package-management 0.0.10 → 0.0.12

package/dist/index.cjs

@@ -0,0 +1,1293 @@
+'use strict';
+
+const ErrorStackParser = require('error-stack-parser');
+const path = require('pathe');
+const process = require('node:process');
+const path$1 = require('node:path');
+const node_url = require('node:url');
+const node_fs = require('node:fs');
+const asyncCacheFn = require('async-cache-fn');
+const execa = require('execa');
+const findUp = require('find-up');
+const promises = require('node:fs/promises');
+const mlly = require('mlly');
+const globby = require('globby');
+const gitignoreParser = require('parse-gitignore');
+const WST = require('workspace-tools');
+const utils = require('pathe/utils');
+const os = require('node:os');
+const jsoncParser = require('jsonc-parser');
+const util = require('@arktype/util');
+const unstorage = require('unstorage');
+const defineMemoryDriver = require('unstorage/drivers/memory');
+const defineFsLiteDriver = require('unstorage/drivers/fs-lite');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  const n = Object.create(null);
+  if (e) {
+    for (const k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return n;
+}
+
+const ErrorStackParser__default = /*#__PURE__*/_interopDefaultCompat(ErrorStackParser);
+const path__default$1 = /*#__PURE__*/_interopDefaultCompat(path);
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path$1);
+const gitignoreParser__default = /*#__PURE__*/_interopDefaultCompat(gitignoreParser);
+const WST__namespace = /*#__PURE__*/_interopNamespaceCompat(WST);
+const os__default = /*#__PURE__*/_interopDefaultCompat(os);
+const defineMemoryDriver__default = /*#__PURE__*/_interopDefaultCompat(defineMemoryDriver);
+const defineFsLiteDriver__default = /*#__PURE__*/_interopDefaultCompat(defineFsLiteDriver);
+
+const toArray = (data) => Array.isArray(data) ? data : [data];
+const entriesOf = (o) => Object.entries(o);
+const fromEntries = (entries) => Object.fromEntries(entries);
+const notFalsy = (value) => [false, null, void 0].every((v) => v !== value);
+const select = (obj, selection, mode) => {
+  if (!selection) return obj;
+  const filtered = entriesOf(obj).filter(([key]) => {
+    return selection[key];
+  });
+  return fromEntries(filtered);
+};
+function normalizePath(path$1, option) {
+  if (typeof option === "function") {
+    return normalizePath(path$1);
+  }
+  if (option === false) {
+    return path$1;
+  }
+  return path.normalize(path$1);
+}
+const invariant = (predicate, message) => {
+  if (!predicate) {
+    throw new Error(message);
+  }
+};
+function getArrayItemAtOffset(arr, index, offset = 0) {
+  if (arr === void 0 || index === void 0) return void 0;
+  return arr[index + offset];
+}
+function isMatching(a, b) {
+  if (!a || !b) return false;
+  return a === b;
+}
+function checkResult(cb, options) {
+  try {
+    return buildSingleProp({
+      key: options?.keys?.data ?? "data",
+      value: cb()
+    });
+  } catch (error) {
+    return buildSingleProp({
+      key: "error",
+      value: error
+    });
+  }
+}
+function isPropertyKey(input) {
+  return typeof input === "string" || typeof input === "number" || typeof input === "symbol";
+}
+function buildSingleProp(entry) {
+  const [key, value] = Array.isArray(entry) ? entry : [entry.key, entry.value];
+  if (!isPropertyKey(key)) {
+    return {};
+  }
+  return { [key]: value };
+}
+
+function findCallerStackFrame(options) {
+  return findErrorStackFrame(options, (frame) => frame.isParentOfRootFunction);
+}
+function findErrorStackFrame(options, find) {
+  return getErrorStackFrames(options, find)[0];
+}
+function getErrorStackFrames(options, filter) {
+  const { error, rootFunctionName, startFrom = "top" } = options;
+  const frames = startFrom === "bottom" ? ErrorStackParser__default.parse(error).reverse() : ErrorStackParser__default.parse(error);
+  const { parsedFrames } = frames.reduce(
+    (acc, frame, index) => {
+      const parsed = parseFrame({
+        frame,
+        index,
+        rootFunctionName,
+        frames
+      });
+      const isValid = filter ? filter(parsed) : true;
+      if (isValid) {
+        acc.parsedFrames.push(parsed);
+      }
+      return acc;
+    },
+    { parsedFrames: [] }
+  );
+  return parsedFrames ?? [];
+}
+function parseFrame(options) {
+  const { frame, frames, index, rootFunctionName, cwd, debug } = options ?? {};
+  const functionName = parseFunctionName(frame.functionName);
+  const isRootFunction = isMatching(functionName, rootFunctionName);
+  const beforeFrameFunctionName = parseFunctionName(
+    getArrayItemAtOffset(frames, index, -1)?.functionName
+  );
+  const isParentOfRootFunction = isMatching(
+    beforeFrameFunctionName,
+    rootFunctionName
+  );
+  const fileData = frame.fileName ? getFilePathData({ filepath: frame.fileName, cwd }) : void 0;
+  const { isFileInCwd: isFrameInScope, ...restFileData } = fileData ?? {};
+  const data = {
+    ...restFileData,
+    functionName,
+    source: frame.source,
+    sourceFunctionName: frame.functionName,
+    isFrameInScope,
+    place: placeFormatter(index, frames?.length),
+    isRootFunction,
+    isParentOfRootFunction,
+    rootFunctionName
+  };
+  debug && console.log(data);
+  return data;
+}
+function getFilePathData({
+  filepath,
+  cwd
+}) {
+  const workingDir = cwd ?? process__default.cwd();
+  const filePath = path.normalize(toFilePath(filepath));
+  const fileBasename = path.basename(filePath);
+  const dirPath = path.dirname(filePath);
+  const dirBasename = path.basename(dirPath);
+  const relativeFilePath = path.relative(workingDir, filePath);
+  const relativeDirPath = path.dirname(relativeFilePath);
+  const isFileInCwd = filePath.startsWith(workingDir);
+  return {
+    filePath,
+    dirPath,
+    relativeFilePath,
+    relativeDirPath,
+    fileBasename,
+    dirBasename,
+    isFileInCwd
+  };
+}
+function toFilePath(fileName) {
+  return fileName.startsWith("file:") ? node_url.fileURLToPath(fileName) : fileName;
+}
+function parseFunctionName(functionName) {
+  if (!functionName) return void 0;
+  return removeStart(functionName, "Module.");
+}
+function removeStart(input, value) {
+  return input.startsWith(value) ? input.slice(value.length) : input;
+}
+function placeFormatter(index, total) {
+  if (index === void 0 || !total) return void 0;
+  return [index, total].join("/");
+}
+
+const _filename = (options) => {
+  const { filePath } = findCallerStackFrame({ error: new Error(), ...options }) ?? {};
+  return filePath;
+};
+const _dirname = (options) => {
+  const { dirPath } = findCallerStackFrame({ error: new Error(), ...options }) ?? {};
+  return dirPath;
+};
+
+async function resolveModule(module) {
+  const resolved = await module;
+  return resolved.default || resolved;
+}
+function isPackageModuleFound(name, options) {
+  return Boolean(resolvePackageModulePath(name, options));
+}
+function resolvePackageModulePath(name, options) {
+  const resolvedPath = findResolvedModulePath(
+    [`${name}/package.json`, name],
+    options
+  );
+  if (resolvedPath === void 0) {
+    console.error(`Could not resolve package ${name}`);
+    return void 0;
+  }
+  return resolvedPath;
+}
+function findResolvedModulePath(paths, options) {
+  for (const path of paths) {
+    const resolvedPath = resolveModulePath(path, options);
+    if (resolvedPath === void 0) continue;
+    return resolvedPath;
+  }
+}
+function resolveModulePath(modulePath, options) {
+  const { normalize = true, paths, ...rest } = options ?? {};
+  try {
+    const path = normalizePath(modulePath, normalize);
+    return mlly.resolvePathSync(path, {
+      url: paths,
+      ...rest
+    });
+  } catch (e) {
+    return void 0;
+  }
+}
+
+const tsconfig = (tsconfigDir) => ({
+  get paths() {
+    return globby.globbySync(["tsconfig.json", "tsconfig.*.json"], {
+      cwd: tsconfigDir
+    }) ?? [];
+  }
+});
+
+function parseGitignoreFile(gitignorePath, options) {
+  return gitignoreParser__default(gitignorePath, options);
+}
+function getGitignoreData(gitignorePath) {
+  const gitignoreFileContent = node_fs.readFileSync(gitignorePath, "utf-8");
+  const gitignores = parseGitignoreFile(gitignoreFileContent);
+  return gitignores;
+}
+const gitignore = (gitignorePath) => ({
+  get data() {
+    return getGitignoreData(gitignorePath);
+  },
+  get patterns() {
+    return getGitignoreData(gitignorePath).patterns;
+  }
+});
+
+const dependencyTypeMap = {
+  dependency: "dependencies",
+  devDependency: "devDependencies",
+  peerDependency: "peerDependencies",
+  optionalDependency: "optionalDependencies"
+};
+
+function isDependencyInPackageJson(options, packageJson) {
+  return Boolean(findDependencyInPackageJson(options, packageJson));
+}
+function findDependencyInPackageJson(option, packageJson) {
+  const { name, type } = typeof option === "string" ? { name: option, type: void 0 } : option;
+  if (!packageJson) return void 0;
+  const allowedTypes = typeof type === "string" ? {
+    [type]: true
+  } : type ?? {
+    dependency: true,
+    devDependency: true
+  };
+  const allowedDependencyTypes = getAllowedDependencyTypeList(allowedTypes);
+  const matches = allowedDependencyTypes.map((type2) => {
+    return getPackageJsonDependencyItem({ name, type: type2 }, packageJson);
+  }).filter(notFalsy);
+  if (matches.length === 0) return void 0;
+  return {
+    firstMatch: matches[0],
+    matches
+  };
+}
+function getPackageJsonDependencyItem({
+  name,
+  type
+}, packageJson) {
+  if (!packageJson) return void 0;
+  const dependencyMap = getPackageJsonDependencyMap(type, packageJson);
+  const version = dependencyMap?.[name];
+  if (version === void 0) return void 0;
+  return {
+    name,
+    version,
+    type
+  };
+}
+function getAllowedDependencyTypeList(selected) {
+  return Object.keys(dependencyTypeMap).filter(
+    (key) => selected[key]
+  );
+}
+function getPackageJsonDependencyMap(type, packageJson) {
+  return packageJson[dependencyTypeMap[type]];
+}
+
+function getWorkspaceFolder(options) {
+  const {
+    cwd = process__default.cwd(),
+    fallbackToGitRoot = true,
+    throwIfNotFound = true
+  } = options ?? {};
+  const getFolder = fallbackToGitRoot ? WST__namespace.findProjectRoot : WST__namespace.getWorkspaceManagerRoot;
+  const folder = getFolder(cwd);
+  if (folder === void 0 && throwIfNotFound) {
+    throw new Error(`Could not find workspace folder`);
+  }
+  return folder;
+}
+
+function getPackageFolder(options) {
+  return WST__namespace.findPackageRoot(options?.cwd ?? process__default.cwd());
+}
+
+function getPackageInfo(options) {
+  const packageDir = getPackageFolder(options);
+  return readPackageInfo({ packageDir });
+}
+function readPackageInfo({
+  packageDir
+}) {
+  const packageJsonPath = path__default.join(packageDir, "package.json");
+  const packageJson = JSON.parse(
+    node_fs.readFileSync(packageJsonPath, "utf-8")
+  );
+  return {
+    name: packageJson.name,
+    path: packageJsonPath,
+    dirpath: packageDir,
+    packageJson
+  };
+}
+
+function getWorkspaceProjectInfo(options) {
+  try {
+    const workspaceDir = getWorkspaceFolder(options);
+    return readPackageInfo({ packageDir: workspaceDir });
+  } catch (e) {
+    console.error(e);
+    throw new Error("Root workspace not found");
+  }
+}
+
+function getWorkspacePackageInfoList(options) {
+  const { workspaceDir, resolveWstList } = common(options);
+  const wstList = WST__namespace.getWorkspaceInfos(workspaceDir);
+  return resolveWstList(wstList);
+}
+function common(options) {
+  const { cwd, includeRoot: includeWorkspace } = options ?? {};
+  const workspaceDir = getWorkspaceFolder({ cwd });
+  function resolveWstList(list) {
+    if (!workspaceDir || !list) return [];
+    if (includeWorkspace) return [getWorkspaceProjectInfo(), ...list];
+    return list;
+  }
+  return {
+    workspaceDir,
+    includeWorkspace,
+    resolveWstList
+  };
+}
+
+function getWorkspacePackageInfoMap(options) {
+  const workspaceInfo = getWorkspacePackageInfoList(options);
+  const entries = workspaceInfo.map((info) => [info.name, info]);
+  return Object.fromEntries(entries);
+}
+
+function getProjectInfoByName(name, options) {
+  const { cwd } = options ?? {};
+  return getWorkspacePackageInfoMap({ cwd })[name];
+}
+
+function getGitRootFolder(options) {
+  const { cwd = process__default.cwd(), throwIfNotFound = true } = options ?? {};
+  const { stdout } = execa.execaSync("git", ["rev-parse", "--show-toplevel"], {
+    cwd,
+    reject: false
+  });
+  if (!stdout) {
+    if (throwIfNotFound) {
+      throw new Error(`Directory "${cwd}" is not in a git repository`);
+    }
+    return void 0;
+  }
+  return path__default$1.normalize(stdout);
+}
+
+function getProjectInfo(folder, options) {
+  if (isWorkspaceFolderTypeOption(folder)) {
+    return getWorkspaceProjectInfo(
+      parseWorkspaceFolderTypeOptions(folder, options)
+    );
+  }
+  if (folder === "<package_folder>") {
+    return getPackageInfo(options);
+  }
+  if (folder === "<gitroot_folder>") {
+    return readPackageInfo({ packageDir: getGitRootFolder(options) });
+  }
+  return getProjectInfoByName(folder.packageName, options);
+}
+function isWorkspaceFolderTypeOption(option) {
+  return Boolean(
+    option === "<workspace_folder>" || typeof option === "object" && "<workspace_folder>" in option
+  );
+}
+function parseWorkspaceFolderTypeOptions(option, defaultOptions) {
+  if (typeof option === "string") {
+    return defaultOptions ?? {};
+  }
+  return { ...defaultOptions, ...option["<workspace_folder>"] };
+}
+
+const project = (...args) => {
+  const [source, projectOptions] = args;
+  const { packageJson, packageJsonPath, packageName, projectDir } = info();
+  const {
+    findPackageManager: findPackageManager2,
+    detectPackageManagers,
+    detectLockfilePackageManagers,
+    detectGlobalPackageManagers,
+    globalVersions,
+    filterPackageManagers,
+    mapPackageManagers
+  } = definePackageManagerClient({ cwd: projectDir });
+  return {
+    packageJson,
+    packageJsonPath,
+    packageName,
+    projectDir,
+    findPackageManager: findPackageManager2,
+    detectPackageManagers,
+    detectGlobalPackageManagers,
+    detectLockfilePackageManagers,
+    globalVersions,
+    mapPackageManagers,
+    tsconfig: tsconfig(projectDir ?? ""),
+    gitignore: gitignore(path__default$1.join(projectDir ?? "", ".gitignore")),
+    filterPackageManagers,
+    getPackageJson: () => get("packageJson"),
+    findDependencyInPackageJson: (options) => findDependencyInPackageJson(options, get("packageJson")),
+    isDependencyInPackageJson: (options) => isDependencyInPackageJson(options, get("packageJson"))
+  };
+  function info() {
+    const {
+      packageJson: packageJson2,
+      name: packageName2,
+      dirpath: projectDir2,
+      path: packageJsonPath2
+    } = getProjectInfo(source, projectOptions) ?? {};
+    return {
+      packageJson: packageJson2,
+      packageJsonPath: packageJsonPath2,
+      packageName: packageName2,
+      projectDir: projectDir2
+    };
+  }
+  function get(key) {
+    return info()[key];
+  }
+};
+
+function getWorkspacePackageNames(options) {
+  return getWorkspacePackageInfoList(options).map((e) => e.name);
+}
+
+const workspace = {
+  packageNames: getWorkspacePackageNames,
+  packageGraph: getWorkspacePackageInfoMap,
+  packageList: getWorkspacePackageInfoList,
+  workspaceRootDir: getWorkspaceFolder,
+  getProject: project
+};
+
+function importer(imports, options) {
+  const { install: defaultInstall = true, installer } = options ?? {};
+  return Promise.all(
+    imports.map(async (e) => {
+      const importOpt = resolveImportOption(e);
+      const shouldInstall = importOpt.install ?? defaultInstall;
+      if (shouldInstall && importOpt.name) {
+        await installImport(importOpt.name, importOpt, installer);
+      }
+      const m = await importOpt.import();
+      return resolveModule(m);
+    })
+  );
+}
+const definePackage = (option) => {
+  const { name, ...rest } = typeof option === "string" ? { name: option } : option;
+  return {
+    name,
+    import: () => import(name),
+    ...rest
+  };
+};
+function resolveImportOption(option) {
+  if (typeof option === "function") {
+    return {
+      import: option
+    };
+  }
+  if (option instanceof Promise) {
+    return {
+      import: () => option
+    };
+  }
+  return option;
+}
+async function installImport(packageName, options, installer) {
+  if (!packageName) return;
+  const { checkExists } = options ?? {};
+  if (checkExists && isPackageDependency(packageName)) return;
+  const installerFn = installer ?? (await workspace.getProject("<package_folder>").findPackageManager()).installPackage;
+  await installerFn(packageName, options);
+}
+
+const importMap = async (importMap2, options) => {
+  const keys = Object.keys(importMap2);
+  const imported = await importer(
+    keys.map((key) => importMap2[key]),
+    options
+  );
+  return Object.fromEntries(
+    keys.map((key, index) => [key, imported[index]])
+  );
+};
+
+function definePackageManager(config, options) {
+  const { cwd: defaultCwd } = options ?? {};
+  const { command, args: agentArgs, options: agentOptions } = config;
+  const findLockfilePath = asyncCacheFn.asyncCacheFn(async (options2) => {
+    const { cwd = defaultCwd } = options2 ?? {};
+    const lockfiles = toArray(config.meta.lockfile);
+    return await findUp.findUp(lockfiles, { cwd });
+  });
+  const installPackage = async (packageName, options2) => {
+    const install = agentArgs.install;
+    const { dev, preferOffline } = select(
+      install.options,
+      {
+        preferOffline: true,
+        cwd: defaultCwd,
+        ...options2
+      });
+    const packageNames = toArray(packageName);
+    try {
+      await $$({
+        command,
+        args: [install.command, dev, preferOffline, ...packageNames],
+        cwd: defaultCwd,
+        ...options2
+      });
+    } catch (error) {
+      throw new Error(`Failed to install: ${packageNames.join(", ")}`, {
+        cause: error
+      });
+    }
+  };
+  const uninstallPackage = async (packageName, options2) => {
+    const uninstall = agentArgs.uninstall;
+    const cwd = options2?.cwd ?? defaultCwd;
+    const { packageJson } = getPackageInfo({ cwd });
+    const installed = toArray(packageName).filter(
+      (name) => isDependencyInPackageJson(name, packageJson)
+    );
+    if (installed.length === 0) return;
+    try {
+      await $$({
+        command,
+        args: [uninstall.command, ...installed],
+        cwd,
+        ...options2
+      });
+    } catch (error) {
+      throw new Error(`Failed to uninstall: ${installed.join(", ")}`, {
+        cause: error
+      });
+    }
+  };
+  return {
+    id: config.id,
+    config,
+    findLockfilePath,
+    hasLockfile: asyncCacheFn.asyncCacheFn(async (...args) => {
+      const lockfilePath = await findLockfilePath.noCache(...args);
+      return Boolean(lockfilePath);
+    }),
+    readLockfile: asyncCacheFn.asyncCacheFn(async (...args) => {
+      const lockfilePath = await findLockfilePath.noCache(...args);
+      if (!lockfilePath) return void 0;
+      return promises.readFile(lockfilePath, "utf8");
+    }),
+    globalVersion: asyncCacheFn.asyncCacheFn(async (...args) => {
+      const [options2] = args;
+      try {
+        const { stdout } = await $$({
+          command,
+          args: [agentOptions.version],
+          cwd: defaultCwd,
+          ...options2
+        });
+        return `${stdout}`;
+      } catch (e) {
+        return void 0;
+      }
+    }),
+    definePackage,
+    installPackage,
+    uninstallPackage,
+    defineImportMap(imports, options2) {
+      const { install = true } = options2 ?? {};
+      return importMap(imports, {
+        install,
+        installer: installPackage
+      });
+    }
+  };
+}
+async function $$(options) {
+  const { command, args = [], silent = true, cwd, shellOptions } = options;
+  return execa.execa(command, args.filter(notFalsy), {
+    cwd,
+    ...shellOptions,
+    // `pipe` keeps output off the console while still capturing it: a failed
+    // command can report why it failed, and `globalVersion` can read stdout.
+    // `ignore` discards the reason along with the output.
+    stdio: silent ? "pipe" : "inherit"
+  });
+}
+
+function definePackageManagerConfig(config) {
+  return config;
+}
+
+const bun = definePackageManagerConfig({
+  id: "bun",
+  name: "Bun",
+  command: "bun",
+  runner: "bunx",
+  meta: {
+    lockfile: "bun.lockb"
+  },
+  args: {
+    install: {
+      command: "install",
+      options: {
+        dev: "-D",
+        preferOffline: "--prefer-offline"
+      }
+    },
+    uninstall: {
+      command: "uninstall"
+    }
+  },
+  options: {
+    version: "--version"
+  }
+});
+
+const npm = definePackageManagerConfig({
+  id: "npm",
+  name: "NPM",
+  command: "npm",
+  runner: "npx",
+  meta: {
+    lockfile: ["package-lock.json", "npm-shrinkwrap.json"]
+  },
+  args: {
+    install: {
+      command: "install",
+      options: {
+        dev: "-D",
+        preferOffline: "--prefer-offline"
+      }
+    },
+    uninstall: {
+      command: "uninstall"
+    }
+  },
+  options: {
+    version: "--version"
+  }
+});
+
+const pnpm = definePackageManagerConfig({
+  id: "pnpm",
+  name: "PNPM",
+  command: "pnpm",
+  runner: "pnpx",
+  meta: {
+    lockfile: "pnpm-lock.yaml"
+  },
+  args: {
+    install: {
+      command: "install",
+      options: {
+        dev: "-D",
+        preferOffline: "--prefer-offline"
+      }
+    },
+    uninstall: {
+      command: "remove"
+    }
+  },
+  options: {
+    version: "--version"
+  }
+});
+
+const yarn = definePackageManagerConfig({
+  id: "yarn",
+  name: "Yarn",
+  command: "yarn",
+  runner: "yarn dlx",
+  meta: {
+    lockfile: "yarn.lock"
+  },
+  args: {
+    install: {
+      command: "add",
+      options: {
+        dev: "-D",
+        preferOffline: "--prefer-offline"
+      }
+    },
+    uninstall: {
+      command: "remove"
+    }
+  },
+  options: {
+    version: "--version"
+  }
+});
+
+async function findPackageManager(packageManagers, options) {
+  const packageManager = await findPackageManagerSafely(
+    packageManagers,
+    options
+  );
+  invariant(packageManager, "No package manager found");
+  return packageManager;
+}
+async function findPackageManagerSafely(packageManagers, options) {
+  const [fromLockfile] = await detectLockfilePackageManagers(
+    packageManagers,
+    options
+  );
+  if (fromLockfile) return fromLockfile;
+  const [fromGlobal] = await detectGlobalPackageManagers(
+    packageManagers,
+    options
+  );
+  return fromGlobal;
+}
+async function detectPackageManagers(packageManagers, options) {
+  return [
+    ...await detectLockfilePackageManagers(packageManagers, options),
+    ...await detectGlobalPackageManagers(packageManagers, options)
+  ];
+}
+async function detectLockfilePackageManagers(packageManagers, options) {
+  return filterPackageManagers(
+    packageManagers,
+    (packageManager) => packageManager.hasLockfile(options),
+    options
+  );
+}
+async function detectGlobalPackageManagers(packageManagers, options) {
+  return filterPackageManagers(
+    packageManagers,
+    // Without the `await`, `Boolean` receives a pending promise and is always
+    // `true`, so every package manager passes the filter regardless of whether
+    // it is actually installed.
+    async (packageManager) => Boolean(await packageManager.globalVersion(options)),
+    options
+  );
+}
+async function getGlobalVersions(packageManagers, options) {
+  const entries = await mapPackageManagers(
+    packageManagers,
+    async (packageManager) => [packageManager.id, await packageManager.globalVersion(options)],
+    options
+  );
+  return Object.fromEntries(entries);
+}
+async function mapPackageManagers(packageManagers, mapFn, options) {
+  return Promise.all(
+    selectAllowedPackageManagers(packageManagers, options).map(
+      (packageManager) => mapFn(packageManager)
+    )
+  );
+}
+async function filterPackageManagers(packageManagers, filterFn, options) {
+  const matches = await mapPackageManagers(
+    packageManagers,
+    async (packageManager) => await filterFn(packageManager) ? packageManager : void 0,
+    options
+  );
+  return matches.filter(notFalsy);
+}
+function selectAllowedPackageManagers(packageManagers, options) {
+  return packageManagers.filter(
+    ({ id }) => options?.allowed ? id in options.allowed : true
+  );
+}
+
+const packageManagerConfigs = [pnpm, yarn, bun, npm];
+function definePackageManagerClient(options) {
+  const configs = packageManagerConfigs.map(
+    (config) => definePackageManager(config, options)
+  );
+  return {
+    configs,
+    findPackageManager: asyncCacheFn.asyncCacheFn(
+      async (options2) => await findPackageManager(configs, options2)
+    ),
+    findPackageManagerSafely: asyncCacheFn.asyncCacheFn(
+      async (options2) => await findPackageManagerSafely(configs, options2)
+    ),
+    detectPackageManagers: asyncCacheFn.asyncCacheFn(
+      async (options2) => await detectPackageManagers(configs, options2)
+    ),
+    detectLockfilePackageManagers: asyncCacheFn.asyncCacheFn(
+      async (options2) => detectLockfilePackageManagers(configs, options2)
+    ),
+    detectGlobalPackageManagers: asyncCacheFn.asyncCacheFn(
+      async (options2) => detectGlobalPackageManagers(configs, options2)
+    ),
+    globalVersions: asyncCacheFn.asyncCacheFn(
+      async (options2) => getGlobalVersions(configs, options2)
+    ),
+    filterPackageManagers: async (filterFn, options2) => filterPackageManagers(configs, filterFn, options2),
+    mapPackageManagers: async (mapFn, options2) => mapPackageManagers(configs, mapFn, options2)
+  };
+}
+
+function isPackageDependency(packageName) {
+  return toArray(packageName).every((name) => isDependencyInPackageJson(name));
+}
+
+function definePathAliases(aliasDefinitions) {
+  const aliasMap = getAliasMap(aliasDefinitions);
+  function getFilePath(options, aliases) {
+    return getAliasedFilePath(
+      { ...aliasMap, ...aliases },
+      options
+    );
+  }
+  return {
+    aliasDefinitions,
+    aliasMap,
+    getFilePath
+  };
+}
+function getAliasedFilePath(aliasMap, options) {
+  const { to, startingFrom, cwd, checkExistence, glob } = typeof options === "string" || Array.isArray(options) ? { to: options } : options;
+  const resolveOptions = { cwd, checkExistence, glob, aliasMap };
+  try {
+    return startingFrom ? resolveRelativePathTo(to, startingFrom, resolveOptions) : resolvePathTo(to, resolveOptions);
+  } catch (error) {
+    if (checkExistence || glob) return void 0;
+    throw error;
+  }
+}
+function resolveRelativePathTo(to, from, options) {
+  const pathFrom = resolvePathTo(from, options);
+  const pathTo = resolvePathTo(to, options);
+  return path__default$1.relative(pathFrom, pathTo);
+}
+function resolvePathTo(pathTo, { cwd, checkExistence, glob, aliasMap }) {
+  const normalized = normalizePathTo(pathTo, { cwd, aliasMap });
+  if (glob) {
+    const globPaths = globby.globbySync(normalized, { cwd });
+    if (!globPaths[0])
+      throw new Error(`No paths found for glob: ${normalized}`);
+    return globPaths[0];
+  }
+  if (!glob && checkExistence && !node_fs.existsSync(normalized))
+    throw new Error(`Path does not exist: ${normalized}`);
+  return normalized;
+}
+function normalizePathTo(pathTo, options) {
+  const { cwd, aliasMap } = options ?? {};
+  const aliasedPath = Array.isArray(pathTo) ? path__default$1.join(...pathTo.filter(isNotNull)) : pathTo;
+  const baseDir = Array.isArray(pathTo) ? pathTo[0] : findAliasToken(aliasedPath, aliasMap);
+  if (baseDir === void 0) return aliasedPath;
+  const baseDirPath = executeMapFn(aliasMap, baseDir, [{ cwd }]);
+  if (typeof baseDirPath !== "string" || baseDirPath.length === 0) {
+    throw new Error(`Path alias resolved to no location: ${baseDir}`);
+  }
+  return utils.resolveAlias(aliasedPath, { [baseDir]: baseDirPath });
+}
+function findAliasToken(pathTo, aliasMap) {
+  return Object.keys(aliasMap ?? {}).filter((alias) => pathTo === alias || pathTo.startsWith(`${alias}/`)).sort((a, b) => b.length - a.length)[0];
+}
+function executeMapFn(map, key, args) {
+  if (!map || !key || !(key in map)) return void 0;
+  const fnArgs = Array.isArray(args) ? args : [args];
+  const resolver = map?.[key];
+  return typeof resolver === "function" ? resolver?.(...fnArgs) : resolver;
+}
+function getAliasMap(aliasDefs) {
+  return Object.fromEntries(
+    Object.entries(aliasDefs).flatMap(([alias, v]) => {
+      const { resolve, subpaths = [] } = v;
+      return [
+        [alias, resolve],
+        ...subpaths.map(({ to }) => {
+          const subpathAlias = path__default$1.join(alias, to);
+          return [
+            subpathAlias,
+            (opts) => utils.resolveAlias(subpathAlias, { [alias]: resolve(opts) })
+          ];
+        })
+      ];
+    })
+  );
+}
+function isNotNull(value) {
+  return value !== null && value !== void 0;
+}
+
+const predefinedPathAliases = {
+  "<workspace_folder>": {
+    resolve: (opts) => getWorkspaceFolder(opts),
+    subpaths: [
+      {
+        to: "node_modules"
+      },
+      {
+        to: "node_modules/.bin"
+      }
+    ]
+  },
+  "<workspace_folder?>": {
+    resolve: (opts) => getWorkspaceFolder({ ...opts, fallbackToGitRoot: false }),
+    subpaths: [
+      {
+        to: "node_modules"
+      },
+      {
+        to: "node_modules/.bin"
+      }
+    ]
+  },
+  "<package_folder>": {
+    resolve: (opts) => getPackageFolder(opts),
+    subpaths: [
+      {
+        to: "node_modules"
+      },
+      {
+        to: "node_modules/.bin"
+      },
+      {
+        to: "src"
+      }
+    ]
+  },
+  "<gitroot_folder>": {
+    resolve: (opts) => getGitRootFolder(opts),
+    subpaths: [
+      {
+        to: "node_modules"
+      },
+      {
+        to: "node_modules/.bin"
+      },
+      {
+        to: ".vscode"
+      }
+    ]
+  },
+  "<user_home>": {
+    resolve: () => os__default.homedir(),
+    subpaths: []
+  },
+  "<user_tmpdir>": {
+    resolve: () => os__default.tmpdir(),
+    subpaths: []
+  },
+  "<cwd>": {
+    resolve: () => process__default.cwd(),
+    subpaths: []
+  },
+  "<current_file>": {
+    // resolve: () => fileURLToPath(import.meta.url),
+    resolve: () => _filename({ rootFunctionName: "getFilePath" }) ?? "",
+    subpaths: []
+  },
+  "<current_folder>": {
+    // resolve: () => fileURLToPath(import.meta.url),
+    resolve: () => _dirname({ rootFunctionName: "getFilePath" }) ?? "",
+    subpaths: []
+  }
+};
+
+const getPath = definePathAliases(predefinedPathAliases).getFilePath;
+
+function getFolderByPackageName(name, options) {
+  const infoMap = getWorkspacePackageInfoMap({ ...options, includeRoot: true });
+  const info = infoMap?.[name];
+  return info?.dirpath;
+}
+
+const jsonSourceResolvers = {
+  data: (json) => {
+    return {
+      text: () => JSON.stringify(json),
+      data: () => json
+    };
+  },
+  text: (text) => {
+    return {
+      text: () => text,
+      data: () => JSON.parse(text)
+    };
+  },
+  filepath: (filepath) => {
+    const text = node_fs.readFileSync(filepath, "utf-8");
+    return {
+      text: () => text,
+      data: () => JSON.parse(text)
+    };
+  }
+};
+function resolveJsonSource(source, as) {
+  const [sourceType, sourceData] = Object.entries(source).find(([_, selected]) => selected !== void 0) ?? [];
+  if (!sourceType || !(sourceType in jsonSourceResolvers) || !sourceData) {
+    throw new Error("Invalid source data");
+  }
+  const sourceTypeResolvers = jsonSourceResolvers[sourceType](
+    sourceData
+  );
+  const resolved = util.morph(sourceTypeResolvers, (key, v) => {
+    try {
+      const value = v();
+      return !as || key === as ? [key, value] : [];
+    } catch (e) {
+      throw new Error(`Failed to resolve ${key} from ${sourceType}`);
+    }
+  });
+  if (as) {
+    return resolved[as];
+  }
+  return resolved;
+}
+
+function resolveEditPath(path, options) {
+  const { pathSeparator = "." } = {};
+  const arr = toArray(path);
+  return arr.map((path2) => {
+    if (typeof path2 === "string") {
+      return pathSeparator === false ? path2 : path2.split(pathSeparator);
+    }
+    return path2;
+  }).flat();
+}
+function parseJSONCEdits(edits) {
+  if (Array.isArray(edits)) {
+    return edits.map(({ path, ...edit }) => ({
+      path: resolveEditPath(path),
+      ...edit
+    }));
+  }
+  return Object.entries(edits).map(
+    ([path, value]) => ({
+      path: resolveEditPath(path),
+      ...value
+    })
+  );
+}
+function modifyJSON({
+  json,
+  edits,
+  defaultEditOptions
+}) {
+  return checkResult(() => {
+    const text = resolveJsonSource(json, "text");
+    const jsoncEdits = parseJSONCEdits(edits);
+    const editResult = jsoncEdits.flatMap(
+      (edit) => jsoncParser.modify(text, edit.path, edit.value, {
+        ...defaultEditOptions,
+        ...edit.options
+      })
+    );
+    const updated = jsoncParser.applyEdits(text, editResult);
+    return resolveJsonSource({ text: updated });
+  });
+}
+function modifyJSONFile(filepath, edits, options) {
+  return checkResult(() => {
+    const { autoCommit = true, defaultEditOptions } = options || {};
+    const { data: json, error } = modifyJSON({
+      json: { filepath },
+      edits,
+      defaultEditOptions
+    });
+    if (error) {
+      throw error;
+    }
+    const commit = () => node_fs.writeFileSync(filepath, json.text);
+    if (autoCommit) {
+      commit();
+      return json;
+    }
+    return {
+      json,
+      commit
+    };
+  });
+}
+
+function isStorageValue(input) {
+  return input === null || typeof input === "string" || typeof input === "number" || typeof input === "boolean" || typeof input === "object";
+}
+
+const storage = unstorage.createStorage({ driver: defineMemoryDriver__default() });
+const tempFileSystem = defineFileSystemStorage({
+  base: path.join(os__default.tmpdir(), ".package-manager")
+});
+function defineFileSystemEntries(definition) {
+  const fileSystemEntries = Object.entries(definition).map(([k, v]) => {
+    if (v instanceof Function) {
+      const {
+        file,
+        options,
+        serialize = (input) => JSON.stringify(input),
+        deserialize = (input) => {
+          try {
+            return JSON.parse(input);
+          } catch {
+            return input;
+          }
+        }
+      } = v();
+      return {
+        key: k,
+        value: serialize(file),
+        options,
+        serialize,
+        deserialize
+      };
+    }
+    if (isStorageValue(v)) {
+      return {
+        key: k,
+        value: JSON.stringify(v)
+      };
+    }
+    return void 0;
+  }).filter((v) => v !== void 0);
+  const resolved = {
+    definition,
+    fileSystemEntries
+  };
+  return resolved;
+}
+function defineFileSystemStorage(options) {
+  const { base: root, initial, ...storageOptions } = options;
+  let initialFileEntriesData = defineFileSystemEntries(initial ?? {});
+  const storage2 = unstorage.createStorage({
+    driver: defineFsLiteDriver__default({ base: root, ...storageOptions })
+  });
+  const fileStorage = {
+    createFile: async (key, data) => {
+      await storage2.setItem(key, data);
+      return {
+        key,
+        filepath: path.join(root, key),
+        get: async () => storage2.getItem(key),
+        update: async (data2) => storage2.setItem(key, data2)
+      };
+    },
+    async getFilePath(key) {
+      return (await this.getFile(key)).filepath;
+    },
+    getFile: async (key) => {
+      const storageData = await storage2.getItem(key);
+      return {
+        key,
+        filepath: path.join(root, key),
+        data: storageData,
+        read: async () => (await storage2.getItemRaw(key))?.toString()
+      };
+    },
+    async readFile(key) {
+      const { read } = await this.getFile(key);
+      const content = await read();
+      return content;
+    },
+    snapshotFs: async (base = root) => {
+      return unstorage.snapshot(storage2, base);
+    },
+    restoreFs: async (snapshot2) => {
+      return unstorage.restoreSnapshot(storage2, snapshot2);
+    },
+    initializeFs: async (override) => {
+      if (override) {
+        initialFileEntriesData = defineFileSystemEntries(override);
+      }
+      await storage2.clear();
+      return storage2.setItems(initialFileEntriesData.fileSystemEntries);
+    },
+    defineFileSystemEntries,
+    removeAllFiles: storage2.clear,
+    async deleteFileSystem() {
+      await this.removeAllFiles();
+      await storage2.unmount(root, true);
+      await promises.rm(root, { recursive: true, force: true });
+    },
+    storage: storage2,
+    meta: {
+      fileEntriesData: initialFileEntriesData
+    }
+  };
+  if (initial) {
+    return {
+      initialize: async () => {
+        await fileStorage.initializeFs(initial);
+        return fileStorage;
+      }
+    };
+  }
+  return fileStorage;
+}
+
+exports._dirname = _dirname;
+exports._filename = _filename;
+exports.defineFileSystemEntries = defineFileSystemEntries;
+exports.defineFileSystemStorage = defineFileSystemStorage;
+exports.definePackage = definePackage;
+exports.definePackageManagerClient = definePackageManagerClient;
+exports.definePathAliases = definePathAliases;
+exports.detectGlobalPackageManagers = detectGlobalPackageManagers;
+exports.detectLockfilePackageManagers = detectLockfilePackageManagers;
+exports.detectPackageManagers = detectPackageManagers;
+exports.filterPackageManagers = filterPackageManagers;
+exports.findDependencyInPackageJson = findDependencyInPackageJson;
+exports.findPackageManager = findPackageManager;
+exports.findPackageManagerSafely = findPackageManagerSafely;
+exports.findResolvedModulePath = findResolvedModulePath;
+exports.getAliasMap = getAliasMap;
+exports.getFolderByPackageName = getFolderByPackageName;
+exports.getGitRootFolder = getGitRootFolder;
+exports.getGlobalVersions = getGlobalVersions;
+exports.getPackageFolder = getPackageFolder;
+exports.getPath = getPath;
+exports.getWorkspaceFolder = getWorkspaceFolder;
+exports.importMap = importMap;
+exports.importer = importer;
+exports.isDependencyInPackageJson = isDependencyInPackageJson;
+exports.isPackageDependency = isPackageDependency;
+exports.isPackageModuleFound = isPackageModuleFound;
+exports.mapPackageManagers = mapPackageManagers;
+exports.modifyJSON = modifyJSON;
+exports.modifyJSONFile = modifyJSONFile;
+exports.packageManagerConfigs = packageManagerConfigs;
+exports.predefinedPathAliases = predefinedPathAliases;
+exports.project = project;
+exports.resolveModule = resolveModule;
+exports.resolveModulePath = resolveModulePath;
+exports.resolvePackageModulePath = resolvePackageModulePath;
+exports.storage = storage;
+exports.tempFileSystem = tempFileSystem;
+exports.workspace = workspace;