// src/lib/checkResult.ts
import chalk from "chalk";
var checkResult = (name, result, level = "error", exitOnFail = false) => {
  if (result) {
    const exiting = exitOnFail ? "[Exiting Process]" : "[Continuing]";
    const chalkFunc = level === "error" ? chalk.red : chalk.yellow;
    console[level](chalkFunc(`${name} had ${result} failures ${exiting}`));
    if (exitOnFail) {
      process.exit(result);
    }
  }
};

// src/lib/concurrency.ts
import { AsyncLocalStorage } from "async_hooks";
var outputStorage = new AsyncLocalStorage();
async function runWithConcurrency(items, concurrency, fn) {
  let next = 0;
  async function worker() {
    while (next < items.length) {
      const i = next++;
      await fn(items[i]);
    }
  }
  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
}

// src/lib/packageManagerRuntime.ts
import { spawnSync } from "child_process";
import fs from "fs";
import chalk2 from "chalk";
var DISPLAY_NAMES = {
  bun: "Bun",
  npm: "npm",
  pnpm: "pnpm",
  yarn: "Yarn"
};
var MAC_INSTALL_COMMANDS = {
  bun: "brew install oven-sh/bun/bun",
  npm: "brew install node",
  pnpm: "brew install pnpm",
  yarn: "brew install yarn"
};
function currentPlatform() {
  if (process.platform === "darwin" || process.platform === "linux" || process.platform === "win32") {
    return process.platform;
  }
  return "unknown";
}
function askYesNo(question) {
  if (!process.stdin.isTTY || !process.stdout.isTTY) {
    return false;
  }
  process.stdout.write(question);
  const buffer = Buffer.alloc(1024);
  const bytesRead = fs.readSync(process.stdin.fd, buffer, 0, buffer.length, null);
  const answer = buffer.toString("utf8", 0, bytesRead).trim().toLowerCase();
  return answer === "y" || answer === "yes";
}
function isCommandInstalled(command) {
  const result = spawnSync(command, ["--version"], {
    encoding: "utf8",
    shell: false,
    stdio: "ignore"
  });
  return !result.error && result.status === 0;
}
function isPackageManagerInstalled(pm) {
  return isCommandInstalled(pm);
}
function getPackageManagerInstallPlan(pm, platform = currentPlatform()) {
  const displayName = DISPLAY_NAMES[pm];
  if (platform === "darwin") {
    const command = MAC_INSTALL_COMMANDS[pm];
    return {
      command,
      manualInstructions: [
        `Install ${displayName} with: ${command}`
      ],
      packageManager: pm,
      platform,
      supported: true
    };
  }
  if (platform === "linux") {
    return {
      manualInstructions: [
        `Automatic installation for ${displayName} is not implemented on Linux yet.`,
        `Install ${displayName} manually and re-run the command.`
      ],
      packageManager: pm,
      platform,
      supported: false
    };
  }
  if (platform === "win32") {
    return {
      manualInstructions: [
        `Automatic installation for ${displayName} is not implemented on Windows yet.`,
        `Install ${displayName} manually and re-run the command.`
      ],
      packageManager: pm,
      platform,
      supported: false
    };
  }
  return {
    manualInstructions: [
      `Automatic installation for ${displayName} is not implemented on ${platform} yet.`,
      `Install ${displayName} manually and re-run the command.`
    ],
    packageManager: pm,
    platform,
    supported: false
  };
}
function printManualInstructions(plan, context) {
  console.error(chalk2.yellow(`${DISPLAY_NAMES[plan.packageManager]} is required for "${context.operation}".`));
  for (const line of plan.manualInstructions) {
    console.error(chalk2.gray(`  ${line}`));
  }
}
function installWithHomebrew(pm, cwd) {
  const command = MAC_INSTALL_COMMANDS[pm];
  const result = spawnSync("brew", command.replace("brew ", "").split(" "), {
    cwd,
    encoding: "utf8",
    shell: false,
    stdio: "inherit"
  });
  return result.status === 0;
}
function ensurePackageManagerInstalled(pm, context) {
  if (isPackageManagerInstalled(pm)) return true;
  const plan = getPackageManagerInstallPlan(pm, context.platform ?? currentPlatform());
  const displayName = DISPLAY_NAMES[pm];
  console.error(chalk2.yellow(`${context.operation} requires ${displayName}, but it is not installed.`));
  if (!plan.supported) {
    printManualInstructions(plan, context);
    return false;
  }
  if (!isCommandInstalled("brew")) {
    console.error(chalk2.yellow("Homebrew is not installed, so automatic installation is unavailable."));
    console.error(chalk2.gray("  Install Homebrew from https://brew.sh and then run:"));
    console.error(chalk2.gray(`  ${plan.command}`));
    return false;
  }
  const confirmed = askYesNo(chalk2.cyan(`Install ${displayName} with Homebrew now? [y/N] `));
  if (!confirmed) {
    console.error(chalk2.gray(`Skipping install. Run "${plan.command}" manually and then retry.`));
    return false;
  }
  console.error(chalk2.cyan(`Installing ${displayName} via Homebrew...
`));
  if (!installWithHomebrew(pm, context.cwd)) {
    console.error(chalk2.red(`Homebrew failed to install ${displayName}.`));
    console.error(chalk2.gray(`Run "${plan.command}" manually and then retry.`));
    return false;
  }
  if (!isPackageManagerInstalled(pm)) {
    console.error(chalk2.red(`${displayName} still does not appear to be installed after Homebrew completed.`));
    console.error(chalk2.gray(`Run "${plan.command}" manually and then retry.`));
    return false;
  }
  console.error(chalk2.green(`${displayName} installed successfully.`));
  return true;
}

