@rsdoctor/core 1.5.11 → 2.0.0-alpha.0

package/dist/inner-plugins/plugins/index.js

@@ -8,5 +8,4 @@ export * from "./base.js";
 export * from "./bundle.js";
 export * from "./ensureModulesChunkGraph.js";
 export * from "./rules.js";
-export * from "./bundleTagPlugin.js";
 export * from "./resolver.js";

package/dist/inner-plugins/plugins/loader.cjs

@@ -148,7 +148,7 @@ class InternalLoaderPlugin extends external_base_cjs_namespaceObject.InternalBas
                 if (compiler.isChild()) return;
                 compiler.options.module.rules = this.getInterceptRules(compiler, compiler.options.module.rules);
                 this.sdk.addClientRoutes([
-                    types_namespaceObject.Manifest.RsdoctorManifestClientRoutes.WebpackLoaders
+                    types_namespaceObject.Manifest.RsdoctorManifestClientRoutes.Loaders
                 ]);
             } finally{
                 (0, logger_namespaceObject.timeEnd)('InternalLoaderPlugin.afterPlugins');

package/dist/inner-plugins/plugins/loader.js

@@ -109,7 +109,7 @@ class InternalLoaderPlugin extends InternalBasePlugin {
                 if (compiler.isChild()) return;
                 compiler.options.module.rules = this.getInterceptRules(compiler, compiler.options.module.rules);
                 this.sdk.addClientRoutes([
-                    Manifest.RsdoctorManifestClientRoutes.WebpackLoaders
+                    Manifest.RsdoctorManifestClientRoutes.Loaders
                 ]);
             } finally{
                 timeEnd('InternalLoaderPlugin.afterPlugins');

package/dist/inner-plugins/plugins/plugins.cjs

@@ -48,7 +48,7 @@ class InternalPluginsPlugin extends external_base_cjs_namespaceObject.InternalBa
                 if (compiler.isChild()) return;
                 index_cjs_namespaceObject.Utils.interceptCompilerHooks(compiler, (name, hook)=>(0, external_utils_index_cjs_namespaceObject.interceptPluginHook)(this.sdk, name, hook));
                 this.sdk.addClientRoutes([
-                    types_namespaceObject.Manifest.RsdoctorManifestClientRoutes.WebpackPlugins
+                    types_namespaceObject.Manifest.RsdoctorManifestClientRoutes.Plugins
                 ]);
             } finally{
                 (0, logger_namespaceObject.timeEnd)('InternalPluginsPlugin.afterPlugins');

package/dist/inner-plugins/plugins/plugins.js

@@ -21,7 +21,7 @@ class InternalPluginsPlugin extends InternalBasePlugin {
                 if (compiler.isChild()) return;
                 Utils.interceptCompilerHooks(compiler, (name, hook)=>interceptPluginHook(this.sdk, name, hook));
                 this.sdk.addClientRoutes([
-                    Manifest.RsdoctorManifestClientRoutes.WebpackPlugins
+                    Manifest.RsdoctorManifestClientRoutes.Plugins
                 ]);
             } finally{
                 timeEnd('InternalPluginsPlugin.afterPlugins');

package/dist/inner-plugins/plugins/progress.cjs

@@ -33,22 +33,20 @@ class InternalProgressPlugin extends external_base_cjs_namespaceObject.InternalB
     apply(compiler) {
         const { sdk, currentProgress } = this;
         if (compiler.webpack && compiler.webpack.ProgressPlugin) {
-            const progress = new compiler.webpack.ProgressPlugin({
-                handler (percentage, msg) {
-                    currentProgress.percentage = percentage;
-                    currentProgress.message = msg || '';
-                    const api = types_namespaceObject.SDK.ServerAPI.APIExtends.GetCompileProgress;
-                    try {
-                        sdk.server.sendAPIDataToClient(api, {
-                            req: {
-                                api,
-                                body: void 0
-                            },
-                            res: currentProgress
-                        });
-                    } catch (e) {
-                        logger_namespaceObject.logger.debug(e);
-                    }
+            const progress = new compiler.webpack.ProgressPlugin((percentage, msg)=>{
+                currentProgress.percentage = percentage;
+                currentProgress.message = msg || '';
+                const api = types_namespaceObject.SDK.ServerAPI.APIExtends.GetCompileProgress;
+                try {
+                    sdk.server.sendAPIDataToClient(api, {
+                        req: {
+                            api,
+                            body: void 0
+                        },
+                        res: currentProgress
+                    });
+                } catch (e) {
+                    logger_namespaceObject.logger.debug(e);
                 }
             });
             progress.apply(compiler);

package/dist/inner-plugins/plugins/progress.d.cts

@@ -1,7 +1,7 @@
 import { SDK } from '@rsdoctor/types';
 import type { Plugin } from '@rsdoctor/types';
 import { InternalBasePlugin } from './base';
-export declare class InternalProgressPlugin<T extends Plugin.BaseCompilerType<'webpack'>> extends InternalBasePlugin<T> {
+export declare class InternalProgressPlugin<T extends Plugin.BaseCompilerType<'rspack'>> extends InternalBasePlugin<T> {
     readonly name = "progress";
     protected currentProgress: SDK.ServerAPI.InferResponseType<SDK.ServerAPI.APIExtends.GetCompileProgress>;
     apply(compiler: T): void;

package/dist/inner-plugins/plugins/progress.d.ts

@@ -1,7 +1,7 @@
 import { SDK } from '@rsdoctor/types';
 import type { Plugin } from '@rsdoctor/types';
 import { InternalBasePlugin } from './base.js';
-export declare class InternalProgressPlugin<T extends Plugin.BaseCompilerType<'webpack'>> extends InternalBasePlugin<T> {
+export declare class InternalProgressPlugin<T extends Plugin.BaseCompilerType<'rspack'>> extends InternalBasePlugin<T> {
     readonly name = "progress";
     protected currentProgress: SDK.ServerAPI.InferResponseType<SDK.ServerAPI.APIExtends.GetCompileProgress>;
     apply(compiler: T): void;

package/dist/inner-plugins/plugins/progress.js

@@ -6,22 +6,20 @@ class InternalProgressPlugin extends InternalBasePlugin {
     apply(compiler) {
         const { sdk, currentProgress } = this;
         if (compiler.webpack && compiler.webpack.ProgressPlugin) {
-            const progress = new compiler.webpack.ProgressPlugin({
-                handler (percentage, msg) {
-                    currentProgress.percentage = percentage;
-                    currentProgress.message = msg || '';
-                    const api = SDK.ServerAPI.APIExtends.GetCompileProgress;
-                    try {
-                        sdk.server.sendAPIDataToClient(api, {
-                            req: {
-                                api,
-                                body: void 0
-                            },
-                            res: currentProgress
-                        });
-                    } catch (e) {
-                        logger.debug(e);
-                    }
+            const progress = new compiler.webpack.ProgressPlugin((percentage, msg)=>{
+                currentProgress.percentage = percentage;
+                currentProgress.message = msg || '';
+                const api = SDK.ServerAPI.APIExtends.GetCompileProgress;
+                try {
+                    sdk.server.sendAPIDataToClient(api, {
+                        req: {
+                            api,
+                            body: void 0
+                        },
+                        res: currentProgress
+                    });
+                } catch (e) {
+                    logger.debug(e);
                 }
             });
             progress.apply(compiler);

package/dist/inner-plugins/plugins/resolver.d.cts

@@ -1,6 +1,5 @@
 import { Plugin } from '@rsdoctor/types';
 import { InternalBasePlugin } from './base';
-import type { Compiler as WebpackCompiler } from 'webpack';
 export declare class InternalResolverPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
     readonly name = "resolver";
     protected resolveDataMap: Map<string, {
@@ -9,5 +8,5 @@ export declare class InternalResolverPlugin<T extends Plugin.BaseCompiler> exten
         request: string;
     }>;
     apply(compiler: T): void;
-    protected handleNormalModuleFactory: (normalModuleFactory: Plugin.RspackNormalModuleFactory | ReturnType<WebpackCompiler["createNormalModuleFactory"]>) => void;
+    protected handleNormalModuleFactory: (normalModuleFactory: Plugin.RspackNormalModuleFactory) => void;
 }

package/dist/inner-plugins/plugins/resolver.d.ts

@@ -1,6 +1,5 @@
 import { Plugin } from '@rsdoctor/types';
 import { InternalBasePlugin } from './base.js';
-import type { Compiler as WebpackCompiler } from 'webpack';
 export declare class InternalResolverPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
     readonly name = "resolver";
     protected resolveDataMap: Map<string, {
@@ -9,5 +8,5 @@ export declare class InternalResolverPlugin<T extends Plugin.BaseCompiler> exten
         request: string;
     }>;
     apply(compiler: T): void;
-    protected handleNormalModuleFactory: (normalModuleFactory: Plugin.RspackNormalModuleFactory | ReturnType<WebpackCompiler["createNormalModuleFactory"]>) => void;
+    protected handleNormalModuleFactory: (normalModuleFactory: Plugin.RspackNormalModuleFactory) => void;
 }

package/dist/inner-plugins/plugins/rules.cjs

@@ -54,16 +54,16 @@ class InternalRulesPlugin extends external_base_cjs_namespaceObject.InternalBase
                 }));
             const errors = validateErrors.filter((item)=>'Error' === item.level);
             const warnings = validateErrors.filter((item)=>'Warn' === item.level);
-            const toWebpackError = (err)=>err.toError();
+            const toRspackError = (err)=>err.toError();
             result.replace.forEach((item)=>{
                 if (Array.isArray(compilation.errors) && compilation.errors.includes(item)) (0, compat_namespaceObject.pull)(compilation.errors, item);
                 if (Array.isArray(compilation.warnings) && compilation.warnings.includes(item)) (0, compat_namespaceObject.pull)(compilation.warnings, item);
             });
             if (Array.isArray(compilation.errors)) errors.forEach((err)=>{
-                compilation.warnings.push(toWebpackError(err));
+                compilation.errors.push(toRspackError(err));
             });
             if (Array.isArray(compilation.warnings)) warnings.forEach((err)=>{
-                compilation.warnings.push(toWebpackError(err));
+                compilation.warnings.push(toRspackError(err));
             });
             this.sdk.reportError(validateErrors);
             await linter.afterValidate({

package/dist/inner-plugins/plugins/rules.js

@@ -27,16 +27,16 @@ class InternalRulesPlugin extends InternalBasePlugin {
                 }));
             const errors = validateErrors.filter((item)=>'Error' === item.level);
             const warnings = validateErrors.filter((item)=>'Warn' === item.level);
-            const toWebpackError = (err)=>err.toError();
+            const toRspackError = (err)=>err.toError();
             result.replace.forEach((item)=>{
                 if (Array.isArray(compilation.errors) && compilation.errors.includes(item)) pull(compilation.errors, item);
                 if (Array.isArray(compilation.warnings) && compilation.warnings.includes(item)) pull(compilation.warnings, item);
             });
             if (Array.isArray(compilation.errors)) errors.forEach((err)=>{
-                compilation.warnings.push(toWebpackError(err));
+                compilation.errors.push(toRspackError(err));
             });
             if (Array.isArray(compilation.warnings)) warnings.forEach((err)=>{
-                compilation.warnings.push(toWebpackError(err));
+                compilation.warnings.push(toRspackError(err));
             });
             this.sdk.reportError(validateErrors);
             await linter.afterValidate({

package/dist/inner-plugins/utils/config.cjs

@@ -61,7 +61,6 @@ function getDefaultOutput() {
 function getDefaultSupports() {
     return {
         parseBundle: true,
-        banner: void 0,
         gzip: true
     };
 }

package/dist/inner-plugins/utils/config.d.cts

@@ -1,5 +1,5 @@
 import { RsdoctorRspackPluginOptions, RsdoctorRspackPluginOptionsNormalized } from '../../types';
 import { Linter, Plugin, SDK } from '@rsdoctor/types';
-export declare function normalizeUserConfig<Rules extends Linter.ExtendRuleData[]>(config?: Plugin.RsdoctorWebpackPluginOptions<Rules>): Plugin.RsdoctorPluginOptionsNormalized<Rules>;
+export declare function normalizeUserConfig<Rules extends Linter.ExtendRuleData[]>(config?: Plugin.RsdoctorRspackPluginOptions<Rules>): Plugin.RsdoctorPluginOptionsNormalized<Rules>;
 export declare const normalizeReportType: (reportCodeType: Plugin.IReportCodeType | Plugin.NewReportCodeType, mode: keyof typeof SDK.IMode) => SDK.ToDataType;
 export declare function normalizeRspackUserOptions<Rules extends Linter.ExtendRuleData[]>(options: RsdoctorRspackPluginOptions<Rules>): RsdoctorRspackPluginOptionsNormalized<Rules>;

package/dist/inner-plugins/utils/config.d.ts

@@ -1,5 +1,5 @@
 import { RsdoctorRspackPluginOptions, RsdoctorRspackPluginOptionsNormalized } from '../../types/index.js';
 import { Linter, Plugin, SDK } from '@rsdoctor/types';
-export declare function normalizeUserConfig<Rules extends Linter.ExtendRuleData[]>(config?: Plugin.RsdoctorWebpackPluginOptions<Rules>): Plugin.RsdoctorPluginOptionsNormalized<Rules>;
+export declare function normalizeUserConfig<Rules extends Linter.ExtendRuleData[]>(config?: Plugin.RsdoctorRspackPluginOptions<Rules>): Plugin.RsdoctorPluginOptionsNormalized<Rules>;
 export declare const normalizeReportType: (reportCodeType: Plugin.IReportCodeType | Plugin.NewReportCodeType, mode: keyof typeof SDK.IMode) => SDK.ToDataType;
 export declare function normalizeRspackUserOptions<Rules extends Linter.ExtendRuleData[]>(options: RsdoctorRspackPluginOptions<Rules>): RsdoctorRspackPluginOptionsNormalized<Rules>;

package/dist/inner-plugins/utils/config.js

@@ -22,7 +22,6 @@ function getDefaultOutput() {
 function getDefaultSupports() {
     return {
         parseBundle: true,
-        banner: void 0,
         gzip: true
     };
 }

package/dist/inner-plugins/utils/loader.cjs

@@ -191,10 +191,10 @@ async function reportLoader(ctx, start, startHRTime, isPitch, sync, code, err, r
     }
     await Promise.all([
         common_namespaceObject.Fetch.postJSON(`${host}${types_namespaceObject.SDK.ServerAPI.API.ReportLoader}`, loaderData, 8888).catch((err)=>{
-            logger_namespaceObject.logger.debug(`${err.message}`, '[WebpackPlugin.ReportLoader][error]');
+            logger_namespaceObject.logger.debug(`${err.message}`, '[RspackPlugin.ReportLoader][error]');
         }),
         common_namespaceObject.Fetch.postJSON(`${host}${types_namespaceObject.SDK.ServerAPI.API.ReportSourceMap}`, sourceMapData, 8888).catch((err)=>{
-            logger_namespaceObject.logger.debug(`${err.message}`, '[WebpackPlugin.ReportSourceMap][error]');
+            logger_namespaceObject.logger.debug(`${err.message}`, '[RspackPlugin.ReportSourceMap][error]');
         })
     ]);
     return loaderData;

package/dist/inner-plugins/utils/loader.js

@@ -149,10 +149,10 @@ async function reportLoader(ctx, start, startHRTime, isPitch, sync, code, err, r
     }
     await Promise.all([
         Fetch.postJSON(`${host}${SDK.ServerAPI.API.ReportLoader}`, loaderData, 8888).catch((err)=>{
-            logger.debug(`${err.message}`, '[WebpackPlugin.ReportLoader][error]');
+            logger.debug(`${err.message}`, '[RspackPlugin.ReportLoader][error]');
         }),
         Fetch.postJSON(`${host}${SDK.ServerAPI.API.ReportSourceMap}`, sourceMapData, 8888).catch((err)=>{
-            logger.debug(`${err.message}`, '[WebpackPlugin.ReportSourceMap][error]');
+            logger.debug(`${err.message}`, '[RspackPlugin.ReportSourceMap][error]');
         })
     ]);
     return loaderData;

package/dist/inner-plugins/utils/normalize-config.d.cts

@@ -1,6 +1,5 @@
 import { Config, Plugin, SDK } from '@rsdoctor/types';
 import type { RuleSetCondition as RspackRuleSetCondition, RuleSetRule as RspackRuleSetRule } from '@rspack/core';
-import { RuleSetCondition as WebpackRuleSetCondition, RuleSetConditionAbsolute as WebpackRuleSetConditionAbsolute, RuleSetRule as WebpackRuleSetRule } from 'webpack';
 /**
  * Process mode-specific configurations with priority logic
  */
@@ -22,9 +21,7 @@ export declare function convertReportCodeTypeObject(reportCodeType: any): Config
  * properly serialized to JSON.
  *
  * @param item - The rule set condition to make serializable. Can be:
- *   - RspackRuleSetCondition: Rspack-specific rule conditions
- *   - WebpackRuleSetConditionAbsolute: Webpack absolute rule conditions
- *   - WebpackRuleSetCondition: Webpack rule conditions
+ *   - RspackRuleSetCondition: Rspack rule conditions
  *   - void: Undefined or null values
  *
  * @example
@@ -36,5 +33,5 @@ export declare function convertReportCodeTypeObject(reportCodeType: any): Config
  * JSON.stringify(condition); // '"/\\.js$/"'
  * ```
  */
-export declare function makeRuleSetSerializable(item: RspackRuleSetCondition | WebpackRuleSetConditionAbsolute | WebpackRuleSetCondition | void): void;
-export declare function makeRulesSerializable(rules: Plugin.RuleSetRule[] | RspackRuleSetRule['oneOf'] | WebpackRuleSetRule['oneOf']): void;
+export declare function makeRuleSetSerializable(item: RspackRuleSetCondition | void): void;
+export declare function makeRulesSerializable(rules: Plugin.RuleSetRule[] | RspackRuleSetRule['oneOf']): void;

package/dist/inner-plugins/utils/normalize-config.d.ts

@@ -1,6 +1,5 @@
 import { Config, Plugin, SDK } from '@rsdoctor/types';
 import type { RuleSetCondition as RspackRuleSetCondition, RuleSetRule as RspackRuleSetRule } from '@rspack/core';
-import { RuleSetCondition as WebpackRuleSetCondition, RuleSetConditionAbsolute as WebpackRuleSetConditionAbsolute, RuleSetRule as WebpackRuleSetRule } from 'webpack';
 /**
  * Process mode-specific configurations with priority logic
  */
@@ -22,9 +21,7 @@ export declare function convertReportCodeTypeObject(reportCodeType: any): Config
  * properly serialized to JSON.
  *
  * @param item - The rule set condition to make serializable. Can be:
- *   - RspackRuleSetCondition: Rspack-specific rule conditions
- *   - WebpackRuleSetConditionAbsolute: Webpack absolute rule conditions
- *   - WebpackRuleSetCondition: Webpack rule conditions
+ *   - RspackRuleSetCondition: Rspack rule conditions
  *   - void: Undefined or null values
  *
  * @example
@@ -36,5 +33,5 @@ export declare function convertReportCodeTypeObject(reportCodeType: any): Config
  * JSON.stringify(condition); // '"/\\.js$/"'
  * ```
  */
-export declare function makeRuleSetSerializable(item: RspackRuleSetCondition | WebpackRuleSetConditionAbsolute | WebpackRuleSetCondition | void): void;
-export declare function makeRulesSerializable(rules: Plugin.RuleSetRule[] | RspackRuleSetRule['oneOf'] | WebpackRuleSetRule['oneOf']): void;
+export declare function makeRuleSetSerializable(item: RspackRuleSetCondition | void): void;
+export declare function makeRulesSerializable(rules: Plugin.RuleSetRule[] | RspackRuleSetRule['oneOf']): void;

package/dist/rules/rules/cjs-require/index.cjs

@@ -57,12 +57,12 @@ const rule = (0, external_rule_cjs_namespaceObject.defineRule)(()=>({
                     issuerModule: {
                         id: dep.module.id,
                         path: dep.module.path,
-                        webpackId: dep.module.webpackId
+                        identifier: dep.module.identifier
                     },
                     requiredModule: {
                         id: requiredModule.id,
                         path: requiredModule.path,
-                        webpackId: requiredModule.webpackId
+                        identifier: requiredModule.identifier
                     },
                     request: dep.request
                 };

package/dist/rules/rules/cjs-require/index.js

@@ -30,12 +30,12 @@ const rule = defineRule(()=>({
                     issuerModule: {
                         id: dep.module.id,
                         path: dep.module.path,
-                        webpackId: dep.module.webpackId
+                        identifier: dep.module.identifier
                     },
                     requiredModule: {
                         id: requiredModule.id,
                         path: requiredModule.path,
-                        webpackId: requiredModule.webpackId
+                        identifier: requiredModule.identifier
                     },
                     request: dep.request
                 };

package/dist/rules/rules/esm-resolved-to-cjs/index.cjs

@@ -52,28 +52,88 @@ function normalizePathForCompare(filePath) {
     const cleanPath = splitIndex === 1 / 0 ? filePath : filePath.slice(0, splitIndex);
     return external_path_default().normalize(cleanPath);
 }
-function extractEsmEntry(pkgJson, pkgRoot) {
-    const { exports: exportsField, module: moduleField } = pkgJson;
-    if (null !== exportsField && 'object' == typeof exportsField) {
-        const exports1 = exportsField;
-        const dotEntry = exports1['.'];
-        if (null !== dotEntry && 'object' == typeof dotEntry) {
-            const dot = dotEntry;
-            const importEntry = dot['import'];
-            if ('string' == typeof importEntry) return external_path_default().resolve(pkgRoot, importEntry);
-            if (null !== importEntry && 'object' == typeof importEntry) {
-                const nested = importEntry['default'];
-                if ('string' == typeof nested) return external_path_default().resolve(pkgRoot, nested);
-            }
-        }
-        const topImport = exports1['import'];
-        if ('string' == typeof topImport) return external_path_default().resolve(pkgRoot, topImport);
-        if (null !== topImport && 'object' == typeof topImport) {
-            const nested = topImport['default'];
-            if ('string' == typeof nested) return external_path_default().resolve(pkgRoot, nested);
-        }
+function isDefinitelyEsmFile(filePath) {
+    return '.mjs' === external_path_default().extname(normalizePathForCompare(filePath));
+}
+function isDeclaredEsmEntry(filePath, esmEntries, toRealPath) {
+    const realPath = toRealPath(filePath);
+    return esmEntries.some((esmEntry)=>realPath === toRealPath(esmEntry));
+}
+function isRecord(value) {
+    return null !== value && 'object' == typeof value && !Array.isArray(value);
+}
+function substituteExportPattern(target, wildcard) {
+    return target.replace(/\*/g, wildcard);
+}
+function toPackagePath(pkgRoot, target, wildcard) {
+    return external_path_default().resolve(pkgRoot, substituteExportPattern(target, wildcard));
+}
+function collectStringTargets(value, wildcard) {
+    if ('string' == typeof value) return [
+        substituteExportPattern(value, wildcard)
+    ];
+    if (Array.isArray(value)) return value.flatMap((item)=>collectStringTargets(item, wildcard));
+    if (!isRecord(value)) return [];
+    return Object.values(value).flatMap((child)=>collectStringTargets(child, wildcard));
+}
+function collectEsmTargets(exportEntry, pkgRoot, wildcard) {
+    const entries = new Set();
+    const addTargets = (value)=>{
+        for (const target of collectStringTargets(value, wildcard))entries.add(toPackagePath(pkgRoot, target, ''));
+    };
+    const visit = (value)=>{
+        if ('string' == typeof value || Array.isArray(value)) return void addTargets(value);
+        if (!isRecord(value)) return;
+        addTargets(value['import']);
+        addTargets(value['module']);
+        for (const child of Object.values(value))if (isRecord(child) || Array.isArray(child)) visit(child);
+    };
+    visit(exportEntry);
+    return entries;
+}
+function hasSubpathExportKeys(exports1) {
+    return Object.keys(exports1).some((key)=>'.' === key || key.startsWith('./'));
+}
+function matchPatternExportKey(patternKey, exportKey) {
+    const wildcardIndex = patternKey.indexOf('*');
+    if (wildcardIndex < 0) return null;
+    const prefix = patternKey.slice(0, wildcardIndex);
+    const suffix = patternKey.slice(wildcardIndex + 1);
+    if (!exportKey.startsWith(prefix) || !exportKey.endsWith(suffix)) return null;
+    return exportKey.slice(prefix.length, exportKey.length - suffix.length);
+}
+function resolveExportEntry(exports1, exportKey) {
+    if (Object.prototype.hasOwnProperty.call(exports1, exportKey)) return {
+        value: exports1[exportKey],
+        wildcard: ''
+    };
+    for (const [key, value] of Object.entries(exports1)){
+        const wildcard = matchPatternExportKey(key, exportKey);
+        if (null !== wildcard) return {
+            value,
+            wildcard
+        };
     }
-    if ('string' == typeof moduleField) return external_path_default().resolve(pkgRoot, moduleField);
+    return null;
+}
+function resolveExportEntryForKey(exportsField, exportKey) {
+    if (!isRecord(exportsField)) return null;
+    if (!hasSubpathExportKeys(exportsField)) return '.' === exportKey ? {
+        value: exportsField,
+        wildcard: ''
+    } : null;
+    return resolveExportEntry(exportsField, exportKey);
+}
+function extractEsmEntries(pkgJson, pkgRoot, exportKey) {
+    const { exports: exportsField, module: moduleField } = pkgJson;
+    const resolvedExport = resolveExportEntryForKey(exportsField, exportKey);
+    const entries = resolvedExport ? collectEsmTargets(resolvedExport.value, pkgRoot, resolvedExport.wildcard) : new Set();
+    if ('.' === exportKey && 'string' == typeof moduleField) entries.add(external_path_default().resolve(pkgRoot, moduleField));
+    return entries;
+}
+function getExportKeyFromRequest(packageName, request) {
+    if (request === packageName) return '.';
+    if (request.startsWith(`${packageName}/`)) return `.${request.slice(packageName.length)}`;
     return null;
 }
 const rule = (0, external_rule_cjs_namespaceObject.defineRule)(()=>({
@@ -121,10 +181,15 @@ const rule = (0, external_rule_cjs_namespaceObject.defineRule)(()=>({
                 const pkg = packageGraph.getPackageByModule(dep.dependency);
                 if (!pkg?.root) continue;
                 const pkgJson = readPkgJson(pkg.root);
-                const esmEntry = !ruleConfig.ignore.some((p)=>pkg.name.includes(p)) && pkgJson && extractEsmEntry(pkgJson, pkg.root);
-                if (!esmEntry) continue;
+                if (ruleConfig.ignore.some((p)=>pkg.name.includes(p)) || !pkgJson) continue;
+                const exportKey = getExportKeyFromRequest(pkg.name, dep.request);
+                if (!exportKey) continue;
+                const esmEntries = extractEsmEntries(pkgJson, pkg.root, exportKey);
+                if (0 === esmEntries.size) continue;
+                const esmEntryList = Array.from(esmEntries);
                 const resolvedModuleRealPath = toRealPath(dep.dependency.path);
-                if (resolvedModuleRealPath === toRealPath(esmEntry)) continue;
+                if (isDefinitelyEsmFile(resolvedModuleRealPath)) continue;
+                if (isDeclaredEsmEntry(resolvedModuleRealPath, esmEntryList, toRealPath)) continue;
                 const groupKey = `${pkg.name}::${resolvedModuleRealPath}`;
                 const issuer = {
                     id: dep.module.id,
@@ -135,11 +200,11 @@ const rule = (0, external_rule_cjs_namespaceObject.defineRule)(()=>({
                 else groups.set(groupKey, {
                     packageName: pkg.name,
                     packageVersion: pkg.version,
-                    esmEntry,
+                    esmEntry: esmEntryList[0],
                     resolvedModule: {
                         id: dep.dependency.id,
                         path: dep.dependency.path,
-                        webpackId: dep.dependency.webpackId
+                        identifier: dep.dependency.identifier
                     },
                     issuers: [
                         issuer