@atlaspack/core 2.24.1 → 2.24.2-dev-ts-project-refs-d30e9754f.0

package/dist/requests/TargetRequest.js

@@ -0,0 +1,1310 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TargetResolver = void 0;
+exports.default = createTargetRequest;
+exports.skipTarget = skipTarget;
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("@atlaspack/utils");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+const Environment_1 = require("../Environment");
+const AtlaspackConfigRequest_1 = __importStar(require("./AtlaspackConfigRequest"));
+const browserslist_1 = __importDefault(require("browserslist"));
+const json_sourcemap_1 = require("@mischnic/json-sourcemap");
+const assert_1 = __importDefault(require("assert"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const TargetDescriptor_schema_1 = require("../TargetDescriptor.schema");
+const Environment_2 = require("../public/Environment");
+const utils_2 = require("../utils");
+const projectPath_1 = require("../projectPath");
+const RequestTracker_1 = require("../RequestTracker");
+const EnvironmentManager_1 = require("../EnvironmentManager");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const DEFAULT_DIST_DIRNAME = 'dist';
+const JS_RE = /\.[mc]?js$/;
+const JS_EXTENSIONS = ['.js', '.mjs', '.cjs'];
+const COMMON_TARGETS = {
+    main: {
+        match: JS_RE,
+        extensions: JS_EXTENSIONS,
+    },
+    module: {
+        // module field is always ESM. Don't allow .cjs extension here.
+        match: /\.m?js$/,
+        extensions: ['.js', '.mjs'],
+    },
+    browser: {
+        match: JS_RE,
+        extensions: JS_EXTENSIONS,
+    },
+    types: {
+        match: /\.d\.ts$/,
+        extensions: ['.d.ts'],
+    },
+};
+const DEFAULT_ENGINES = {
+    node: 'current',
+    browsers: [
+        'last 1 Chrome version',
+        'last 1 Safari version',
+        'last 1 Firefox version',
+        'last 1 Edge version',
+    ],
+};
+const type = 'target_request';
+function createTargetRequest(input) {
+    return {
+        id: `${type}:${(0, utils_1.hashObject)(input)}`,
+        type: RequestTracker_1.requestTypes.target_request,
+        run,
+        input,
+    };
+}
+function skipTarget(targetName, exclusiveTarget, descriptorSource) {
+    //  We skip targets if they have a descriptor.source and don't match the current exclusiveTarget
+    //  They will be handled by a separate resolvePackageTargets call from their Entry point
+    //  but with exclusiveTarget set.
+    return exclusiveTarget == null
+        ? descriptorSource != null
+        : targetName !== exclusiveTarget;
+}
+async function run({ input, api, options }) {
+    let targetResolver = new TargetResolver(api, (0, utils_2.optionsProxy)(options, api.invalidateOnOptionChange));
+    let targets = await targetResolver.resolve((0, projectPath_1.fromProjectPath)(options.projectRoot, input.packagePath), input.target);
+    // Filter targets based on allowExplicitTargetEntries feature flag
+    if ((0, feature_flags_1.getFeatureFlag)('allowExplicitTargetEntries') &&
+        options.targets &&
+        // Only explicit targets are allowed (i.e. an object of targets)
+        !Array.isArray(options.targets)) {
+        // Check if ALL targets have sources - only apply new behavior if they do
+        const allTargetsHaveSources = targets.every((t) => t.source);
+        if (allTargetsHaveSources) {
+            // Get the current entry file path relative to project root
+            const currentEntryPath = input.filePath;
+            // Filter targets to only include those whose source matches the current entry
+            targets = targets.filter((target) => {
+                // Handle both string and array sources
+                const sources = Array.isArray(target.source)
+                    ? target.source
+                    : [target.source];
+                // Check if current entry matches any of the target sources
+                return sources.some((source) => {
+                    const targetSourcePath = (0, projectPath_1.toProjectPath)(options.projectRoot, path_1.default.resolve((0, projectPath_1.fromProjectPath)(options.projectRoot, input.packagePath), (0, nullthrows_1.default)(source, 'Source must be not be undefined when specified')));
+                    return targetSourcePath === currentEntryPath;
+                });
+            });
+        }
+        else {
+            // If not all targets have sources, fall back to old behavior (skip targets with sources)
+            targets = targets.filter((target) => !target.source);
+        }
+    }
+    assertTargetsAreNotEntries(targets, input, options);
+    let configResult = (0, nullthrows_1.default)(await api.runRequest((0, AtlaspackConfigRequest_1.default)()));
+    let atlaspackConfig = (0, AtlaspackConfigRequest_1.getCachedAtlaspackConfig)(configResult, options);
+    // Find named pipelines for each target.
+    let pipelineNames = new Set(atlaspackConfig.getNamedPipelines());
+    for (let target of targets) {
+        if (pipelineNames.has(target.name)) {
+            target.pipeline = target.name;
+        }
+    }
+    if (options.logLevel === 'verbose') {
+        await debugResolvedTargets(input, targets, targetResolver.targetInfo, options);
+    }
+    return targets;
+}
+class TargetResolver {
+    constructor(api, options) {
+        this.api = api;
+        this.fs = options.inputFS;
+        this.options = options;
+        this.targetInfo = new Map();
+    }
+    async resolve(rootDir, exclusiveTarget) {
+        let optionTargets = this.options.targets;
+        if (exclusiveTarget != null && optionTargets == null) {
+            optionTargets = [exclusiveTarget];
+        }
+        let packageTargets = await this.resolvePackageTargets(rootDir, exclusiveTarget);
+        let targets;
+        if (optionTargets) {
+            if (Array.isArray(optionTargets)) {
+                if (optionTargets.length === 0) {
+                    throw new diagnostic_1.default({
+                        diagnostic: {
+                            message: `Targets option is an empty array`,
+                            origin: '@atlaspack/core',
+                        },
+                    });
+                }
+                // Only build the intersection of the exclusive target and option targets.
+                if (exclusiveTarget != null) {
+                    optionTargets = optionTargets.filter((target) => target === exclusiveTarget);
+                }
+                // If an array of strings is passed, it's a filter on the resolved package
+                // targets. Load them, and find the matching targets.
+                // @ts-expect-error TS2322
+                targets = optionTargets
+                    .map((target) => {
+                    // null means skipped.
+                    if (!packageTargets.has(target)) {
+                        throw new diagnostic_1.default({
+                            diagnostic: {
+                                message: (0, diagnostic_1.md) `Could not find target with name "${target}"`,
+                                origin: '@atlaspack/core',
+                            },
+                        });
+                    }
+                    return packageTargets.get(target);
+                })
+                    .filter(Boolean);
+            }
+            else {
+                // Otherwise, it's an object map of target descriptors (similar to those
+                // in package.json). Adapt them to native targets.
+                targets = Object.entries(optionTargets)
+                    .map(([name, _descriptor]) => {
+                    let { distDir, ...descriptor } = parseDescriptor(name, _descriptor, null, JSON.stringify({ targets: optionTargets }, null, '\t'));
+                    if (distDir == null) {
+                        let optionTargetsString = JSON.stringify(optionTargets, null, '\t');
+                        throw new diagnostic_1.default({
+                            diagnostic: {
+                                message: (0, diagnostic_1.md) `Missing distDir for target "${name}"`,
+                                origin: '@atlaspack/core',
+                                codeFrames: [
+                                    {
+                                        code: optionTargetsString,
+                                        codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(optionTargetsString || '', [
+                                            {
+                                                key: `/${name}`,
+                                                type: 'value',
+                                            },
+                                        ]),
+                                    },
+                                ],
+                            },
+                        });
+                    }
+                    let target = {
+                        name,
+                        distDir: (0, projectPath_1.toProjectPath)(this.options.projectRoot, path_1.default.resolve(this.fs.cwd(), distDir)),
+                        publicUrl: descriptor.publicUrl ??
+                            this.options.defaultTargetOptions.publicUrl,
+                        env: (0, Environment_1.createEnvironment)({
+                            engines: descriptor.engines,
+                            context: descriptor.context,
+                            isLibrary: descriptor.isLibrary ??
+                                this.options.defaultTargetOptions.isLibrary,
+                            includeNodeModules: descriptor.includeNodeModules,
+                            outputFormat: descriptor.outputFormat ??
+                                this.options.defaultTargetOptions.outputFormat,
+                            shouldOptimize: this.options.defaultTargetOptions.shouldOptimize &&
+                                descriptor.optimize !== false,
+                            shouldScopeHoist: this.options.defaultTargetOptions.shouldScopeHoist &&
+                                descriptor.scopeHoist !== false,
+                            sourceMap: normalizeSourceMap(this.options, descriptor.sourceMap),
+                            unstableSingleFileOutput: descriptor.__unstable_singleFileOutput,
+                            customEnv: descriptor.env,
+                        }),
+                    };
+                    if (descriptor.distEntry != null) {
+                        target.distEntry = descriptor.distEntry;
+                    }
+                    if (descriptor.source != null) {
+                        target.source = descriptor.source;
+                    }
+                    return target;
+                })
+                    .filter((target) => ((0, feature_flags_1.getFeatureFlag)('allowExplicitTargetEntries') &&
+                    this.options.entries.length !== 0) ||
+                    !skipTarget(target.name, exclusiveTarget, target.source));
+                // Apply allowExplicitTargetEntries filtering logic
+                if ((0, feature_flags_1.getFeatureFlag)('allowExplicitTargetEntries')) {
+                    // Check if ALL targets have sources - only apply new behavior if they do
+                    const allTargetsHaveSources = targets.every((t) => t.source);
+                    if (!allTargetsHaveSources) {
+                        // If not all targets have sources, fall back to old behavior (skip targets with sources)
+                        targets = targets.filter((target) => !target.source);
+                    }
+                }
+            }
+            let serve = this.options.serveOptions;
+            if (serve && targets.length > 0) {
+                // In serve mode, we only support a single browser target. If the user
+                // provided more than one, or the matching target is not a browser, throw.
+                if (targets.length > 1) {
+                    throw new diagnostic_1.default({
+                        diagnostic: {
+                            message: `More than one target is not supported in serve mode`,
+                            origin: '@atlaspack/core',
+                        },
+                    });
+                }
+                if (!Environment_2.BROWSER_ENVS.has((0, EnvironmentManager_1.fromEnvironmentId)(targets[0].env).context)) {
+                    throw new diagnostic_1.default({
+                        diagnostic: {
+                            message: `Only browser targets are supported in serve mode`,
+                            origin: '@atlaspack/core',
+                        },
+                    });
+                }
+                targets[0].distDir = (0, projectPath_1.toProjectPath)(this.options.projectRoot, serve.distDir);
+            }
+        }
+        else {
+            // Explicit targets were not provided. Either use a modern target for server
+            // mode, or simply use the package.json targets.
+            if (this.options.serveOptions) {
+                // In serve mode, we only support a single browser target. Since the user
+                // hasn't specified a target, use one targeting modern browsers for development
+                targets = [
+                    {
+                        name: 'default',
+                        distDir: (0, projectPath_1.toProjectPath)(this.options.projectRoot, this.options.serveOptions.distDir),
+                        publicUrl: this.options.defaultTargetOptions.publicUrl ?? '/',
+                        env: (0, Environment_1.createEnvironment)({
+                            context: 'browser',
+                            engines: {
+                                // @ts-expect-error TS2322
+                                browsers: DEFAULT_ENGINES.browsers,
+                            },
+                            shouldOptimize: this.options.defaultTargetOptions.shouldOptimize,
+                            outputFormat: this.options.defaultTargetOptions.outputFormat,
+                            shouldScopeHoist: this.options.defaultTargetOptions.shouldScopeHoist,
+                            sourceMap: this.options.defaultTargetOptions.sourceMaps
+                                ? {}
+                                : undefined,
+                        }),
+                    },
+                ];
+            }
+            else {
+                // @ts-expect-error TS2322
+                targets = Array.from(packageTargets.values())
+                    .filter(Boolean)
+                    .filter((descriptor) => {
+                    return (descriptor &&
+                        !skipTarget(descriptor.name, exclusiveTarget, descriptor.source));
+                });
+            }
+        }
+        return targets;
+    }
+    async resolvePackageTargets(rootDir, exclusiveTarget) {
+        let rootFile = path_1.default.join(rootDir, 'index');
+        let conf = await (0, utils_1.loadConfig)(this.fs, rootFile, ['package.json'], this.options.projectRoot);
+        let rootFileProject = (0, projectPath_1.toProjectPath)(this.options.projectRoot, rootFile);
+        // Invalidate whenever a package.json file is added.
+        this.api.invalidateOnFileCreate({
+            fileName: 'package.json',
+            aboveFilePath: rootFileProject,
+        });
+        let pkg;
+        let pkgContents;
+        let pkgFilePath;
+        let pkgDir;
+        let pkgMap;
+        if (conf) {
+            pkg = conf.config;
+            let pkgFile = conf.files[0];
+            if (pkgFile == null) {
+                throw new diagnostic_1.default({
+                    diagnostic: {
+                        message: (0, diagnostic_1.md) `Expected package.json file in ${rootDir}`,
+                        origin: '@atlaspack/core',
+                    },
+                });
+            }
+            let _pkgFilePath = (pkgFilePath = pkgFile.filePath); // For Flow
+            pkgDir = path_1.default.dirname(_pkgFilePath);
+            pkgContents = await this.fs.readFile(_pkgFilePath, 'utf8');
+            pkgMap = (0, json_sourcemap_1.parse)(pkgContents, undefined, { tabWidth: 1 });
+            let pp = (0, projectPath_1.toProjectPath)(this.options.projectRoot, _pkgFilePath);
+            this.api.invalidateOnFileUpdate(pp);
+            this.api.invalidateOnFileDelete(pp);
+        }
+        else {
+            pkg = {};
+            pkgDir = this.fs.cwd();
+        }
+        let pkgTargets = pkg.targets || {};
+        let pkgEngines = parseEngines(pkg.engines, pkgFilePath, pkgContents, '/engines', 'Invalid engines in package.json') || {};
+        let browsersLoc = { path: '/engines/browsers' };
+        let nodeLoc = { path: '/engines/node' };
+        if (pkgEngines.browsers == null) {
+            let env = this.options.env.BROWSERSLIST_ENV ??
+                this.options.env.NODE_ENV ??
+                this.options.mode;
+            if (pkg.browserslist != null) {
+                let pkgBrowserslist = pkg.browserslist;
+                let browserslist = typeof pkgBrowserslist === 'object' && !Array.isArray(pkgBrowserslist)
+                    ? pkgBrowserslist[env]
+                    : pkgBrowserslist;
+                pkgEngines = {
+                    ...pkgEngines,
+                    browsers: browserslist,
+                };
+                browsersLoc = { path: '/browserslist' };
+            }
+            else {
+                let browserslistConfig = await (0, utils_1.resolveConfig)(this.fs, path_1.default.join(rootDir, 'index'), ['browserslist', '.browserslistrc'], this.options.projectRoot);
+                this.api.invalidateOnFileCreate({
+                    fileName: 'browserslist',
+                    aboveFilePath: rootFileProject,
+                });
+                this.api.invalidateOnFileCreate({
+                    fileName: '.browserslistrc',
+                    aboveFilePath: rootFileProject,
+                });
+                if (browserslistConfig != null) {
+                    let contents = await this.fs.readFile(browserslistConfig, 'utf8');
+                    let config = browserslist_1.default.parseConfig(contents);
+                    let browserslistBrowsers = config[env] || config.defaults;
+                    let pp = (0, projectPath_1.toProjectPath)(this.options.projectRoot, browserslistConfig);
+                    if (browserslistBrowsers?.length > 0) {
+                        pkgEngines = {
+                            ...pkgEngines,
+                            browsers: browserslistBrowsers,
+                        };
+                        browsersLoc = {
+                            // @ts-expect-error TS2353
+                            message: `(defined in ${path_1.default.relative(process.cwd(), browserslistConfig)})`,
+                        };
+                    }
+                    // Invalidate whenever browserslist config file or relevant environment variables change
+                    this.api.invalidateOnFileUpdate(pp);
+                    this.api.invalidateOnFileDelete(pp);
+                    this.api.invalidateOnEnvChange('BROWSERSLIST_ENV');
+                    this.api.invalidateOnEnvChange('NODE_ENV');
+                }
+            }
+        }
+        let targets = new Map();
+        let node = pkgEngines.node;
+        let browsers = pkgEngines.browsers;
+        let defaultEngines = this.options.defaultTargetOptions.engines;
+        let context = (browsers ?? node == null) ? 'browser' : 'node';
+        if (context === 'browser' && pkgEngines.browsers == null) {
+            pkgEngines = {
+                ...pkgEngines,
+                // @ts-expect-error TS2322
+                browsers: defaultEngines?.browsers ?? DEFAULT_ENGINES.browsers,
+            };
+            // @ts-expect-error TS2353
+            browsersLoc = { message: '(default)' };
+        }
+        else if (context === 'node' && pkgEngines.node == null) {
+            pkgEngines = {
+                ...pkgEngines,
+                node: defaultEngines?.node ?? DEFAULT_ENGINES.node,
+            };
+            // @ts-expect-error TS2353
+            nodeLoc = { message: '(default)' };
+        }
+        // If there is a separate `browser` target, or an `engines.node` field but no browser targets, then
+        // the `main` and `module` targets refer to node, otherwise browser.
+        let mainContext = (pkg.browser ?? pkgTargets.browser ?? (node != null && browsers == null))
+            ? 'node'
+            : 'browser';
+        let mainContextLoc = pkg.browser != null
+            ? {
+                inferred: '/browser',
+                message: '(because a browser field also exists)',
+                type: 'key',
+            }
+            : pkgTargets.browser
+                ? {
+                    inferred: '/targets/browser',
+                    message: '(because a browser target also exists)',
+                    type: 'key',
+                }
+                : node != null && browsers == null
+                    ? nodeLoc.path
+                        ? {
+                            inferred: nodeLoc.path,
+                            message: '(because node engines were defined)',
+                            type: 'key',
+                        }
+                        : nodeLoc
+                    : { message: '(default)' };
+        let moduleContext = (pkg.browser ?? pkgTargets.browser) ? 'browser' : mainContext;
+        let moduleContextLoc = pkg.browser != null
+            ? {
+                inferred: '/browser',
+                message: '(because a browser field also exists)',
+                type: 'key',
+            }
+            : pkgTargets.browser
+                ? {
+                    inferred: '/targets/browser',
+                    message: '(becausea browser target also exists)',
+                    type: 'key',
+                }
+                : mainContextLoc;
+        let getEnginesLoc = (targetName, descriptor) => {
+            let enginesLoc = `/targets/${targetName}/engines`;
+            switch (context) {
+                case 'browser':
+                case 'web-worker':
+                case 'service-worker':
+                case 'worklet': {
+                    if (descriptor.engines) {
+                        return { path: enginesLoc + '/browsers' };
+                    }
+                    else {
+                        return browsersLoc;
+                    }
+                }
+                case 'node': {
+                    if (descriptor.engines) {
+                        return { path: enginesLoc + '/node' };
+                    }
+                    else {
+                        return nodeLoc;
+                    }
+                }
+                case 'electron-main':
+                case 'electron-renderer': {
+                    if (descriptor.engines?.electron != null) {
+                        return { path: enginesLoc + '/electron' };
+                    }
+                    else if (pkgEngines?.electron != null) {
+                        return { path: '/engines/electron' };
+                    }
+                }
+            }
+            return { message: '(default)' };
+        };
+        for (let targetName in COMMON_TARGETS) {
+            let _targetDist;
+            let pointer;
+            if (targetName === 'browser' &&
+                pkg[targetName] != null &&
+                typeof pkg[targetName] === 'object' &&
+                pkg.name) {
+                // The `browser` field can be a file path or an alias map.
+                _targetDist = pkg[targetName][pkg.name];
+                pointer = `/${targetName}/${(0, diagnostic_1.encodeJSONKeyComponent)(pkg.name)}`;
+            }
+            else {
+                // @ts-expect-error TS7053
+                _targetDist = pkg[targetName];
+                pointer = `/${targetName}`;
+            }
+            // For Flow
+            let targetDist = _targetDist;
+            if (typeof targetDist === 'string' || pkgTargets[targetName]) {
+                let distDir;
+                let distEntry;
+                let loc;
+                (0, assert_1.default)(pkgMap != null);
+                let _descriptor = pkgTargets[targetName] ?? {};
+                if (typeof targetDist === 'string') {
+                    distDir = (0, projectPath_1.toProjectPath)(this.options.projectRoot, path_1.default.resolve(pkgDir, path_1.default.dirname(targetDist)));
+                    distEntry = path_1.default.basename(targetDist);
+                    loc = {
+                        filePath: (0, nullthrows_1.default)(pkgFilePath),
+                        ...(0, diagnostic_1.getJSONSourceLocation)(pkgMap.pointers[pointer], 'value'),
+                    };
+                }
+                else {
+                    distDir =
+                        this.options.defaultTargetOptions.distDir ??
+                            (0, projectPath_1.toProjectPath)(this.options.projectRoot, path_1.default.join(pkgDir, DEFAULT_DIST_DIRNAME, targetName));
+                }
+                if (_descriptor == false) {
+                    continue;
+                }
+                let descriptor = parseCommonTargetDescriptor(targetName, _descriptor, pkgFilePath, pkgContents);
+                if (skipTarget(targetName, exclusiveTarget, descriptor.source)) {
+                    targets.set(targetName, null);
+                    continue;
+                }
+                if (distEntry != null &&
+                    // @ts-expect-error TS7053
+                    !COMMON_TARGETS[targetName].match.test(distEntry)) {
+                    let contents = typeof pkgContents === 'string'
+                        ? pkgContents
+                        : JSON.stringify(pkgContents, null, '\t');
+                    let listFormat = new Intl.ListFormat('en-US', { type: 'disjunction' });
+                    let extensions = listFormat.format(
+                    // @ts-expect-error TS7053
+                    COMMON_TARGETS[targetName].extensions);
+                    let ext = path_1.default.extname(distEntry);
+                    throw new diagnostic_1.default({
+                        diagnostic: {
+                            message: (0, diagnostic_1.md) `Unexpected output file type ${ext} in target "${targetName}"`,
+                            origin: '@atlaspack/core',
+                            codeFrames: [
+                                {
+                                    language: 'json',
+                                    filePath: pkgFilePath ?? undefined,
+                                    code: contents,
+                                    codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(contents, [
+                                        {
+                                            key: pointer,
+                                            type: 'value',
+                                            message: `File extension must be ${extensions}`,
+                                        },
+                                    ]),
+                                },
+                            ],
+                            hints: [
+                                `The "${targetName}" field is meant for libraries. If you meant to output a ${ext} file, either remove the "${targetName}" field or choose a different target name.`,
+                            ],
+                            documentationURL: 'https://parceljs.org/features/targets/#library-targets',
+                        },
+                    });
+                }
+                if (descriptor.outputFormat === 'global') {
+                    let contents = typeof pkgContents === 'string'
+                        ? pkgContents
+                        : JSON.stringify(pkgContents, null, '\t');
+                    throw new diagnostic_1.default({
+                        diagnostic: {
+                            message: (0, diagnostic_1.md) `The "global" output format is not supported in the "${targetName}" target.`,
+                            origin: '@atlaspack/core',
+                            codeFrames: [
+                                {
+                                    language: 'json',
+                                    filePath: pkgFilePath ?? undefined,
+                                    code: contents,
+                                    codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(contents, [
+                                        {
+                                            key: `/targets/${targetName}/outputFormat`,
+                                            type: 'value',
+                                        },
+                                    ]),
+                                },
+                            ],
+                            hints: [
+                                `The "${targetName}" field is meant for libraries. The outputFormat must be either "commonjs" or "esmodule". Either change or remove the declared outputFormat.`,
+                            ],
+                            documentationURL: 'https://parceljs.org/features/targets/#library-targets',
+                        },
+                    });
+                }
+                let [inferredOutputFormat, inferredOutputFormatField] = this.inferOutputFormat(distEntry, descriptor, targetName, 
+                // @ts-expect-error TS2345
+                pkg, pkgFilePath, pkgContents);
+                let outputFormat = descriptor.outputFormat ??
+                    this.options.defaultTargetOptions.outputFormat ??
+                    inferredOutputFormat ??
+                    (targetName === 'module' ? 'esmodule' : 'commonjs');
+                let isModule = outputFormat === 'esmodule';
+                if (targetName === 'main' &&
+                    outputFormat === 'esmodule' &&
+                    inferredOutputFormat !== 'esmodule') {
+                    let contents = typeof pkgContents === 'string'
+                        ? pkgContents
+                        : JSON.stringify(pkgContents, null, '\t');
+                    throw new diagnostic_1.default({
+                        diagnostic: {
+                            // prettier-ignore
+                            message: (0, diagnostic_1.md) `Output format "esmodule" cannot be used in the "main" target without a .mjs extension or "type": "module" field.`,
+                            origin: '@atlaspack/core',
+                            codeFrames: [
+                                {
+                                    language: 'json',
+                                    filePath: pkgFilePath ?? undefined,
+                                    code: contents,
+                                    codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(contents, [
+                                        {
+                                            key: `/targets/${targetName}/outputFormat`,
+                                            type: 'value',
+                                            message: 'Declared output format defined here',
+                                        },
+                                        {
+                                            key: '/main',
+                                            type: 'value',
+                                            message: 'Inferred output format defined here',
+                                        },
+                                    ]),
+                                },
+                            ],
+                            hints: [
+                                `Either change the output file extension to .mjs, add "type": "module" to package.json, or remove the declared outputFormat.`,
+                            ],
+                            documentationURL: 'https://parceljs.org/features/targets/#library-targets',
+                        },
+                    });
+                }
+                if (descriptor.scopeHoist === false) {
+                    let contents = typeof pkgContents === 'string'
+                        ? pkgContents
+                        : JSON.stringify(pkgContents, null, '\t');
+                    throw new diagnostic_1.default({
+                        diagnostic: {
+                            message: 'Scope hoisting cannot be disabled for library targets.',
+                            origin: '@atlaspack/core',
+                            codeFrames: [
+                                {
+                                    language: 'json',
+                                    filePath: pkgFilePath ?? undefined,
+                                    code: contents,
+                                    codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(contents, [
+                                        {
+                                            key: `/targets/${targetName}/scopeHoist`,
+                                            type: 'value',
+                                        },
+                                    ]),
+                                },
+                            ],
+                            hints: [
+                                `The "${targetName}" target is meant for libraries. Either remove the "scopeHoist" option, or use a different target name.`,
+                            ],
+                            documentationURL: 'https://parceljs.org/features/targets/#library-targets',
+                        },
+                    });
+                }
+                let context = descriptor.context ??
+                    (targetName === 'browser'
+                        ? 'browser'
+                        : isModule
+                            ? moduleContext
+                            : mainContext);
+                targets.set(targetName, {
+                    name: targetName,
+                    distDir,
+                    distEntry,
+                    publicUrl: descriptor.publicUrl ?? this.options.defaultTargetOptions.publicUrl,
+                    env: (0, Environment_1.createEnvironment)({
+                        engines: descriptor.engines ?? pkgEngines,
+                        // @ts-expect-error TS2322
+                        context,
+                        includeNodeModules: descriptor.includeNodeModules ?? false,
+                        outputFormat,
+                        isLibrary: true,
+                        shouldOptimize: this.options.defaultTargetOptions.shouldOptimize &&
+                            descriptor.optimize === true,
+                        shouldScopeHoist: true,
+                        sourceMap: normalizeSourceMap(this.options, descriptor.sourceMap),
+                    }),
+                    loc: (0, utils_2.toInternalSourceLocation)(this.options.projectRoot, loc),
+                });
+                this.targetInfo.set(targetName, {
+                    output: { path: pointer },
+                    engines: getEnginesLoc(targetName, descriptor),
+                    context: descriptor.context
+                        ? { path: `/targets/${targetName}/context` }
+                        : targetName === 'browser'
+                            ? {
+                                message: '(inferred from target name)',
+                                inferred: pointer,
+                                type: 'key',
+                            }
+                            : isModule
+                                ? moduleContextLoc
+                                : mainContextLoc,
+                    includeNodeModules: descriptor.includeNodeModules
+                        ? { path: `/targets/${targetName}/includeNodeModules`, type: 'key' }
+                        : { message: '(default)' },
+                    outputFormat: descriptor.outputFormat
+                        ? { path: `/targets/${targetName}/outputFormat` }
+                        : inferredOutputFormatField === '/type'
+                            ? {
+                                message: `(inferred from package.json#type)`,
+                                inferred: inferredOutputFormatField,
+                            }
+                            : inferredOutputFormatField != null
+                                ? {
+                                    message: `(inferred from file extension)`,
+                                    inferred: inferredOutputFormatField,
+                                }
+                                : { message: '(default)' },
+                    isLibrary: { message: '(default)' },
+                    shouldOptimize: descriptor.optimize
+                        ? { path: `/targets/${targetName}/optimize` }
+                        : { message: '(default)' },
+                    shouldScopeHoist: { message: '(default)' },
+                });
+            }
+        }
+        let customTargets = Object.keys(pkgTargets).filter(
+        // @ts-expect-error TS7053
+        (targetName) => !COMMON_TARGETS[targetName]);
+        // Custom targets
+        for (let targetName of customTargets) {
+            // @ts-expect-error TS7053
+            let distPath = pkg[targetName];
+            let distDir;
+            let distEntry;
+            let loc;
+            let pointer;
+            if (distPath == null) {
+                distDir =
+                    (0, projectPath_1.fromProjectPath)(this.options.projectRoot, this.options.defaultTargetOptions.distDir) ?? path_1.default.join(pkgDir, DEFAULT_DIST_DIRNAME);
+                if (customTargets.length >= 2) {
+                    distDir = path_1.default.join(distDir, targetName);
+                }
+                (0, assert_1.default)(pkgMap != null);
+                (0, assert_1.default)(typeof pkgFilePath === 'string');
+                loc = {
+                    filePath: pkgFilePath,
+                    ...(0, diagnostic_1.getJSONSourceLocation)(pkgMap.pointers[`/targets/${targetName}`], 'key'),
+                };
+            }
+            else {
+                if (typeof distPath !== 'string') {
+                    let contents = typeof pkgContents === 'string'
+                        ? pkgContents
+                        : JSON.stringify(pkgContents, null, '\t');
+                    throw new diagnostic_1.default({
+                        diagnostic: {
+                            message: (0, diagnostic_1.md) `Invalid distPath for target "${targetName}"`,
+                            origin: '@atlaspack/core',
+                            codeFrames: [
+                                {
+                                    language: 'json',
+                                    filePath: pkgFilePath ?? undefined,
+                                    code: contents,
+                                    codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(contents, [
+                                        {
+                                            key: `/${targetName}`,
+                                            type: 'value',
+                                            message: 'Expected type string',
+                                        },
+                                    ]),
+                                },
+                            ],
+                        },
+                    });
+                }
+                distDir = path_1.default.resolve(pkgDir, path_1.default.dirname(distPath));
+                distEntry = path_1.default.basename(distPath);
+                (0, assert_1.default)(typeof pkgFilePath === 'string');
+                (0, assert_1.default)(pkgMap != null);
+                loc = {
+                    filePath: pkgFilePath,
+                    ...(0, diagnostic_1.getJSONSourceLocation)(pkgMap.pointers[`/${targetName}`], 'value'),
+                };
+                pointer = `/${targetName}`;
+            }
+            if (targetName in pkgTargets) {
+                let descriptor = parsePackageDescriptor(targetName, pkgTargets[targetName], pkgFilePath, pkgContents);
+                let pkgDir = path_1.default.dirname((0, nullthrows_1.default)(pkgFilePath));
+                if (skipTarget(targetName, exclusiveTarget, descriptor.source)) {
+                    targets.set(targetName, null);
+                    continue;
+                }
+                let [inferredOutputFormat, inferredOutputFormatField] = this.inferOutputFormat(distEntry, descriptor, targetName, 
+                // @ts-expect-error TS2345
+                pkg, pkgFilePath, pkgContents);
+                if (descriptor.scopeHoist === false && descriptor.isLibrary) {
+                    let contents = typeof pkgContents === 'string'
+                        ? pkgContents
+                        : JSON.stringify(pkgContents, null, '\t');
+                    throw new diagnostic_1.default({
+                        diagnostic: {
+                            message: 'Scope hoisting cannot be disabled for library targets.',
+                            origin: '@atlaspack/core',
+                            codeFrames: [
+                                {
+                                    language: 'json',
+                                    filePath: pkgFilePath ?? undefined,
+                                    code: contents,
+                                    codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(contents, [
+                                        {
+                                            key: `/targets/${targetName}/scopeHoist`,
+                                            type: 'value',
+                                        },
+                                        {
+                                            key: `/targets/${targetName}/isLibrary`,
+                                            type: 'value',
+                                        },
+                                    ]),
+                                },
+                            ],
+                            hints: [`Either remove the "scopeHoist" or "isLibrary" option.`],
+                            documentationURL: 'https://parceljs.org/features/targets/#library-targets',
+                        },
+                    });
+                }
+                let isLibrary = descriptor.isLibrary ??
+                    this.options.defaultTargetOptions.isLibrary ??
+                    false;
+                let shouldScopeHoist = isLibrary
+                    ? true
+                    : this.options.defaultTargetOptions.shouldScopeHoist;
+                targets.set(targetName, {
+                    name: targetName,
+                    distDir: (0, projectPath_1.toProjectPath)(this.options.projectRoot, descriptor.distDir != null
+                        ? path_1.default.resolve(pkgDir, descriptor.distDir)
+                        : distDir),
+                    distEntry,
+                    publicUrl: descriptor.publicUrl ?? this.options.defaultTargetOptions.publicUrl,
+                    env: (0, Environment_1.createEnvironment)({
+                        engines: descriptor.engines ?? pkgEngines,
+                        context: descriptor.context,
+                        includeNodeModules: descriptor.includeNodeModules,
+                        unstableSingleFileOutput: descriptor.__unstable_singleFileOutput,
+                        outputFormat: descriptor.outputFormat ??
+                            this.options.defaultTargetOptions.outputFormat ??
+                            inferredOutputFormat ??
+                            undefined,
+                        isLibrary,
+                        shouldOptimize: this.options.defaultTargetOptions.shouldOptimize &&
+                            // Libraries are not optimized by default, users must explicitly configure this.
+                            (isLibrary
+                                ? descriptor.optimize === true
+                                : descriptor.optimize !== false),
+                        shouldScopeHoist: shouldScopeHoist && descriptor.scopeHoist !== false,
+                        sourceMap: normalizeSourceMap(this.options, descriptor.sourceMap),
+                    }),
+                    loc: (0, utils_2.toInternalSourceLocation)(this.options.projectRoot, loc),
+                });
+                this.targetInfo.set(targetName, {
+                    output: pointer != null ? { path: pointer } : { message: '(default)' },
+                    engines: getEnginesLoc(targetName, descriptor),
+                    context: descriptor.context
+                        ? { path: `/targets/${targetName}/context` }
+                        : { message: '(default)' },
+                    includeNodeModules: descriptor.includeNodeModules
+                        ? { path: `/targets/${targetName}/includeNodeModules`, type: 'key' }
+                        : { message: '(default)' },
+                    outputFormat: descriptor.outputFormat
+                        ? { path: `/targets/${targetName}/outputFormat` }
+                        : inferredOutputFormatField === '/type'
+                            ? {
+                                message: `(inferred from package.json#type)`,
+                                inferred: inferredOutputFormatField,
+                            }
+                            : inferredOutputFormatField != null
+                                ? {
+                                    message: `(inferred from file extension)`,
+                                    inferred: inferredOutputFormatField,
+                                }
+                                : { message: '(default)' },
+                    isLibrary: descriptor.isLibrary != null
+                        ? { path: `/targets/${targetName}/isLibrary` }
+                        : { message: '(default)' },
+                    shouldOptimize: descriptor.optimize != null
+                        ? { path: `/targets/${targetName}/optimize` }
+                        : { message: '(default)' },
+                    shouldScopeHoist: descriptor.scopeHoist != null
+                        ? { path: `/targets/${targetName}/scopeHoist` }
+                        : { message: '(default)' },
+                });
+            }
+        }
+        // If no explicit targets were defined, add a default.
+        if (targets.size === 0) {
+            targets.set('default', {
+                name: 'default',
+                distDir: this.options.defaultTargetOptions.distDir ??
+                    (0, projectPath_1.toProjectPath)(this.options.projectRoot, path_1.default.join(pkgDir, DEFAULT_DIST_DIRNAME)),
+                publicUrl: this.options.defaultTargetOptions.publicUrl,
+                env: (0, Environment_1.createEnvironment)({
+                    engines: pkgEngines,
+                    // @ts-expect-error TS2322
+                    context,
+                    outputFormat: this.options.defaultTargetOptions.outputFormat,
+                    isLibrary: this.options.defaultTargetOptions.isLibrary,
+                    shouldOptimize: this.options.defaultTargetOptions.shouldOptimize,
+                    shouldScopeHoist: this.options.defaultTargetOptions.shouldScopeHoist ??
+                        (this.options.mode === 'production' &&
+                            !this.options.defaultTargetOptions.isLibrary),
+                    sourceMap: this.options.defaultTargetOptions.sourceMaps
+                        ? {}
+                        : undefined,
+                }),
+            });
+        }
+        assertNoDuplicateTargets(this.options, targets, pkgFilePath, pkgContents);
+        return targets;
+    }
+    inferOutputFormat(distEntry, descriptor, targetName, pkg, pkgFilePath, pkgContents) {
+        // Infer the outputFormat based on package.json properties.
+        // If the extension is .mjs it's always a module.
+        // If the extension is .cjs, it's always commonjs.
+        // If the "type" field is set to "module" and the extension is .js, it's a module.
+        let ext = distEntry != null ? path_1.default.extname(distEntry) : null;
+        let inferredOutputFormat, inferredOutputFormatField;
+        switch (ext) {
+            case '.mjs':
+                inferredOutputFormat = 'esmodule';
+                inferredOutputFormatField = `/${targetName}`;
+                break;
+            case '.cjs':
+                inferredOutputFormat = 'commonjs';
+                inferredOutputFormatField = `/${targetName}`;
+                break;
+            case '.js':
+                if (pkg.type === 'module') {
+                    inferredOutputFormat = 'esmodule';
+                    inferredOutputFormatField = '/type';
+                }
+                break;
+        }
+        if (descriptor.outputFormat &&
+            inferredOutputFormat &&
+            descriptor.outputFormat !== inferredOutputFormat) {
+            let contents = typeof pkgContents === 'string'
+                ? pkgContents
+                : JSON.stringify(pkgContents, null, '\t');
+            let expectedExtensions;
+            switch (descriptor.outputFormat) {
+                case 'esmodule':
+                    expectedExtensions = ['.mjs', '.js'];
+                    break;
+                case 'commonjs':
+                    expectedExtensions = ['.cjs', '.js'];
+                    break;
+                case 'global':
+                    expectedExtensions = ['.js'];
+                    break;
+            }
+            let listFormat = new Intl.ListFormat('en-US', { type: 'disjunction' });
+            throw new diagnostic_1.default({
+                diagnostic: {
+                    message: (0, diagnostic_1.md) `Declared output format "${descriptor.outputFormat}" does not match expected output format "${inferredOutputFormat}".`,
+                    origin: '@atlaspack/core',
+                    codeFrames: [
+                        {
+                            language: 'json',
+                            filePath: pkgFilePath ?? undefined,
+                            code: contents,
+                            codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(contents, [
+                                {
+                                    key: `/targets/${targetName}/outputFormat`,
+                                    type: 'value',
+                                    message: 'Declared output format defined here',
+                                },
+                                {
+                                    key: (0, nullthrows_1.default)(inferredOutputFormatField),
+                                    type: 'value',
+                                    message: 'Inferred output format defined here',
+                                },
+                            ]),
+                        },
+                    ],
+                    hints: [
+                        inferredOutputFormatField === '/type'
+                            ? 'Either remove the target\'s declared "outputFormat" or remove the "type" field.'
+                            : `Either remove the target's declared "outputFormat" or change the extension to ${listFormat.format(expectedExtensions)}.`,
+                    ],
+                    documentationURL: 'https://parceljs.org/features/targets/#library-targets',
+                },
+            });
+        }
+        // @ts-expect-error TS2322
+        return [inferredOutputFormat, inferredOutputFormatField];
+    }
+}
+exports.TargetResolver = TargetResolver;
+function parseEngines(engines, pkgPath, pkgContents, prependKey, message) {
+    if (engines === undefined) {
+        return engines;
+    }
+    else {
+        utils_1.validateSchema.diagnostic(TargetDescriptor_schema_1.ENGINES_SCHEMA, { data: engines, source: pkgContents, filePath: pkgPath, prependKey }, '@atlaspack/core', message);
+        // @ts-expect-error TS2322
+        return engines;
+    }
+}
+function parseDescriptor(targetName, descriptor, pkgPath, pkgContents) {
+    utils_1.validateSchema.diagnostic(TargetDescriptor_schema_1.DESCRIPTOR_SCHEMA, {
+        data: descriptor,
+        source: pkgContents,
+        filePath: pkgPath,
+        prependKey: `/targets/${targetName}`,
+    }, '@atlaspack/core', `Invalid target descriptor for target "${targetName}"`);
+    // @ts-expect-error TS2322
+    return descriptor;
+}
+function parsePackageDescriptor(targetName, descriptor, pkgPath, pkgContents) {
+    utils_1.validateSchema.diagnostic(TargetDescriptor_schema_1.PACKAGE_DESCRIPTOR_SCHEMA, {
+        data: descriptor,
+        source: pkgContents,
+        filePath: pkgPath,
+        prependKey: `/targets/${targetName}`,
+    }, '@atlaspack/core', `Invalid target descriptor for target "${targetName}"`);
+    // @ts-expect-error TS2322
+    return descriptor;
+}
+function parseCommonTargetDescriptor(targetName, descriptor, pkgPath, pkgContents) {
+    utils_1.validateSchema.diagnostic(TargetDescriptor_schema_1.COMMON_TARGET_DESCRIPTOR_SCHEMA, {
+        data: descriptor,
+        source: pkgContents,
+        filePath: pkgPath,
+        prependKey: `/targets/${targetName}`,
+    }, '@atlaspack/core', `Invalid target descriptor for target "${targetName}"`);
+    // @ts-expect-error TS2322
+    return descriptor;
+}
+function assertNoDuplicateTargets(options, targets, pkgFilePath, pkgContents) {
+    // Detect duplicate targets by destination path and provide a nice error.
+    // Without this, an assertion is thrown much later after naming the bundles and finding duplicates.
+    let targetsByPath = new Map();
+    for (let target of targets.values()) {
+        if (!target) {
+            continue;
+        }
+        let { distEntry } = target;
+        if (distEntry != null) {
+            let distPath = path_1.default.join((0, projectPath_1.fromProjectPath)(options.projectRoot, target.distDir), distEntry);
+            if (!targetsByPath.has(distPath)) {
+                targetsByPath.set(distPath, []);
+            }
+            targetsByPath.get(distPath)?.push(target.name);
+        }
+    }
+    let diagnostics = [];
+    for (let [targetPath, targetNames] of targetsByPath) {
+        if (targetNames.length > 1 && pkgContents != null && pkgFilePath != null) {
+            diagnostics.push({
+                message: (0, diagnostic_1.md) `Multiple targets have the same destination path "${path_1.default.relative(path_1.default.dirname(pkgFilePath), targetPath)}"`,
+                origin: '@atlaspack/core',
+                codeFrames: [
+                    {
+                        language: 'json',
+                        filePath: pkgFilePath || undefined,
+                        code: pkgContents,
+                        codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(pkgContents, targetNames.map((t) => ({
+                            key: `/${t}`,
+                            type: 'value',
+                        }))),
+                    },
+                ],
+            });
+        }
+    }
+    if (diagnostics.length > 0) {
+        // Only add hints to the last diagnostic so it isn't duplicated on each one
+        diagnostics[diagnostics.length - 1].hints = [
+            'Try removing the duplicate targets, or changing the destination paths.',
+        ];
+        throw new diagnostic_1.default({
+            diagnostic: diagnostics,
+        });
+    }
+}
+function normalizeSourceMap(options, 
+// @ts-expect-error TS2304
+sourceMap) {
+    if (options.defaultTargetOptions.sourceMaps) {
+        if (typeof sourceMap === 'boolean') {
+            return sourceMap ? {} : undefined;
+        }
+        else {
+            return sourceMap ?? {};
+        }
+    }
+    else {
+        return undefined;
+    }
+}
+function assertTargetsAreNotEntries(targets, input, options) {
+    for (const target of targets) {
+        if (target.distEntry != null &&
+            (0, projectPath_1.joinProjectPath)(target.distDir, target.distEntry) === input.filePath) {
+            let loc = target.loc;
+            let relativeEntry = path_1.default.relative(process.cwd(), (0, projectPath_1.fromProjectPath)(options.projectRoot, input.filePath));
+            // @ts-expect-error TS2304
+            let codeFrames = [];
+            if (loc) {
+                codeFrames.push({
+                    filePath: (0, projectPath_1.fromProjectPath)(options.projectRoot, loc.filePath),
+                    codeHighlights: [
+                        (0, diagnostic_1.convertSourceLocationToHighlight)(loc, 'Target defined here'),
+                    ],
+                });
+                let inputLoc = input.loc;
+                if (inputLoc) {
+                    let highlight = (0, diagnostic_1.convertSourceLocationToHighlight)(inputLoc, 'Entry defined here');
+                    if (inputLoc.filePath === loc.filePath) {
+                        codeFrames[0].codeHighlights.push(highlight);
+                    }
+                    else {
+                        codeFrames.push({
+                            filePath: (0, projectPath_1.fromProjectPath)(options.projectRoot, inputLoc.filePath),
+                            codeHighlights: [highlight],
+                        });
+                    }
+                }
+            }
+            throw new diagnostic_1.default({
+                diagnostic: {
+                    origin: '@atlaspack/core',
+                    message: `Target "${target.name}" is configured to overwrite entry "${relativeEntry}".`,
+                    codeFrames,
+                    hints: [
+                        // @ts-expect-error TS7053
+                        (COMMON_TARGETS[target.name]
+                            ? `The "${target.name}" field is an _output_ file path so that your build can be consumed by other tools. `
+                            : '') +
+                            `Change the "${target.name}" field to point to an output file rather than your source code.`,
+                    ],
+                    documentationURL: 'https://parceljs.org/features/targets/',
+                },
+            });
+        }
+    }
+}
+async function debugResolvedTargets(input, targets, targetInfo, options) {
+    for (let target of targets) {
+        let info = targetInfo.get(target.name);
+        let loc = target.loc;
+        if (!loc || !info) {
+            continue;
+        }
+        let output = (0, projectPath_1.fromProjectPath)(options.projectRoot, target.distDir);
+        if (target.distEntry != null) {
+            output = path_1.default.join(output, target.distEntry);
+        }
+        // Resolve relevant engines for context.
+        let engines;
+        const env = (0, EnvironmentManager_1.fromEnvironmentId)(target.env);
+        switch (env.context) {
+            case 'browser':
+            case 'web-worker':
+            case 'service-worker':
+            case 'worklet': {
+                let browsers = env.engines.browsers;
+                engines = Array.isArray(browsers) ? browsers.join(', ') : browsers;
+                break;
+            }
+            case 'node':
+                engines = env.engines.node;
+                break;
+            case 'electron-main':
+            case 'electron-renderer':
+                engines = env.engines.electron;
+                break;
+        }
+        // @ts-expect-error TS2304
+        let highlights = [];
+        if (input.loc) {
+            highlights.push((0, diagnostic_1.convertSourceLocationToHighlight)(input.loc, 'entry defined here'));
+        }
+        // Read package.json where target is defined.
+        let targetFilePath = (0, projectPath_1.fromProjectPath)(options.projectRoot, loc.filePath);
+        let contents = await options.inputFS.readFile(targetFilePath, 'utf8');
+        // Builds up map of code highlights for each defined/inferred path in the package.json.
+        let jsonHighlights = new Map();
+        for (let key in info) {
+            // @ts-expect-error TS7053
+            let keyInfo = info[key];
+            let path = keyInfo.path || keyInfo.inferred;
+            if (!path) {
+                continue;
+            }
+            let type = keyInfo.type || 'value';
+            let highlight = jsonHighlights.get(path);
+            if (!highlight) {
+                highlight = {
+                    type: type,
+                    defined: '',
+                    inferred: [],
+                };
+                jsonHighlights.set(path, highlight);
+            }
+            else if (highlight.type !== type) {
+                highlight.type = null;
+            }
+            if (keyInfo.path) {
+                highlight.defined = (0, diagnostic_1.md) `${key} defined here`;
+            }
+            if (keyInfo.inferred) {
+                // @ts-expect-error TS2345
+                highlight.inferred.push((0, diagnostic_1.md) `${key} to be ${JSON.stringify(env[key])}`);
+            }
+        }
+        let listFormat = new Intl.ListFormat('en-US');
+        // Generate human friendly messages for each field.
+        let highlightsWithMessages = [...jsonHighlights].map(([k, v]) => {
+            let message = v.defined;
+            if (v.inferred.length > 0) {
+                message += (message ? ', ' : '') + 'caused ';
+                message += listFormat.format(v.inferred);
+            }
+            return {
+                key: k,
+                type: v.type,
+                message,
+            };
+        });
+        // Get code highlights from JSON paths.
+        highlights.push(...(0, diagnostic_1.generateJSONCodeHighlights)(contents, highlightsWithMessages));
+        // Format includeNodeModules to be human readable.
+        let includeNodeModules;
+        if (typeof env.includeNodeModules === 'boolean') {
+            includeNodeModules = String(env.includeNodeModules);
+        }
+        else if (Array.isArray(env.includeNodeModules)) {
+            includeNodeModules =
+                'only ' +
+                    listFormat.format(env.includeNodeModules.map((m) => JSON.stringify(m)));
+        }
+        else if (env.includeNodeModules &&
+            typeof env.includeNodeModules === 'object') {
+            includeNodeModules =
+                'all except ' +
+                    listFormat.format(Object.entries(env.includeNodeModules)
+                        .filter(([, v]) => v === false)
+                        // @ts-expect-error TS2345
+                        .map(([k]) => JSON.stringify(k)));
+        }
+        let format = (v) => 
+        // @ts-expect-error TS2339
+        v.message != null ? diagnostic_1.md.italic(v.message) : '';
+        logger_1.default.verbose({
+            origin: '@atlaspack/core',
+            message: (0, diagnostic_1.md) `**Target** "${target.name}"
+
+               **Entry**: ${path_1.default.relative(process.cwd(), (0, projectPath_1.fromProjectPath)(options.projectRoot, input.filePath))}
+              **Output**: ${path_1.default.relative(process.cwd(), output)}
+              **Format**: ${env.outputFormat} ${format(info.outputFormat)}
+             **Context**: ${env.context} ${format(info.context)}
+             **Engines**: ${engines || ''} ${format(info.engines)}
+        **Library Mode**: ${String(env.isLibrary)} ${format(info.isLibrary)}
+**Include Node Modules**: ${includeNodeModules} ${format(info.includeNodeModules)}
+            **Optimize**: ${String(env.shouldOptimize)} ${format(info.shouldOptimize)}`,
+            codeFrames: target.loc
+                ? [
+                    {
+                        filePath: targetFilePath,
+                        codeHighlights: highlights,
+                    },
+                ]
+                : [],
+        });
+    }
+}