@atlaspack/package-manager 2.14.31 → 2.14.32

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atlaspack/package-manager
 
+## 2.14.32
+
+### Patch Changes
+
+- Updated dependencies [[`1180103`](https://github.com/atlassian-labs/atlaspack/commit/118010351ed444f8178988afb3f77807154dd933)]:
+  - @atlaspack/utils@3.0.0
+  - @atlaspack/fs@2.15.27
+  - @atlaspack/node-resolver-core@3.7.3
+  - @atlaspack/logger@2.14.24
+  - @atlaspack/workers@2.14.32
+  - @atlaspack/types@2.15.22
+
 ## 2.14.31
 
 ### Patch Changes

package/dist/JSONParseStream.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+const stream_1 = require("stream");
+// Transforms chunks of json strings to parsed objects.
+// Pair with split2 to parse stream of newline-delimited text.
+class JSONParseStream extends stream_1.Transform {
+    constructor(options) {
+        // @ts-expect-error TS2698
+        super({ ...options, objectMode: true });
+    }
+    _transform(chunk, encoding, callback) {
+        try {
+            let parsed;
+            try {
+                parsed = JSON.parse(chunk.toString());
+            }
+            catch (e) {
+                // Be permissive and ignoreJSON parse errors in case there was
+                // a non-JSON line in the package manager's stdout.
+                logger_1.default.verbose({
+                    message: 'Ignored invalid JSON message: ' + chunk.toString(),
+                    origin: '@atlaspack/package-manager',
+                });
+                return;
+            }
+            callback(null, parsed);
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+}
+exports.default = JSONParseStream;

package/dist/MockPackageInstaller.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockPackageInstaller = void 0;
+const path_1 = __importDefault(require("path"));
+const build_cache_1 = require("@atlaspack/build-cache");
+const fs_1 = require("@atlaspack/fs");
+const package_json_1 = __importDefault(require("../package.json"));
+const utils_1 = require("./utils");
+// This PackageInstaller implementation simply copies files from one filesystem to another.
+// Mostly useful for testing purposes.
+class MockPackageInstaller {
+    constructor() {
+        this.packages = new Map();
+    }
+    register(packageName, fs, packagePath) {
+        this.packages.set(packageName, { fs, packagePath });
+    }
+    async install({ modules, fs, cwd, packagePath, saveDev = true, }) {
+        if (packagePath == null) {
+            packagePath = path_1.default.join(cwd, 'package.json');
+            await fs.writeFile(packagePath, '{}');
+        }
+        let pkg = JSON.parse(await fs.readFile(packagePath, 'utf8'));
+        let key = saveDev ? 'devDependencies' : 'dependencies';
+        if (!pkg[key]) {
+            pkg[key] = {};
+        }
+        for (let module of modules) {
+            pkg[key][module.name] =
+                '^' + (await this.installPackage(module, fs, packagePath));
+        }
+        await fs.writeFile(packagePath, JSON.stringify(pkg));
+    }
+    async installPackage(moduleRequest, fs, packagePath) {
+        let pkg = this.packages.get(moduleRequest.name);
+        if (!pkg) {
+            throw new Error('Unknown package ' + moduleRequest.name);
+        }
+        let dest = path_1.default.join(path_1.default.dirname(packagePath), 'node_modules', moduleRequest.name);
+        await (0, fs_1.ncp)(pkg.fs, pkg.packagePath, fs, dest);
+        let packageJSON = JSON.parse(await fs.readFile(path_1.default.join(dest, 'package.json'), 'utf8'));
+        if (packageJSON.dependencies != null) {
+            for (let dep of (0, utils_1.moduleRequestsFromDependencyMap)(packageJSON.dependencies)) {
+                await this.installPackage(dep, fs, packagePath);
+            }
+        }
+        return packageJSON.version;
+    }
+}
+exports.MockPackageInstaller = MockPackageInstaller;
+(0, build_cache_1.registerSerializableClass)(`${package_json_1.default.version}:MockPackageInstaller`, MockPackageInstaller);

package/dist/NodePackageManager.js

@@ -0,0 +1,559 @@
+"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.NodePackageManager = void 0;
+const build_cache_1 = require("@atlaspack/build-cache");
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const fs_1 = require("@atlaspack/fs");
+const fs_2 = __importDefault(require("fs"));
+const module_1 = __importDefault(require("module"));
+const path_1 = __importDefault(require("path"));
+const semver_1 = __importDefault(require("semver"));
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const utils_1 = require("@atlaspack/utils");
+const utils_2 = require("./utils");
+const installPackage_1 = require("./installPackage");
+const package_json_1 = __importDefault(require("../package.json"));
+const nodejsConditions_1 = require("./nodejsConditions");
+const node_resolver_core_1 = require("@atlaspack/node-resolver-core");
+const url_1 = require("url");
+const core_1 = require("@swc/core");
+// Package.json fields. Must match package_json.rs.
+const MAIN = 1 << 0;
+const SOURCE = 1 << 2;
+let ENTRIES = MAIN;
+if (process.env.ATLASPACK_REGISTER_USE_SRC === 'true') {
+    ENTRIES |= SOURCE;
+}
+const NODE_MODULES = `${path_1.default.sep}node_modules${path_1.default.sep}`;
+const compileExtensions = new Set(['.ts', '.tsx', '.mts', '.cts']);
+// There can be more than one instance of NodePackageManager, but node has only a single module cache.
+// Therefore, the resolution cache and the map of parent to child modules should also be global.
+const cache = new Map();
+const children = new Map();
+const invalidationsCache = new Map();
+// This implements a package manager for Node by monkey patching the Node require
+// algorithm so that it uses the specified FileSystem instead of the native one.
+// It also handles installing packages when they are required if not already installed.
+// See https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js
+// for reference to Node internals.
+class NodePackageManager {
+    constructor(fs, projectRoot, installer) {
+        this.fs = fs;
+        this.projectRoot = projectRoot;
+        this.installer = installer;
+        // If using src then assume we're linked and find the link root dir
+        this.atlaspackLinkRoot =
+            process.env.ATLASPACK_REGISTER_USE_SRC === 'true'
+                ? path_1.default.resolve(__dirname, '../../../..')
+                : null;
+        // @ts-expect-error TS2339
+        this.currentExtensions = Object.keys(module_1.default._extensions).map((e) => e.substring(1));
+    }
+    // @ts-expect-error TS2749
+    _createResolver() {
+        return new node_resolver_core_1.ResolverBase(this.projectRoot, {
+            fs: this.fs instanceof fs_1.NodeFS && process.versions.pnp == null
+                ? undefined
+                : {
+                    canonicalize: (path) => this.fs.realpathSync(path),
+                    read: (path) => this.fs.readFileSync(path),
+                    isFile: (path) => this.fs.statSync(path).isFile(),
+                    isDir: (path) => this.fs.statSync(path).isDirectory(),
+                },
+            mode: 2,
+            entries: ENTRIES,
+            packageExports: true,
+            moduleDirResolver: process.versions.pnp != null
+                ? (module, from) => {
+                    // @ts-expect-error TS2339
+                    let pnp = module_1.default.findPnpApi(path_1.default.dirname(from));
+                    return pnp.resolveToUnqualified(
+                    // append slash to force loading builtins from npm
+                    module + '/', from);
+                }
+                : undefined,
+            extensions: this.currentExtensions,
+            typescript: true,
+        });
+    }
+    static deserialize(opts) {
+        return new NodePackageManager(opts.fs, opts.projectRoot, opts.installer);
+    }
+    serialize() {
+        return {
+            $$raw: false,
+            fs: this.fs,
+            projectRoot: this.projectRoot,
+            installer: this.installer,
+        };
+    }
+    async require(name, from, opts) {
+        let { resolved, type } = await this.resolve(name, from, opts);
+        if (type === 2) {
+            logger_1.default.warn({
+                message: 'ES module dependencies are experimental.',
+                origin: '@atlaspack/package-manager',
+                codeFrames: [
+                    {
+                        filePath: resolved,
+                        codeHighlights: [],
+                    },
+                ],
+            });
+            // On Windows, Node requires absolute paths to be file URLs.
+            if (process.platform === 'win32' && path_1.default.isAbsolute(resolved)) {
+                // @ts-expect-error TS2322
+                resolved = (0, url_1.pathToFileURL)(resolved);
+            }
+            return import(resolved);
+        }
+        return this.load(resolved, from);
+    }
+    requireSync(name, from) {
+        let { resolved } = this.resolveSync(name, from);
+        return this.load(resolved, from);
+    }
+    load(filePath, from) {
+        if (!path_1.default.isAbsolute(filePath)) {
+            // Node builtin module
+            return require(filePath);
+        }
+        // @ts-expect-error TS2339
+        const cachedModule = module_1.default._cache[filePath];
+        if (cachedModule !== undefined) {
+            return cachedModule.exports;
+        }
+        // @ts-expect-error TS2339
+        let m = new module_1.default(filePath, module_1.default._cache[from] || module.parent);
+        // @ts-expect-error TS2339
+        const extensions = Object.keys(module_1.default._extensions);
+        // This handles supported extensions changing due to, for example, esbuild/register being used
+        // We assume that the extension list will change in size - as these tools usually add support for
+        // additional extensions.
+        if (extensions.length !== this.currentExtensions.length) {
+            this.currentExtensions = extensions.map((e) => e.substring(1));
+            this.resolver = this._createResolver();
+        }
+        // @ts-expect-error TS2339
+        module_1.default._cache[filePath] = m;
+        // Patch require within this module so it goes through our require
+        m.require = (id) => {
+            return this.requireSync(id, filePath);
+        };
+        // Patch `fs.readFileSync` temporarily so that it goes through our file system
+        let { readFileSync, statSync } = fs_2.default;
+        // @ts-expect-error TS2322
+        fs_2.default.readFileSync = (filename, encoding) => {
+            return this.fs.readFileSync(filename, encoding);
+        };
+        // @ts-expect-error TS2540
+        fs_2.default.statSync = (filename) => {
+            return this.fs.statSync(filename);
+        };
+        let extname = path_1.default.extname(filePath);
+        function shouldCompile(atlaspackLinkRoot) {
+            if (filePath.includes(NODE_MODULES)) {
+                // Don't compile node_modules
+                return false;
+            }
+            if (!compileExtensions.has(extname)) {
+                // Ignore non-TS files
+                return false;
+            }
+            if (atlaspackLinkRoot != null) {
+                // If we're linked, only compile files outside the linked atlaspack
+                // as those are handled by @atlaspack/babel-register
+                return !filePath.startsWith(atlaspackLinkRoot);
+            }
+            // @ts-expect-error TS2339
+            // Lastly make sure there's no existing loader for this extension
+            return !module_1.default._extensions[extname];
+        }
+        if (shouldCompile(this.atlaspackLinkRoot)) {
+            // @ts-expect-error TS2339
+            let compile = m._compile;
+            // @ts-expect-error TS2339
+            m._compile = (code, filename) => {
+                let out = (0, core_1.transformSync)(code, {
+                    filename,
+                    module: { type: 'commonjs' },
+                    env: { targets: { node: '18' } },
+                });
+                compile.call(m, out.code, filename);
+            };
+            // @ts-expect-error TS2339
+            module_1.default._extensions[extname] = (m, filename) => {
+                // @ts-expect-error TS2339
+                delete module_1.default._extensions[extname];
+                // @ts-expect-error TS2339
+                module_1.default._extensions['.js'](m, filename);
+            };
+        }
+        try {
+            // @ts-expect-error TS2339
+            m.load(filePath);
+        }
+        catch (err) {
+            // @ts-expect-error TS2339
+            delete module_1.default._cache[filePath];
+            throw err;
+        }
+        finally {
+            fs_2.default.readFileSync = readFileSync;
+            // @ts-expect-error TS2540
+            fs_2.default.statSync = statSync;
+        }
+        return m.exports;
+    }
+    async resolve(id, from, options) {
+        let basedir = path_1.default.dirname(from);
+        let key = basedir + ':' + id;
+        let resolved = cache.get(key);
+        if (!resolved) {
+            let [name] = (0, utils_1.getModuleParts)(id);
+            try {
+                resolved = this.resolveInternal(id, from);
+            }
+            catch (e) {
+                if (e.code !== 'MODULE_NOT_FOUND' ||
+                    options?.shouldAutoInstall !== true ||
+                    id.startsWith('.') // a local file, don't autoinstall
+                ) {
+                    if (e.code === 'MODULE_NOT_FOUND' &&
+                        options?.shouldAutoInstall !== true) {
+                        let err = new diagnostic_1.default({
+                            diagnostic: {
+                                message: (0, diagnostic_1.escapeMarkdown)(e.message),
+                                hints: [
+                                    'Autoinstall is disabled, please install this package manually and restart Parcel.',
+                                ],
+                            },
+                        });
+                        // @ts-expect-error TS2339
+                        err.code = 'MODULE_NOT_FOUND';
+                        throw err;
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+                let conflicts = await (0, utils_2.getConflictingLocalDependencies)(this.fs, name, from, this.projectRoot);
+                if (conflicts == null) {
+                    this.invalidate(id, from);
+                    await this.install([{ name, range: options?.range }], from, {
+                        saveDev: options?.saveDev ?? true,
+                    });
+                    return this.resolve(id, from, {
+                        ...options,
+                        shouldAutoInstall: false,
+                    });
+                }
+                throw new diagnostic_1.default({
+                    diagnostic: conflicts.fields.map((field) => ({
+                        message: (0, diagnostic_1.md) `Could not find module "${name}", but it was listed in package.json. Run your package manager first.`,
+                        origin: '@atlaspack/package-manager',
+                        codeFrames: [
+                            {
+                                filePath: conflicts.filePath,
+                                language: 'json',
+                                code: conflicts.json,
+                                codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(conflicts.json, [
+                                    {
+                                        key: `/${field}/${(0, diagnostic_1.encodeJSONKeyComponent)(name)}`,
+                                        type: 'key',
+                                        message: 'Defined here, but not installed',
+                                    },
+                                ]),
+                            },
+                        ],
+                    })),
+                });
+            }
+            let range = options?.range;
+            if (range != null) {
+                let pkg = resolved.pkg;
+                if (pkg == null || !semver_1.default.satisfies(pkg.version, range)) {
+                    let conflicts = await (0, utils_2.getConflictingLocalDependencies)(this.fs, name, from, this.projectRoot);
+                    if (conflicts == null && options?.shouldAutoInstall === true) {
+                        this.invalidate(id, from);
+                        await this.install([{ name, range }], from);
+                        return this.resolve(id, from, {
+                            ...options,
+                            shouldAutoInstall: false,
+                        });
+                    }
+                    else if (conflicts != null) {
+                        throw new diagnostic_1.default({
+                            diagnostic: {
+                                message: (0, diagnostic_1.md) `Could not find module "${name}" satisfying ${range}.`,
+                                origin: '@atlaspack/package-manager',
+                                codeFrames: [
+                                    {
+                                        filePath: conflicts.filePath,
+                                        language: 'json',
+                                        code: conflicts.json,
+                                        codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(conflicts.json, conflicts.fields.map((field) => ({
+                                            key: `/${field}/${(0, diagnostic_1.encodeJSONKeyComponent)(name)}`,
+                                            type: 'key',
+                                            message: 'Found this conflicting local requirement.',
+                                        }))),
+                                    },
+                                ],
+                            },
+                        });
+                    }
+                    let version = pkg?.version;
+                    let message = (0, diagnostic_1.md) `Could not resolve package "${name}" that satisfies ${range}.`;
+                    if (version != null) {
+                        message += (0, diagnostic_1.md) ` Found ${version}.`;
+                    }
+                    throw new diagnostic_1.default({
+                        diagnostic: {
+                            message,
+                            hints: [
+                                'Looks like the incompatible version was installed transitively. Add this package as a direct dependency with a compatible version range.',
+                            ],
+                        },
+                    });
+                }
+            }
+            cache.set(key, resolved);
+            invalidationsCache.clear();
+            // Add the specifier as a child to the parent module.
+            // Don't do this if the specifier was an absolute path, as this was likely a dynamically resolved path
+            // (e.g. babel uses require() to load .babelrc.js configs and we don't want them to be added  as children of babel itself).
+            if (!path_1.default.isAbsolute(name)) {
+                let moduleChildren = children.get(from);
+                if (!moduleChildren) {
+                    moduleChildren = new Set();
+                    children.set(from, moduleChildren);
+                }
+                moduleChildren.add(name);
+            }
+        }
+        return resolved;
+    }
+    resolveSync(name, from) {
+        let basedir = path_1.default.dirname(from);
+        let key = basedir + ':' + name;
+        let resolved = cache.get(key);
+        if (!resolved) {
+            resolved = this.resolveInternal(name, from);
+            cache.set(key, resolved);
+            invalidationsCache.clear();
+            if (!path_1.default.isAbsolute(name)) {
+                let moduleChildren = children.get(from);
+                if (!moduleChildren) {
+                    moduleChildren = new Set();
+                    children.set(from, moduleChildren);
+                }
+                moduleChildren.add(name);
+            }
+        }
+        return resolved;
+    }
+    async install(modules, from, opts) {
+        await (0, installPackage_1.installPackage)(this.fs, this, modules, from, this.projectRoot, {
+            packageInstaller: this.installer,
+            ...opts,
+        });
+    }
+    getInvalidations(name, from) {
+        let basedir = path_1.default.dirname(from);
+        let cacheKey = basedir + ':' + name;
+        let resolved = cache.get(cacheKey);
+        if (resolved && path_1.default.isAbsolute(resolved.resolved)) {
+            let cached = invalidationsCache.get(resolved.resolved);
+            if (cached != null) {
+                return cached;
+            }
+            let res = {
+                invalidateOnFileCreate: [],
+                invalidateOnFileChange: new Set(),
+                invalidateOnStartup: false,
+            };
+            let seen = new Set();
+            let addKey = (name, from) => {
+                let basedir = path_1.default.dirname(from);
+                let key = basedir + ':' + name;
+                if (seen.has(key)) {
+                    return;
+                }
+                seen.add(key);
+                let resolved = cache.get(key);
+                if (!resolved || !path_1.default.isAbsolute(resolved.resolved)) {
+                    return;
+                }
+                // @ts-expect-error TS2345
+                res.invalidateOnFileCreate.push(...resolved.invalidateOnFileCreate);
+                res.invalidateOnFileChange.add(resolved.resolved);
+                for (let file of resolved.invalidateOnFileChange) {
+                    res.invalidateOnFileChange.add(file);
+                }
+                let moduleChildren = children.get(resolved.resolved);
+                if (moduleChildren) {
+                    for (let specifier of moduleChildren) {
+                        addKey(specifier, resolved.resolved);
+                    }
+                }
+            };
+            addKey(name, from);
+            // If this is an ES module, we won't have any of the dependencies because import statements
+            // cannot be intercepted. Instead, ask the resolver to parse the file and recursively analyze the deps.
+            if (resolved.type === 2) {
+                let invalidations = this.resolver.getInvalidations(resolved.resolved);
+                // @ts-expect-error TS7006
+                invalidations.invalidateOnFileChange.forEach((i) => res.invalidateOnFileChange.add(i));
+                // @ts-expect-error TS7006
+                invalidations.invalidateOnFileCreate.forEach((i) => 
+                // @ts-expect-error TS2345
+                res.invalidateOnFileCreate.push(i));
+                res.invalidateOnStartup || (res.invalidateOnStartup = invalidations.invalidateOnStartup);
+                if (res.invalidateOnStartup) {
+                    logger_1.default.warn({
+                        message: (0, diagnostic_1.md) `${path_1.default.relative(this.projectRoot, resolved.resolved)} contains non-statically analyzable dependencies in its module graph. This causes Parcel to invalidate the cache on startup.`,
+                        origin: '@atlaspack/package-manager',
+                    });
+                }
+            }
+            // @ts-expect-error TS2345
+            invalidationsCache.set(resolved.resolved, res);
+            // @ts-expect-error TS2322
+            return res;
+        }
+        return {
+            invalidateOnFileCreate: [],
+            invalidateOnFileChange: new Set(),
+            invalidateOnStartup: false,
+        };
+    }
+    invalidate(name, from) {
+        let seen = new Set();
+        let invalidate = (name, from) => {
+            let basedir = path_1.default.dirname(from);
+            let key = basedir + ':' + name;
+            if (seen.has(key)) {
+                return;
+            }
+            seen.add(key);
+            let resolved = cache.get(key);
+            if (!resolved || !path_1.default.isAbsolute(resolved.resolved)) {
+                return;
+            }
+            // During testing don't invalidate Atlaspack modules because
+            // this causes failures due to multiple instances of the same module
+            // existing simultaniously. This is fine when using babe;-register because
+            // it has an internal module cache that NodePacakageManager does not invalidate
+            // but fails when using compiled Atlaspack packages in integration tests
+            if (process.env.ATLASPACK_BUILD_ENV === 'test' &&
+                name.startsWith('@atlaspack/')) {
+                return;
+            }
+            invalidationsCache.delete(resolved.resolved);
+            // @ts-expect-error TS2339
+            let module = module_1.default._cache[resolved.resolved];
+            if (module) {
+                // @ts-expect-error TS2339
+                delete module_1.default._cache[resolved.resolved];
+            }
+            let moduleChildren = children.get(resolved.resolved);
+            if (moduleChildren) {
+                for (let specifier of moduleChildren) {
+                    invalidate(specifier, resolved.resolved);
+                }
+            }
+            children.delete(resolved.resolved);
+            cache.delete(key);
+        };
+        invalidate(name, from);
+        this.resolver = this._createResolver();
+    }
+    resolveInternal(name, from) {
+        if (this.resolver == null) {
+            this.resolver = this._createResolver();
+        }
+        let res = this.resolver.resolve({
+            filename: name,
+            specifierType: 'commonjs',
+            parent: from,
+            packageConditions: (0, nodejsConditions_1.getConditionsFromEnv)(),
+        });
+        // Invalidate whenever the .pnp.js file changes.
+        // TODO: only when we actually resolve a node_modules package?
+        if (process.versions.pnp != null && res.invalidateOnFileChange) {
+            // @ts-expect-error TS2339
+            let pnp = module_1.default.findPnpApi(path_1.default.dirname(from));
+            res.invalidateOnFileChange.push(pnp.resolveToUnqualified('pnpapi', null));
+        }
+        if (res.error) {
+            let e = new Error(`Could not resolve module "${name}" from "${from}"`);
+            // @ts-expect-error TS2339
+            e.code = 'MODULE_NOT_FOUND';
+            throw e;
+        }
+        // @ts-expect-error TS7034
+        let getPkg;
+        switch (res.resolution.type) {
+            case 'Path':
+                getPkg = () => {
+                    let pkgPath = this.fs.findAncestorFile(['package.json'], (0, nullthrows_1.default)(res.resolution.value), this.projectRoot);
+                    return pkgPath
+                        ? JSON.parse(this.fs.readFileSync(pkgPath, 'utf8'))
+                        : null;
+                };
+            // fallthrough
+            case 'Builtin':
+                return {
+                    resolved: res.resolution.value,
+                    invalidateOnFileChange: new Set(res.invalidateOnFileChange),
+                    invalidateOnFileCreate: res.invalidateOnFileCreate,
+                    type: res.moduleType,
+                    get pkg() {
+                        // @ts-expect-error TS7005
+                        return getPkg();
+                    },
+                };
+            default:
+                throw new Error('Unknown resolution type');
+        }
+    }
+}
+exports.NodePackageManager = NodePackageManager;
+(0, build_cache_1.registerSerializableClass)(`${package_json_1.default.version}:NodePackageManager`, NodePackageManager);