// src/pm/workspaces.ts
import { existsSync, readFileSync } from "fs";
import PATH from "path";
import { globSync } from "glob";
function readJsonFile(path2) {
  if (!existsSync(path2)) return void 0;
  try {
    return JSON.parse(readFileSync(path2, "utf8"));
  } catch {
    return void 0;
  }
}
function readRootPackageJson(cwd = process.cwd()) {
  return readJsonFile(PATH.resolve(cwd, "package.json"));
}
function detectPackageManagerFromPackageJson(cwd = process.cwd()) {
  const packageManager = readRootPackageJson(cwd)?.packageManager;
  if (!packageManager) return void 0;
  return packageManager.split("@")[0];
}

// src/pm/detectPackageManager.ts
import { existsSync as existsSync2 } from "fs";
var knownPackageManagers = /* @__PURE__ */ new Set(["bun", "npm", "pnpm", "yarn"]);
function detectPackageManager() {
  const packageManager = detectPackageManagerFromPackageJson();
  if (packageManager && knownPackageManagers.has(packageManager)) {
    return packageManager;
  }
  if (existsSync2("pnpm-lock.yaml") || existsSync2("pnpm-workspace.yaml")) return "pnpm";
  if (existsSync2("bun.lock") || existsSync2("bun.lockb")) return "bun";
  if (existsSync2("yarn.lock") || existsSync2(".yarnrc.yml")) return "yarn";
  if (existsSync2("package-lock.json") || existsSync2("npm-shrinkwrap.json")) return "npm";
  return "yarn";
}

// src/pm/registry.ts
var implementations = /* @__PURE__ */ new Map();
function getPackageManager(name) {
  const pmName = name ?? detectPackageManager();
  const pm = implementations.get(pmName);
  if (!pm) {
    throw new Error(
      `No package manager implementation registered for "${pmName}". Ensure registerPackageManager() has been called before getPackageManager().`
    );
  }
  return pm;
}

// src/lib/processEx.ts
import chalk3 from "chalk";

// src/lib/withError.ts
var withError = (ex, closure, predicate = (ex2) => !!ex2.name && !!ex2.message) => {
  return predicate(ex) ? closure(ex) : void 0;
};

// src/lib/withErrnoException.ts
var withErrnoException = (ex, closure) => {
  return withError(ex, closure, (ex2) => ex2.errno !== void 0);
};

// src/lib/processEx.ts
var processEx = (ex) => {
  const error = typeof ex === "string" ? new Error(ex) : ex;
  const exitCode = withErrnoException(error, (error2) => {
    if (error2.code === "ENOENT") {
      console.error(chalk3.red(`'${error2.path}' not found.`));
    } else {
      console.error(chalk3.red(`Errno: ${error2.code}`));
    }
    return error2.errno ?? -1;
  }) ?? withError(error, (error2) => {
    console.error(chalk3.red(`${error2.name}: ${error2.message}`));
    return -1;
  }) ?? (() => {
    console.error(chalk3.red(`Unexpected Error: ${JSON.stringify(ex, null, 2)}`));
    return -1;
  })();
  process.exit(process.exitCode ?? exitCode);
};

