package-management 0.0.8 → 0.0.10

package/dist/index.cjs

@@ -1,1006 +0,0 @@
-'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_fs = require('node:fs');
-const execa = require('execa');
-const asyncCacheFn = require('async-cache-fn');
-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');
-
-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 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 mode === "omit" ? !selection[key] : 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 (!index || !arr)
-    return void 0;
-  return arr[index + offset];
-}
-function isMatching(a, b) {
-  if (!a || !b)
-    return false;
-  return a === b;
-}
-
-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(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 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 || !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.getWorkspaceRoot;
-  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.getWorkspaces(workspaceDir);
-  return resolveWstList(wstList);
-}
-function common(options) {
-  const { cwd, includeRoot: includeWorkspace } = options ?? {};
-  const workspaceDir = getWorkspaceFolder({ cwd });
-  function resolveWstList(list) {
-    if (!workspaceDir)
-      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 getProjectInfo(folder, options) {
-  if (isWorkspaceFolderTypeOption(folder)) {
-    return getWorkspaceProjectInfo(
-      parseWorkspaceFolderTypeOptions(folder, options)
-    );
-  }
-  if (folder === "<package_folder>") {
-    return getPackageInfo(options);
-  }
-  if (folder === "<gitroot_folder>") {
-    return getPackageInfo(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>"] };
-}
-getProjectInfo({
-  "<workspace_folder>": {}
-});
-
-const project = (...args) => {
-  const [source, projectOptions] = args;
-  const { packageJson, packageJsonPath, packageName, projectDir } = info();
-  const {
-    findPackageManager: findPackageManager2,
-    detectPackageManagers,
-    detectLockfilePackageManagers,
-    detectGlobalPackageManagers,
-    filterPackageManagers
-  } = definePackageManagerClient({ cwd: projectDir });
-  return {
-    packageJson,
-    packageJsonPath,
-    packageName,
-    projectDir,
-    findPackageManager: findPackageManager2,
-    detectPackageManagers,
-    detectGlobalPackageManagers,
-    detectLockfilePackageManagers,
-    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
-      },
-      "pick"
-    );
-    const packageNames = toArray(packageName);
-    try {
-      await $$({
-        command,
-        args: [install.command, dev, preferOffline, ...packageNames],
-        cwd: defaultCwd,
-        ...options2
-      });
-    } catch (e) {
-      throw new Error(`Failed to install: ${packageNames.join(", ")}`);
-    }
-  };
-  const uninstallPackage = async (packageName, options2) => {
-    const uninstall = agentArgs.uninstall;
-    await Promise.all(
-      toArray(packageName).map(async (name) => {
-        try {
-          await $$({
-            command,
-            args: [uninstall.command, name],
-            cwd: defaultCwd,
-            ...options2
-          });
-        } catch (e) {
-        }
-      })
-    );
-  };
-  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,
-    stdio: silent ? "ignore" : "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 { ...rest } = options ?? {};
-  const packageManager = await findPackageManagerSafely(packageManagers, rest);
-  invariant(packageManager, "No package manager found");
-  return packageManager;
-}
-async function findPackageManagerSafely(packageManagers, options) {
-  const lockfilePm = (await detectLockfilePackageManagers(packageManagers, options))[0];
-  if (lockfilePm) {
-    return lockfilePm;
-  }
-  const globalPm = (await detectGlobalPackageManagers(packageManagers, options))[0];
-  return globalPm;
-}
-async function detectPackageManagers(packageManagers, options) {
-  return [
-    ...await detectLockfilePackageManagers(packageManagers, options),
-    ...await detectGlobalPackageManagers(packageManagers, options)
-  ];
-}
-async function detectLockfilePackageManagers(packageManagers, options) {
-  return filterPackageManagers(
-    packageManagers,
-    (e) => e.hasLockfile(options),
-    options
-  );
-}
-async function detectGlobalPackageManagers(packageManagers, options) {
-  return filterPackageManagers(
-    packageManagers,
-    async (e) => Boolean(e.globalVersion(options)),
-    options
-  );
-}
-async function filterPackageManagers(packageManagers, filterFn, options) {
-  const allowedPackageManagers = packageManagers.filter(({ id }) => {
-    if (!options?.allowed)
-      return true;
-    return id in options.allowed;
-  });
-  return (await Promise.all(
-    allowedPackageManagers.map(async (pm) => {
-      const valid = await filterFn(pm);
-      return valid ? pm : void 0;
-    })
-  )).filter(notFalsy);
-}
-
-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)
-    ),
-    filterPackageManagers: async (filterFn, options2) => filterPackageManagers(configs, filterFn, 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) {
-  try {
-    if (typeof options === "string" || Array.isArray(options)) {
-      return resolvePathTo(options, { aliasMap });
-    }
-    const opts = { ...options, aliasMap };
-    if (opts.startingFrom) {
-      return resolveRelativePathTo(opts.to, opts.startingFrom, opts);
-    }
-    return resolvePathTo(opts.to, opts);
-  } catch (e) {
-    return void 0;
-  }
-}
-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 ?? {};
-  if (Array.isArray(pathTo)) {
-    const [baseDir] = pathTo;
-    const aliasedPath = path__default$1.join(...pathTo.filter(isNotNull));
-    return utils.resolveAlias(aliasedPath, {
-      [baseDir]: executeMapFn(aliasMap, baseDir, [{ cwd }])
-    });
-  }
-  return pathTo;
-}
-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),
-    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;
-}
-
-function getGitRootFolder(options) {
-  const output = execa.execaSync(`git rev-parse --show-toplevel`, {
-    ...options,
-    reject: false
-  });
-  if (!output.stdout) {
-    console.warn(`Directory "${output.cwd}" is not in a git repository`);
-    return void 0;
-  }
-  return path__default$1.normalize(output.stdout);
-}
-
-exports._dirname = _dirname;
-exports._filename = _filename;
-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.getPackageFolder = getPackageFolder;
-exports.getPath = getPath;
-exports.getWorkspaceFolder = getWorkspaceFolder;
-exports.importMap = importMap;
-exports.importer = importer;
-exports.isDependencyInPackageJson = isDependencyInPackageJson;
-exports.isPackageDependency = isPackageDependency;
-exports.isPackageModuleFound = isPackageModuleFound;
-exports.packageManagerConfigs = packageManagerConfigs;
-exports.predefinedPathAliases = predefinedPathAliases;
-exports.project = project;
-exports.resolveModule = resolveModule;
-exports.resolveModulePath = resolveModulePath;
-exports.resolvePackageModulePath = resolvePackageModulePath;
-exports.workspace = workspace;