@shopify/cli 3.63.1 → 3.64.0

package/dist/chunk-MO3UHUJB.js

@@ -1,221 +0,0 @@
-import {
-  require_notifier
-} from "./chunk-S4VBXFXP.js";
-import {
-  fanoutHooks,
-  reportAnalyticsEvent
-} from "./chunk-6EIVOQYP.js";
-import {
-  getEnvironmentData
-} from "./chunk-QCB66M7L.js";
-import {
-  CLI_KIT_VERSION
-} from "./chunk-WLZZJLBE.js";
-import {
-  AbortSilentError,
-  CancelExecution,
-  cleanSingleStackTracePath,
-  errorMapper,
-  getAllPublicMetadata,
-  getAllSensitiveMetadata,
-  handler,
-  outputDebug,
-  outputInfo,
-  printEventsJson,
-  require_stacktracey,
-  shouldReportError
-} from "./chunk-TYOQQCHN.js";
-import {
-  bugsnagApiKey
-} from "./chunk-WADS2TV5.js";
-import {
-  require_lib
-} from "./chunk-GEN4RXTD.js";
-import {
-  cwd,
-  isAbsolutePath,
-  joinPath,
-  normalizePath,
-  relativePath
-} from "./chunk-UNPXLODI.js";
-import {
-  __toESM,
-  init_cjs_shims
-} from "./chunk-ZPL24Y2D.js";
-
-// ../cli-kit/src/public/node/error-handler.ts
-init_cjs_shims();
-var import_core = __toESM(require_lib(), 1);
-var import_stacktracey = __toESM(require_stacktracey(), 1);
-var import_js = __toESM(require_notifier(), 1);
-import { realpath } from "fs/promises";
-async function errorHandler(error, config) {
-  if (error instanceof CancelExecution) {
-    if (error.message && error.message !== "") {
-      outputInfo(`\u2728  ${error.message}`);
-    }
-  } else if (error instanceof AbortSilentError) {
-    printEventsJson();
-  } else {
-    return errorMapper(error).then((error2) => {
-      return handler(error2);
-    }).then((mappedError) => {
-      printEventsJson();
-      return reportError(mappedError, config);
-    });
-  }
-}
-var reportError = async (error, config) => {
-  let exitMode = "expected_error";
-  if (shouldReportError(error))
-    exitMode = "unexpected_error";
-  if (config !== void 0) {
-    await reportAnalyticsEvent({ config, errorMessage: error instanceof Error ? error.message : void 0, exitMode });
-  }
-  await sendErrorToBugsnag(error, exitMode);
-};
-async function sendErrorToBugsnag(error, exitMode) {
-  if (import_core.settings.debug) {
-    outputDebug(`Skipping Bugsnag report`);
-    return { reported: false, error, unhandled: void 0 };
-  }
-  const unhandled = exitMode === "unexpected_error";
-  let reportableError;
-  let stacktrace;
-  let report = false;
-  if (error instanceof Error) {
-    report = true;
-    reportableError = new Error(error.message);
-    stacktrace = error.stack;
-  } else if (typeof error === "string" && error.trim().length !== 0) {
-    report = true;
-    reportableError = new Error(error);
-    stacktrace = reportableError.stack;
-  } else {
-    report = false;
-    reportableError = new Error("Unknown error");
-  }
-  const formattedStacktrace = new import_stacktracey.default(stacktrace ?? "").clean().items.map((item) => {
-    const filePath = cleanSingleStackTracePath(item.file);
-    return `    at ${item.callee} (${filePath}:${item.line}:${item.column})`;
-  }).join("\n");
-  reportableError.stack = `Error: ${reportableError.message}
-${formattedStacktrace}`;
-  if (report) {
-    initializeBugsnag();
-    await new Promise((resolve, reject) => {
-      outputDebug(`Reporting ${unhandled ? "unhandled" : "handled"} error to Bugsnag: ${reportableError.message}`);
-      const eventHandler = (event) => {
-        event.severity = "error";
-        event.unhandled = unhandled;
-      };
-      const errorHandler2 = (error2) => {
-        if (error2) {
-          reject(error2);
-        } else {
-          resolve(reportableError);
-        }
-      };
-      import_js.default.notify(reportableError, eventHandler, errorHandler2);
-    });
-  }
-  return { error: reportableError, reported: report, unhandled };
-}
-function cleanStackFrameFilePath({
-  currentFilePath,
-  projectRoot,
-  pluginLocations
-}) {
-  const fullLocation = isAbsolutePath(currentFilePath) ? currentFilePath : joinPath(projectRoot, currentFilePath);
-  const matchingPluginPath = pluginLocations.filter(({ pluginPath }) => fullLocation.indexOf(pluginPath) === 0)[0];
-  if (matchingPluginPath !== void 0) {
-    return joinPath(matchingPluginPath.name, relativePath(matchingPluginPath.pluginPath, fullLocation));
-  }
-  return currentFilePath.replace(/.*node_modules\//, "");
-}
-async function registerCleanBugsnagErrorsFromWithinPlugins(config) {
-  const bugsnagConfigProjectRoot = import_js.default?._client?._config?.projectRoot ?? cwd();
-  const projectRoot = normalizePath(bugsnagConfigProjectRoot);
-  const pluginLocations = await Promise.all(
-    [...config.plugins].map(async ([_, plugin]) => {
-      const followSymlinks = await realpath(plugin.root);
-      return { name: plugin.name, pluginPath: normalizePath(followSymlinks) };
-    })
-  );
-  initializeBugsnag();
-  import_js.default.addOnError(async (event) => {
-    event.errors.forEach((error) => {
-      error.stacktrace.forEach((stackFrame) => {
-        stackFrame.file = cleanStackFrameFilePath({ currentFilePath: stackFrame.file, projectRoot, pluginLocations });
-      });
-    });
-    try {
-      await addBugsnagMetadata(event, config);
-    } catch (metadataError) {
-      outputDebug(`There was an error adding metadata to the Bugsnag report; Ignoring and carrying on ${metadataError}`);
-    }
-  });
-}
-async function addBugsnagMetadata(event, config) {
-  const publicData = getAllPublicMetadata();
-  const { commandStartOptions } = getAllSensitiveMetadata();
-  const { startCommand } = commandStartOptions ?? {};
-  const { "@shopify/app": appPublic, ...otherPluginsPublic } = await fanoutHooks(config, "public_command_metadata", {});
-  const environment = await getEnvironmentData(config);
-  const allMetadata = {
-    command: startCommand,
-    ...appPublic,
-    ...publicData,
-    ...environment,
-    pluginData: otherPluginsPublic
-  };
-  const appData = {};
-  const commandData = {};
-  const environmentData = {};
-  const miscData = {};
-  const appKeys = ["api_key", "partner_id", "project_type"];
-  const commandKeys = ["command"];
-  const environmentKeys = ["cli_version", "node_version", "ruby_version", "uname"];
-  Object.entries(allMetadata).forEach(([key, value]) => {
-    if (key.startsWith("app_") || appKeys.includes(key)) {
-      appData[key] = value;
-    } else if (key.startsWith("cmd_") || commandKeys.includes(key)) {
-      commandData[key] = value;
-    } else if (key.startsWith("env_") || environmentKeys) {
-      environmentData[key] = value;
-    } else {
-      miscData[key] = value;
-    }
-  });
-  const bugsnagMetadata = {
-    "Shopify App": appData,
-    Command: commandData,
-    Environment: environmentData,
-    Misc: miscData
-  };
-  Object.entries(bugsnagMetadata).forEach(([section, values]) => {
-    event.addMetadata(section, values);
-  });
-}
-function initializeBugsnag() {
-  if (import_js.default.isStarted()) {
-    return;
-  }
-  import_js.default.start({
-    appType: "node",
-    apiKey: bugsnagApiKey,
-    logger: null,
-    appVersion: CLI_KIT_VERSION,
-    autoTrackSessions: false,
-    autoDetectErrors: false
-  });
-}
-
-export {
-  errorHandler,
-  sendErrorToBugsnag,
-  cleanStackFrameFilePath,
-  registerCleanBugsnagErrorsFromWithinPlugins,
-  addBugsnagMetadata
-};
-//# sourceMappingURL=chunk-MO3UHUJB.js.map

package/dist/chunk-NBSFQYKI.js

@@ -1,496 +0,0 @@
-import {
-  Conf,
-  latestVersion
-} from "./chunk-DIRL62CL.js";
-import {
-  require_semver
-} from "./chunk-PRJ3U7MR.js";
-import {
-  AbortController,
-  AbortError,
-  BugError,
-  captureOutput,
-  exec,
-  fileExists,
-  findPathUp,
-  glob,
-  outputContent,
-  outputDebug,
-  outputToken,
-  readFile,
-  runWithTimer,
-  writeFile
-} from "./chunk-TYOQQCHN.js";
-import {
-  dirname,
-  joinPath
-} from "./chunk-UNPXLODI.js";
-import {
-  __export,
-  __toESM,
-  init_cjs_shims
-} from "./chunk-ZPL24Y2D.js";
-
-// ../cli-kit/src/public/node/node-package-manager.ts
-var node_package_manager_exports = {};
-__export(node_package_manager_exports, {
-  FindUpAndReadPackageJsonNotFoundError: () => FindUpAndReadPackageJsonNotFoundError,
-  PackageJsonNotFoundError: () => PackageJsonNotFoundError,
-  UnknownPackageManagerError: () => UnknownPackageManagerError,
-  addNPMDependencies: () => addNPMDependencies,
-  addNPMDependenciesIfNeeded: () => addNPMDependenciesIfNeeded,
-  addNPMDependenciesWithoutVersionIfNeeded: () => addNPMDependenciesWithoutVersionIfNeeded,
-  addResolutionOrOverride: () => addResolutionOrOverride,
-  bunLockfile: () => bunLockfile,
-  checkForNewVersion: () => checkForNewVersion,
-  findUpAndReadPackageJson: () => findUpAndReadPackageJson,
-  getDependencies: () => getDependencies,
-  getPackageManager: () => getPackageManager,
-  getPackageName: () => getPackageName,
-  getPackageVersion: () => getPackageVersion,
-  installNPMDependenciesRecursively: () => installNPMDependenciesRecursively,
-  installNodeModules: () => installNodeModules,
-  lockfiles: () => lockfiles,
-  npmLockfile: () => npmLockfile,
-  packageManager: () => packageManager,
-  packageManagerFromUserAgent: () => packageManagerFromUserAgent,
-  pnpmLockfile: () => pnpmLockfile,
-  pnpmWorkspaceFile: () => pnpmWorkspaceFile,
-  readAndParsePackageJson: () => readAndParsePackageJson,
-  usesWorkspaces: () => usesWorkspaces,
-  versionSatisfies: () => versionSatisfies,
-  writePackageJSON: () => writePackageJSON,
-  yarnLockfile: () => yarnLockfile
-});
-init_cjs_shims();
-
-// ../cli-kit/src/private/node/conf-store.ts
-init_cjs_shims();
-
-// ../cli-kit/src/public/node/local-storage.ts
-init_cjs_shims();
-var LocalStorage = class {
-  constructor(options) {
-    this.config = new Conf(options);
-  }
-  /**
-   * Get a value from the local storage.
-   *
-   * @param key - The key to get.
-   * @returns The value.
-   */
-  get(key) {
-    return this.config.get(key);
-  }
-  /**
-   * Set a value in the local storage.
-   *
-   * @param key - The key to set.
-   * @param value - The value to set.
-   */
-  set(key, value) {
-    this.config.set(key, value);
-  }
-  /**
-   * Delete a value from the local storage.
-   *
-   * @param key - The key to delete.
-   */
-  delete(key) {
-    this.config.delete(key);
-  }
-  /**
-   * Clear the local storage (delete all values).
-   */
-  clear() {
-    this.config.clear();
-  }
-};
-
-// ../cli-kit/src/private/node/conf-store.ts
-var _instance;
-function cliKitStore() {
-  if (!_instance) {
-    _instance = new LocalStorage({ projectName: "shopify-cli-kit" });
-  }
-  return _instance;
-}
-function getSession(config = cliKitStore()) {
-  outputDebug(outputContent`Getting session store...`);
-  return config.get("sessionStore");
-}
-function setSession(session, config = cliKitStore()) {
-  outputDebug(outputContent`Setting session store...`);
-  config.set("sessionStore", session);
-}
-function removeSession(config = cliKitStore()) {
-  outputDebug(outputContent`Removing session store...`);
-  config.delete("sessionStore");
-}
-async function cacheRetrieveOrRepopulate(key, fn, timeout, config = cliKitStore()) {
-  const cache = config.get("cache") || {};
-  const cached = cache[key];
-  if (cached?.value !== void 0 && (timeout === void 0 || Date.now() - cached.timestamp < timeout)) {
-    return cached.value;
-  }
-  const value = await fn();
-  cache[key] = { value, timestamp: Date.now() };
-  config.set("cache", cache);
-  return value;
-}
-
-// ../cli-kit/src/public/node/node-package-manager.ts
-var import_semver = __toESM(require_semver(), 1);
-var yarnLockfile = "yarn.lock";
-var npmLockfile = "package-lock.json";
-var pnpmLockfile = "pnpm-lock.yaml";
-var bunLockfile = "bun.lockb";
-var pnpmWorkspaceFile = "pnpm-workspace.yaml";
-var lockfiles = [yarnLockfile, pnpmLockfile, npmLockfile, bunLockfile];
-var packageManager = ["yarn", "npm", "pnpm", "bun", "unknown"];
-var UnknownPackageManagerError = class extends AbortError {
-  constructor() {
-    super("Unknown package manager");
-  }
-};
-var PackageJsonNotFoundError = class extends AbortError {
-  constructor(directory) {
-    super(outputContent`The directory ${outputToken.path(directory)} doesn't have a package.json.`);
-  }
-};
-var FindUpAndReadPackageJsonNotFoundError = class extends BugError {
-  constructor(directory) {
-    super(outputContent`Couldn't find a a package.json traversing directories from ${outputToken.path(directory)}`);
-  }
-};
-function packageManagerFromUserAgent(env = process.env) {
-  if (env.npm_config_user_agent?.includes("yarn")) {
-    return "yarn";
-  } else if (env.npm_config_user_agent?.includes("pnpm")) {
-    return "pnpm";
-  } else if (env.npm_config_user_agent?.includes("bun")) {
-    return "bun";
-  } else if (env.npm_config_user_agent?.includes("npm")) {
-    return "npm";
-  }
-  return "unknown";
-}
-async function getPackageManager(fromDirectory) {
-  const directory = await captureOutput("npm", ["prefix"], { cwd: fromDirectory });
-  outputDebug(outputContent`Obtaining the dependency manager in directory ${outputToken.path(directory)}...`);
-  const packageJson = joinPath(directory, "package.json");
-  if (!await fileExists(packageJson)) {
-    return packageManagerFromUserAgent();
-  }
-  const yarnLockPath = joinPath(directory, yarnLockfile);
-  const pnpmLockPath = joinPath(directory, pnpmLockfile);
-  const bunLockPath = joinPath(directory, bunLockfile);
-  if (await fileExists(yarnLockPath)) {
-    return "yarn";
-  } else if (await fileExists(pnpmLockPath)) {
-    return "pnpm";
-  } else if (await fileExists(bunLockPath)) {
-    return "bun";
-  } else {
-    return "npm";
-  }
-}
-async function installNPMDependenciesRecursively(options) {
-  const packageJsons = await glob(joinPath(options.directory, "**/package.json"), {
-    ignore: [joinPath(options.directory, "node_modules/**/package.json")],
-    cwd: options.directory,
-    onlyFiles: true,
-    deep: options.deep
-  });
-  const abortController = new AbortController();
-  try {
-    await Promise.all(
-      packageJsons.map(async (packageJsonPath) => {
-        const directory = dirname(packageJsonPath);
-        await installNodeModules({
-          directory,
-          packageManager: options.packageManager,
-          stdout: void 0,
-          stderr: void 0,
-          signal: abortController.signal,
-          args: []
-        });
-      })
-    );
-  } catch (error) {
-    abortController.abort();
-    throw error;
-  }
-}
-async function installNodeModules(options) {
-  const execOptions = {
-    cwd: options.directory,
-    stdin: void 0,
-    stdout: options.stdout,
-    stderr: options.stderr,
-    signal: options.signal
-  };
-  let args = ["install"];
-  if (options.args) {
-    args = args.concat(options.args);
-  }
-  await runWithTimer("cmd_all_timing_network_ms")(async () => {
-    await exec(options.packageManager, args, execOptions);
-  });
-}
-async function getPackageName(packageJsonPath) {
-  const packageJsonContent = await readAndParsePackageJson(packageJsonPath);
-  return packageJsonContent.name;
-}
-async function getPackageVersion(packageJsonPath) {
-  const packageJsonContent = await readAndParsePackageJson(packageJsonPath);
-  return packageJsonContent.version;
-}
-async function getDependencies(packageJsonPath) {
-  const packageJsonContent = await readAndParsePackageJson(packageJsonPath);
-  const dependencies = packageJsonContent.dependencies ?? {};
-  const devDependencies = packageJsonContent.devDependencies ?? {};
-  return { ...dependencies, ...devDependencies };
-}
-async function usesWorkspaces(appDirectory) {
-  const packageJsonPath = joinPath(appDirectory, "package.json");
-  const packageJsonContent = await readAndParsePackageJson(packageJsonPath);
-  const pnpmWorkspacePath = joinPath(appDirectory, pnpmWorkspaceFile);
-  return Boolean(packageJsonContent.workspaces) || fileExists(pnpmWorkspacePath);
-}
-async function checkForNewVersion(dependency, currentVersion, { cacheExpiryInHours = 0 } = {}) {
-  const getLatestVersion = async () => {
-    outputDebug(outputContent`Checking if there's a version of ${dependency} newer than ${currentVersion}`);
-    return getLatestNPMPackageVersion(dependency);
-  };
-  const cacheKey = `npm-package-${dependency}`;
-  let lastVersion;
-  try {
-    lastVersion = await cacheRetrieveOrRepopulate(cacheKey, getLatestVersion, cacheExpiryInHours * 24 * 1e3);
-  } catch (error) {
-    return void 0;
-  }
-  if (lastVersion && new import_semver.SemVer(currentVersion).compare(lastVersion) < 0) {
-    return lastVersion;
-  } else {
-    return void 0;
-  }
-}
-function versionSatisfies(version, requirements) {
-  return (0, import_semver.satisfies)(version, requirements);
-}
-async function readAndParsePackageJson(packageJsonPath) {
-  if (!await fileExists(packageJsonPath)) {
-    throw new PackageJsonNotFoundError(dirname(packageJsonPath));
-  }
-  return JSON.parse(await readFile(packageJsonPath));
-}
-async function addNPMDependenciesIfNeeded(dependencies, options) {
-  outputDebug(outputContent`Adding the following dependencies if needed:
-${outputToken.json(dependencies)}
-With options:
-${outputToken.json(options)}
-  `);
-  const packageJsonPath = joinPath(options.directory, "package.json");
-  if (!await fileExists(packageJsonPath)) {
-    throw new PackageJsonNotFoundError(options.directory);
-  }
-  const existingDependencies = Object.keys(await getDependencies(packageJsonPath));
-  const dependenciesToAdd = dependencies.filter((dep) => {
-    return !existingDependencies.includes(dep.name);
-  });
-  if (dependenciesToAdd.length === 0) {
-    return;
-  }
-  await addNPMDependencies(dependenciesToAdd, options);
-}
-async function addNPMDependencies(dependencies, options) {
-  const dependenciesWithVersion = dependencies.map((dep) => {
-    return dep.version ? `${dep.name}@${dep.version}` : dep.name;
-  });
-  options.stdout?.write(`Installing ${[dependenciesWithVersion].join(" ")} with ${options.packageManager}`);
-  switch (options.packageManager) {
-    case "npm":
-      for (const dep of dependenciesWithVersion) {
-        await installDependencies(options, argumentsToAddDependenciesWithNPM(dep, options.type));
-      }
-      break;
-    case "yarn":
-      await installDependencies(
-        options,
-        argumentsToAddDependenciesWithYarn(dependenciesWithVersion, options.type, Boolean(options.addToRootDirectory))
-      );
-      break;
-    case "pnpm":
-      await installDependencies(
-        options,
-        argumentsToAddDependenciesWithPNPM(dependenciesWithVersion, options.type, Boolean(options.addToRootDirectory))
-      );
-      break;
-    case "bun":
-      await installDependencies(options, argumentsToAddDependenciesWithBun(dependenciesWithVersion, options.type));
-      await installDependencies(options, ["install"]);
-      break;
-    case "unknown":
-      throw new UnknownPackageManagerError();
-  }
-}
-async function installDependencies(options, args) {
-  return runWithTimer("cmd_all_timing_network_ms")(async () => {
-    return exec(options.packageManager, args, {
-      cwd: options.directory,
-      stdout: options.stdout,
-      stderr: options.stderr,
-      signal: options.signal
-    });
-  });
-}
-async function addNPMDependenciesWithoutVersionIfNeeded(dependencies, options) {
-  await addNPMDependenciesIfNeeded(
-    dependencies.map((dependency) => {
-      return { name: dependency, version: void 0 };
-    }),
-    options
-  );
-}
-function argumentsToAddDependenciesWithNPM(dependency, type) {
-  let command = ["install"];
-  command = command.concat(dependency);
-  switch (type) {
-    case "dev":
-      command.push("--save-dev");
-      break;
-    case "peer":
-      command.push("--save-peer");
-      break;
-    case "prod":
-      command.push("--save-prod");
-      break;
-  }
-  if (dependency.match(/@\d/g)) {
-    command.push("--save-exact");
-  }
-  return command;
-}
-function argumentsToAddDependenciesWithYarn(dependencies, type, addAtRoot = false) {
-  let command = ["add"];
-  if (addAtRoot) {
-    command.push("-W");
-  }
-  command = command.concat(dependencies);
-  switch (type) {
-    case "dev":
-      command.push("--dev");
-      break;
-    case "peer":
-      command.push("--peer");
-      break;
-    case "prod":
-      command.push("--prod");
-      break;
-  }
-  return command;
-}
-function argumentsToAddDependenciesWithPNPM(dependencies, type, addAtRoot = false) {
-  let command = ["add"];
-  if (addAtRoot) {
-    command.push("-w");
-  }
-  command = command.concat(dependencies);
-  switch (type) {
-    case "dev":
-      command.push("--save-dev");
-      break;
-    case "peer":
-      command.push("--save-peer");
-      break;
-    case "prod":
-      command.push("--save-prod");
-      break;
-  }
-  return command;
-}
-function argumentsToAddDependenciesWithBun(dependencies, type) {
-  let command = ["add"];
-  command = command.concat(dependencies);
-  switch (type) {
-    case "dev":
-      command.push("--development");
-      break;
-    case "peer":
-      command.push("--optional");
-      break;
-    case "prod":
-      break;
-  }
-  return command;
-}
-async function findUpAndReadPackageJson(fromDirectory) {
-  const packageJsonPath = await findPathUp("package.json", { cwd: fromDirectory, type: "file" });
-  if (packageJsonPath) {
-    const packageJson = JSON.parse(await readFile(packageJsonPath));
-    return { path: packageJsonPath, content: packageJson };
-  } else {
-    throw new FindUpAndReadPackageJsonNotFoundError(fromDirectory);
-  }
-}
-async function addResolutionOrOverride(directory, dependencies) {
-  const packageManager2 = await getPackageManager(directory);
-  const packageJsonPath = joinPath(directory, "package.json");
-  const packageJsonContent = await readAndParsePackageJson(packageJsonPath);
-  if (packageManager2 === "yarn") {
-    packageJsonContent.resolutions = packageJsonContent.resolutions ? { ...packageJsonContent.resolutions, ...dependencies } : dependencies;
-  }
-  if (packageManager2 === "npm" || packageManager2 === "pnpm" || packageManager2 === "bun") {
-    packageJsonContent.overrides = packageJsonContent.overrides ? { ...packageJsonContent.overrides, ...dependencies } : dependencies;
-  }
-  await writeFile(packageJsonPath, JSON.stringify(packageJsonContent, null, 2));
-}
-async function getLatestNPMPackageVersion(name) {
-  outputDebug(outputContent`Getting the latest version of NPM package: ${outputToken.raw(name)}`);
-  return runWithTimer("cmd_all_timing_network_ms")(() => {
-    return latestVersion(name);
-  });
-}
-async function writePackageJSON(directory, packageJSON) {
-  outputDebug(outputContent`JSON-encoding and writing content to package.json at ${outputToken.path(directory)}...`);
-  const packagePath = joinPath(directory, "package.json");
-  await writeFile(packagePath, JSON.stringify(packageJSON, null, 2));
-}
-
-export {
-  LocalStorage,
-  getSession,
-  setSession,
-  removeSession,
-  cacheRetrieveOrRepopulate,
-  yarnLockfile,
-  npmLockfile,
-  pnpmLockfile,
-  bunLockfile,
-  pnpmWorkspaceFile,
-  lockfiles,
-  packageManager,
-  UnknownPackageManagerError,
-  PackageJsonNotFoundError,
-  FindUpAndReadPackageJsonNotFoundError,
-  packageManagerFromUserAgent,
-  getPackageManager,
-  installNPMDependenciesRecursively,
-  installNodeModules,
-  getPackageName,
-  getPackageVersion,
-  getDependencies,
-  usesWorkspaces,
-  checkForNewVersion,
-  versionSatisfies,
-  readAndParsePackageJson,
-  addNPMDependenciesIfNeeded,
-  addNPMDependencies,
-  addNPMDependenciesWithoutVersionIfNeeded,
-  findUpAndReadPackageJson,
-  addResolutionOrOverride,
-  writePackageJSON,
-  node_package_manager_exports
-};
-//# sourceMappingURL=chunk-NBSFQYKI.js.map