// src/lib/safeExit.ts
var safeExit = (func, exitOnFail = true) => {
  try {
    const result = func();
    if (result && exitOnFail) {
      process.exit(result);
    }
    return result;
  } catch (ex) {
    return processEx(ex);
  }
};

// src/lib/initCwd.ts
function INIT_CWD() {
  return process.env.INIT_CWD ?? process.cwd();
}

// src/lib/packageName.ts
import { readFileSync as readFileSync2 } from "fs";
import path from "path";
function packageName() {
  if (process.env.npm_package_name) {
    return process.env.npm_package_name;
  }
  try {
    const pkgPath = path.join(INIT_CWD(), "package.json");
    const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
    return pkg.name;
  } catch {
    return void 0;
  }
}

// src/lib/runSteps.ts
import { spawnSync as spawnSync2 } from "child_process";
import { existsSync as existsSync3 } from "fs";
import chalk4 from "chalk";
var packageManagers = /* @__PURE__ */ new Set(["bun", "npm", "pnpm", "yarn"]);
var runSteps = (name, steps, exitOnFail = true, messages) => {
  return safeExit(() => {
    const pkgName = packageName();
    console.log(chalk4.green(`${name} [${pkgName}]`));
    let totalStatus = 0;
    for (const [i, [command, args, config]] of steps.entries()) {
      if (messages?.[i]) {
        console.log(chalk4.gray(messages?.[i]));
      }
      const argList = Array.isArray(args) ? args : args.split(" ");
      if (command === "node" && !existsSync3(argList[0])) {
        throw new Error(`File not found [${argList[0]}]`);
      }
      if (packageManagers.has(command) && !ensurePackageManagerInstalled(command, { operation: `${name}: ${command} ${Array.isArray(args) ? args.join(" ") : args}`.trim() })) {
        checkResult(name, 1, "error", exitOnFail);
        totalStatus += 1;
        continue;
      }
      const status = spawnSync2(command, Array.isArray(args) ? args : args.split(" "), {
        ...config,
        encoding: "utf8",
        env: { FORCE_COLOR: "3", ...process.env },
        shell: true,
        stdio: "inherit"
      }).status ?? 0;
      checkResult(name, status, "error", exitOnFail);
      totalStatus += status ?? 0;
    }
    return totalStatus;
  }, !!exitOnFail);
};

// src/lib/updo/applyUpdates.ts
import { readFileSync as readFileSync3, writeFileSync } from "fs";
import PATH2 from "path";
import chalk5 from "chalk";
function applyUpdates(cwd, workspaces, updates) {
  const updateMap = new Map(updates.map((u) => [u.name, u]));
  let modified = 0;
  for (const ws of workspaces) {
    const pkgPath = PATH2.resolve(cwd, ws.location, "package.json");
    let content;
    try {
      content = readFileSync3(pkgPath, "utf8");
    } catch {
      continue;
    }
    const pkg = JSON.parse(content);
    let changed = false;
    for (const depField of ["dependencies", "devDependencies", "peerDependencies"]) {
      const deps = pkg[depField];
      if (!deps) continue;
      for (const [name, currentRange] of Object.entries(deps)) {
        const update = updateMap.get(name);
        if (!update) continue;
        const prefix = /^([~^]|>=?|<=?)/.exec(currentRange)?.[0] ?? "~";
        const newRange = `${prefix}${update.targetVersion}`;
        if (deps[name] !== newRange) {
          deps[name] = newRange;
          changed = true;
        }
      }
    }
    if (changed) {
      writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
`);
      modified++;
      console.log(chalk5.gray(`  Updated ${ws.name}`));
    }
  }
  return modified;
}

// src/lib/updo/collectWorkspaceDeps.ts
import { readFileSync as readFileSync4 } from "fs";
import PATH3 from "path";
var DEP_FIELDS = ["dependencies", "devDependencies", "peerDependencies"];
function collectWorkspaceDeps(cwd, workspaces, workspaceNames) {
  const depMap = /* @__PURE__ */ new Map();
  for (const ws of workspaces) {
    const pkgPath = PATH3.resolve(cwd, ws.location, "package.json");
    let pkg;
    try {
      pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
    } catch {
      continue;
    }
    for (const depField of DEP_FIELDS) {
      const deps = pkg[depField];
      if (!deps) continue;
      for (const [name, range] of Object.entries(deps)) {
        if (workspaceNames.has(name)) continue;
        if (range.startsWith("workspace:")) continue;
        const existing = depMap.get(name);
        if (existing) {
          if (!existing.workspaces.includes(ws.name)) {
            existing.workspaces.push(ws.name);
          }
          if (!existing.depTypes.includes(depField)) {
            existing.depTypes.push(depField);
          }
          if (!existing.ranges.includes(range)) {
            existing.ranges.push(range);
          }
        } else {
          depMap.set(name, {
            depTypes: [depField],
            name,
            ranges: [range],
            workspaces: [ws.name]
          });
        }
      }
    }
  }
  return depMap;
}

// src/lib/updo/fetchRegistryInfo.ts
var REGISTRY_BASE = "https://registry.npmjs.org";
async function fetchRegistryInfo(packageName2) {
  try {
    const url = `${REGISTRY_BASE}/${encodeURIComponent(packageName2)}`;
    const res = await fetch(url, { headers: { Accept: "application/vnd.npm.install-v1+json" } });
    if (!res.ok) {
      return { distTags: {}, versions: [] };
    }
    const data = await res.json();
    return {
      distTags: data["dist-tags"] ?? {},
      versions: Object.keys(data.versions ?? {})
    };
  } catch {
    return { distTags: {}, versions: [] };
  }
}
async function fetchAllRegistryInfo(packageNames, concurrency = 16) {
  const results = /* @__PURE__ */ new Map();
  let completed = 0;
  const total = packageNames.length;
  await runWithConcurrency(packageNames, concurrency, async (name) => {
    results.set(name, await fetchRegistryInfo(name));
    completed++;
    if (completed % 25 === 0 || completed === total) {
      process.stderr.write(`\r  Fetched ${completed}/${total} packages...`);
    }
  });
  if (total > 0) {
    process.stderr.write("\n");
  }
  return results;
}

// src/lib/updo/interactiveSelect.ts
import {
  createPrompt,
  ExitPromptError,
  isDownKey,
  isEnterKey,
  isSpaceKey,
  isUpKey,
  useKeypress,
  useRef,
  useState
} from "@inquirer/core";
import chalk6 from "chalk";
import semver from "semver";
function versionColor(version, current) {
  if (!version || !current) return chalk6.gray;
  if (version === current) return chalk6.gray;
  const diff = semver.diff(current, version);
  if (diff === "major" || diff === "premajor") return chalk6.red;
  if (diff === "minor" || diff === "preminor") return chalk6.yellow;
  return chalk6.green;
}
function pad(raw, colored, width) {
  return colored + " ".repeat(Math.max(0, width - raw.length));
}
function dot(selected) {
  return selected ? chalk6.green("\u25CF") : chalk6.dim("\u25CB");
}
function renderHeader(w) {
  const header = [
    "  ",
    chalk6.bold("Package".padEnd(w.name)),
    chalk6.bold("Current".padEnd(w.current)),
    chalk6.bold("  Wanted".padEnd(w.wanted + 2)),
    chalk6.bold("  Latest".padEnd(w.latest + 2)),
    chalk6.bold("  Next/RC".padEnd(w.next + 2))
  ].join("  ");
  const totalWidth = w.name + w.current + w.wanted + w.latest + w.next + 24;
  return `${header}
${chalk6.gray("\u2500".repeat(totalWidth))}`;
}
function renderRow(dep, selection, active, w) {
  const pointer = active ? chalk6.cyan("\u276F") : " ";
  const rawName = dep.name;
  const name = active ? chalk6.white(rawName) : chalk6.gray(rawName);
  const rawCurrent = dep.current ?? "-";
  const current = chalk6.gray(rawCurrent);
  const rawWanted = dep.wanted ?? "-";
  const wantedColorFn = dep.wanted ? versionColor(dep.wanted, dep.current) : chalk6.gray;
  const wantedDot = dep.wanted ? dot(selection === 0) : " ";
  const wanted = `${wantedDot} ${pad(rawWanted, wantedColorFn(rawWanted), w.wanted)}`;
  const rawLatest = dep.latest ?? "-";
  const latestColorFn = dep.latest ? versionColor(dep.latest, dep.current) : chalk6.gray;
  const latestDot = dep.latest ? dot(selection === 1) : " ";
  const latest = `${latestDot} ${pad(rawLatest, latestColorFn(rawLatest), w.latest)}`;
  const rawNext = dep.next ?? "-";
  const nextColorFn = dep.next ? versionColor(dep.next, dep.current) : chalk6.gray;
  const nextDot = dep.next ? dot(selection === 2) : " ";
  const next = `${nextDot} ${pad(rawNext, nextColorFn(rawNext), w.next)}`;
  return `${pointer} ${pad(rawName, name, w.name)}  ${pad(rawCurrent, current, w.current)}  ${wanted}  ${latest}  ${next}`;
}
function getAvailableSelections(dep) {
  const available = [-1];
  if (dep.wanted) available.push(0);
  if (dep.latest && dep.latest !== dep.wanted) available.push(1);
  if (dep.next) available.push(2);
  return available;
}
function getTargetVersion(dep, selection) {
  if (selection === 0) return dep.wanted;
  if (selection === 1) return dep.latest;
  if (selection === 2) return dep.next;
  return void 0;
}
function computeWidths(rows) {
  let name = 7;
  let current = 7;
  let wanted = 6;
  let latest = 6;
  let next = 7;
  for (const dep of rows) {
    name = Math.max(name, dep.name.length);
    current = Math.max(current, (dep.current ?? "-").length);
    wanted = Math.max(wanted, (dep.wanted ?? "-").length);
    latest = Math.max(latest, (dep.latest ?? "-").length);
    next = Math.max(next, (dep.next ?? "-").length);
  }
  return {
    current,
    latest,
    name,
    next,
    wanted
  };
}
function renderPage(rows, cursor, selections, w, pageSize) {
  const total = rows.length;
  let start = 0;
  if (total > pageSize) {
    start = Math.max(0, Math.min(cursor - Math.floor(pageSize / 2), total - pageSize));
  }
  const end = Math.min(start + pageSize, total);
  const lines = [];
  for (let i = start; i < end; i++) {
    lines.push(renderRow(rows[i], selections[i], i === cursor, w));
  }
  if (total > pageSize) {
    if (start > 0) lines.unshift(chalk6.dim("  \u2191 more"));
    if (end < total) lines.push(chalk6.dim("  \u2193 more"));
  }
  return lines.join("\n");
}
var updoPrompt = createPrompt((config, done) => {
  const { rows } = config;
  const [cursor, setCursor] = useState(0);
  const [tick, setTick] = useState(0);
  const availableSelections = useRef(rows.map((r) => getAvailableSelections(r)));
  const selections = useRef(rows.map(() => -1));
  const widths = useRef(computeWidths(rows));
  useKeypress((key) => {
    if (key.name === "escape" || key.ctrl && key.name === "c") {
      done([]);
      return;
    }
    if (isEnterKey(key)) {
      const results = [];
      for (const [i, dep] of rows.entries()) {
        const version = getTargetVersion(dep, selections.current[i]);
        if (version) {
          results.push({
            depTypes: dep.depTypes,
            name: dep.name,
            targetVersion: version,
            workspaces: dep.workspaces
          });
        }
      }
      done(results);
      return;
    }
    if (isUpKey(key)) {
      setCursor(Math.max(0, cursor - 1));
    } else if (isDownKey(key)) {
      setCursor(Math.min(rows.length - 1, cursor + 1));
    } else if (isSpaceKey(key)) {
      const available = availableSelections.current[cursor];
      const currentSel = selections.current[cursor];
      const currentIdx = available.indexOf(currentSel);
      const nextIdx = (currentIdx + 1) % available.length;
      selections.current[cursor] = available[nextIdx];
      setTick(tick + 1);
    }
  });
  const w = widths.current;
  const header = renderHeader(w);
  const page = renderPage(rows, cursor, selections.current, w, 20);
  const selectedCount = selections.current.filter((s) => s >= 0).length;
  const status = chalk6.gray(`  ${selectedCount} selected  \u2191/\u2193 navigate  space cycle version  enter confirm`);
  return `${header}
${page}
${status}`;
});
async function interactiveSelect(deps) {
  const updatable = deps.filter((d) => d.updateAvailable);
  if (updatable.length === 0) {
    console.log(chalk6.green("\nAll packages are up to date!"));
    return [];
  }
  if (!process.stdout.isTTY) {
    console.log(chalk6.yellow("Non-interactive environment detected, skipping selection."));
    return [];
  }
  try {
    return await updoPrompt({ rows: updatable });
  } catch (error) {
    if (error instanceof ExitPromptError) {
      return [];
    }
    throw error;
  }
}

// src/lib/updo/resolveVersions.ts
import semver2 from "semver";
function computeWanted(info, ranges) {
  const candidates = ranges.map((range) => semver2.maxSatisfying(info.versions, range));
  const valid = candidates.filter((v) => v !== null);
  if (valid.length === 0) return void 0;
  let min = valid[0];
  for (const v of valid) {
    if (semver2.lt(v, min)) min = v;
  }
  return min;
}
function hasNewerVersion(version, current) {
  return version !== void 0 && semver2.gt(version, current);
}
function isUpdateAvailable(current, wanted, latest, next) {
  if (!current) return false;
  return hasNewerVersion(wanted, current) || hasNewerVersion(latest, current) || hasNewerVersion(next, current);
}
function resolveVersions(deps, registry, installedVersions) {
  const resolved = [];
  for (const [name, dep] of deps) {
    const info = registry.get(name);
    const current = installedVersions.get(name);
    const wanted = info ? computeWanted(info, dep.ranges) : void 0;
    const latest = info?.distTags.latest;
    const rawNext = info?.distTags.next ?? info?.distTags.rc;
    const next = rawNext && latest && semver2.gt(rawNext, latest) ? rawNext : void 0;
    const updateAvailable = isUpdateAvailable(current, wanted, latest, next);
    resolved.push({
      current,
      declaredRange: dep.ranges.length === 1 ? dep.ranges[0] : dep.ranges.join(" | "),
      depTypes: dep.depTypes,
      latest,
      name,
      next,
      updateAvailable,
      wanted: wanted && current && wanted !== current ? wanted : void 0,
      workspaces: dep.workspaces
    });
  }
  return resolved.toSorted((a, b) => {
    if (a.updateAvailable !== b.updateAvailable) return a.updateAvailable ? -1 : 1;
    return a.name.localeCompare(b.name);
  });
}

// src/lib/updo/runUpdo.ts
import chalk7 from "chalk";
async function runUpdo(pm, _options = {}) {
  const cwd = INIT_CWD();
  const workspaces = pm.listWorkspaces();
  const workspaceNames = new Set(workspaces.map((ws) => ws.name));
  console.log(chalk7.gray("Scanning workspace dependencies..."));
  const declaredDeps = collectWorkspaceDeps(cwd, workspaces, workspaceNames);
  console.log(chalk7.gray(`  Found ${declaredDeps.size} unique dependencies across ${workspaces.length} workspaces`));
  console.log(chalk7.gray("Fetching registry info..."));
  const registryInfo = await fetchAllRegistryInfo([...declaredDeps.keys()]);
  console.log(chalk7.gray("Reading installed versions..."));
  const installedVersions = pm.listInstalledVersions();
  const resolved = resolveVersions(declaredDeps, registryInfo, installedVersions);
  const updates = await interactiveSelect(resolved);
  if (updates.length === 0) {
    console.log(chalk7.gray("No updates selected."));
    return 0;
  }
  console.log(chalk7.gray(`
Applying ${updates.length} updates...`));
  const modified = applyUpdates(cwd, workspaces, updates);
  console.log(chalk7.gray(`  Modified ${modified} package.json files`));
  console.log(chalk7.gray("Installing updated dependencies..."));
  return runSteps("Updo", [
    pm.install(),
    pm.dedupe()
  ], true);
}

// src/actions/updo.ts
var updo = async ({ latest = true } = {}) => {
  const pm = getPackageManager();
  return await runUpdo(pm, { latest });
};
export {
  updo
};
//# sourceMappingURL=updo.mjs.map