bumpp 10.0.3 → 10.1.0

package/dist/shared/bumpp.B_9jg8A3.mjs

@@ -1,941 +0,0 @@
-import process$1 from 'node:process';
-import { tokenizeArgs } from 'args-tokenizer';
-import prompts from 'prompts';
-import { execSync } from 'node:child_process';
-import { x } from 'tinyexec';
-import semver, { valid, SemVer, clean } from 'semver';
-import fs, { existsSync } from 'node:fs';
-import * as path from 'node:path';
-import path__default, { dirname } from 'node:path';
-import * as jsonc from 'jsonc-parser';
-import fs$1 from 'node:fs/promises';
-import yaml from 'js-yaml';
-import { glob } from 'tinyglobby';
-import { loadConfig } from 'c12';
-import escalade from 'escalade/sync';
-
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-var picocolors = {exports: {}};
-
-var hasRequiredPicocolors;
-
-function requirePicocolors () {
-	if (hasRequiredPicocolors) return picocolors.exports;
-	hasRequiredPicocolors = 1;
-	let p = process || {}, argv = p.argv || [], env = p.env || {};
-	let isColorSupported =
-		!(!!env.NO_COLOR || argv.includes("--no-color")) &&
-		(!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || ((p.stdout || {}).isTTY && env.TERM !== "dumb") || !!env.CI);
-
-	let formatter = (open, close, replace = open) =>
-		input => {
-			let string = "" + input, index = string.indexOf(close, open.length);
-			return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close
-		};
-
-	let replaceClose = (string, close, replace, index) => {
-		let result = "", cursor = 0;
-		do {
-			result += string.substring(cursor, index) + replace;
-			cursor = index + close.length;
-			index = string.indexOf(close, cursor);
-		} while (~index)
-		return result + string.substring(cursor)
-	};
-
-	let createColors = (enabled = isColorSupported) => {
-		let f = enabled ? formatter : () => String;
-		return {
-			isColorSupported: enabled,
-			reset: f("\x1b[0m", "\x1b[0m"),
-			bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
-			dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
-			italic: f("\x1b[3m", "\x1b[23m"),
-			underline: f("\x1b[4m", "\x1b[24m"),
-			inverse: f("\x1b[7m", "\x1b[27m"),
-			hidden: f("\x1b[8m", "\x1b[28m"),
-			strikethrough: f("\x1b[9m", "\x1b[29m"),
-
-			black: f("\x1b[30m", "\x1b[39m"),
-			red: f("\x1b[31m", "\x1b[39m"),
-			green: f("\x1b[32m", "\x1b[39m"),
-			yellow: f("\x1b[33m", "\x1b[39m"),
-			blue: f("\x1b[34m", "\x1b[39m"),
-			magenta: f("\x1b[35m", "\x1b[39m"),
-			cyan: f("\x1b[36m", "\x1b[39m"),
-			white: f("\x1b[37m", "\x1b[39m"),
-			gray: f("\x1b[90m", "\x1b[39m"),
-
-			bgBlack: f("\x1b[40m", "\x1b[49m"),
-			bgRed: f("\x1b[41m", "\x1b[49m"),
-			bgGreen: f("\x1b[42m", "\x1b[49m"),
-			bgYellow: f("\x1b[43m", "\x1b[49m"),
-			bgBlue: f("\x1b[44m", "\x1b[49m"),
-			bgMagenta: f("\x1b[45m", "\x1b[49m"),
-			bgCyan: f("\x1b[46m", "\x1b[49m"),
-			bgWhite: f("\x1b[47m", "\x1b[49m"),
-
-			blackBright: f("\x1b[90m", "\x1b[39m"),
-			redBright: f("\x1b[91m", "\x1b[39m"),
-			greenBright: f("\x1b[92m", "\x1b[39m"),
-			yellowBright: f("\x1b[93m", "\x1b[39m"),
-			blueBright: f("\x1b[94m", "\x1b[39m"),
-			magentaBright: f("\x1b[95m", "\x1b[39m"),
-			cyanBright: f("\x1b[96m", "\x1b[39m"),
-			whiteBright: f("\x1b[97m", "\x1b[39m"),
-
-			bgBlackBright: f("\x1b[100m", "\x1b[49m"),
-			bgRedBright: f("\x1b[101m", "\x1b[49m"),
-			bgGreenBright: f("\x1b[102m", "\x1b[49m"),
-			bgYellowBright: f("\x1b[103m", "\x1b[49m"),
-			bgBlueBright: f("\x1b[104m", "\x1b[49m"),
-			bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
-			bgCyanBright: f("\x1b[106m", "\x1b[49m"),
-			bgWhiteBright: f("\x1b[107m", "\x1b[49m"),
-		}
-	};
-
-	picocolors.exports = createColors();
-	picocolors.exports.createColors = createColors;
-	return picocolors.exports;
-}
-
-var picocolorsExports = /*@__PURE__*/ requirePicocolors();
-const c = /*@__PURE__*/getDefaultExportFromCjs(picocolorsExports);
-
-function execCommand(cmd, options) {
-  try {
-    return execSync(cmd, { encoding: "utf8", cwd: options?.cwd }).trim();
-  } catch (error) {
-    return "";
-  }
-}
-function getLastGitTag() {
-  return execCommand("git describe --tags --abbrev=0")?.split("\n").at(0) || undefined;
-}
-const GIT_LOG_FORMAT = "%h|%s|%an|%ae|%ad|%b[GIT_LOG_COMMIT_END]";
-function getGitLog(from, to = "HEAD") {
-  return execCommand(`git --no-pager log "${from ? `${from}...${to}` : to}" --pretty="${GIT_LOG_FORMAT}"`).split("[GIT_LOG_COMMIT_END]\n").filter(Boolean);
-}
-
-const ConventionalCommitRegex = /(?<emoji>:.+:|(\uD83C[\uDF00-\uDFFF])|(\uD83D[\uDC00-\uDE4F\uDE80-\uDEFF])|[\u2600-\u2B55])?( *)(?<type>[a-z]+)(\((?<scope>.+)\))?(?<breaking>!)?: (?<description>.+)/i;
-const CoAuthoredByRegex = /co-authored-by:\s*(?<name>.+)(<(?<email>.+)>)/gi;
-const PullRequestRE = /\([ a-z]*(#\d+)\s*\)/g;
-const IssueRE = /(#\d+)/g;
-const BreakingRE = /breaking[ -]changes?:/i;
-function parseRawCommit(commit) {
-  const [shortHash, message, authorName, authorEmail, data, ..._body] = commit.split("|");
-  const body = _body.filter(Boolean).join("\n");
-  return {
-    author: { name: authorName, email: authorEmail },
-    body,
-    data,
-    message,
-    shortHash
-  };
-}
-function parseCommit(rawCommit) {
-  const { shortHash, message, body, data } = rawCommit;
-  const match = message.match(ConventionalCommitRegex);
-  const isConventional = match !== null;
-  const type = match?.groups?.type || "";
-  const scope = match?.groups?.scope || "";
-  let description = match?.groups?.description || message;
-  const hasBreakingBody = BreakingRE.test(body);
-  const isBreaking = Boolean(match?.groups?.breaking || hasBreakingBody);
-  const references = [];
-  for (const m of description.matchAll(PullRequestRE)) {
-    references.push({ type: "pull-request", value: m[1] });
-  }
-  for (const m of description.matchAll(IssueRE)) {
-    if (!references.some((i) => i.value === m[1])) {
-      references.push({ type: "issue", value: m[1] });
-    }
-  }
-  description = description.replace(PullRequestRE, "").trim();
-  const authors = [rawCommit.author];
-  for (const match2 of body.matchAll(CoAuthoredByRegex)) {
-    authors.push({
-      name: (match2.groups?.name || "").trim(),
-      email: (match2.groups?.email || "").trim()
-    });
-  }
-  return {
-    authors,
-    body,
-    data,
-    description,
-    isBreaking,
-    isConventional,
-    message,
-    references,
-    scope,
-    shortHash,
-    type
-  };
-}
-
-function getCommits(from, to) {
-  return getGitLog(from, to).map(parseRawCommit).map(parseCommit);
-}
-function getRecentCommits(from, to) {
-  if (!from)
-    from = getLastGitTag();
-  if (!to)
-    to = "HEAD";
-  return getCommits(from, to);
-}
-
-const symbols = {
-  success: c.green("\u2714"),
-  info: c.blue("\u2139")
-};
-
-async function readJsoncFile(name, cwd) {
-  const file = await readTextFile(name, cwd);
-  const data = jsonc.parse(file.data);
-  const modified = [];
-  return { ...file, data, modified, text: file.data };
-}
-async function writeJsoncFile(file) {
-  let newJSON = file.text;
-  for (const [key, value] of file.modified) {
-    const edit = jsonc.modify(newJSON, key, value, {});
-    newJSON = jsonc.applyEdits(newJSON, edit);
-  }
-  return writeTextFile({ ...file, data: newJSON });
-}
-function readTextFile(name, cwd) {
-  return new Promise((resolve, reject) => {
-    const filePath = path__default.join(cwd, name);
-    fs.readFile(filePath, "utf8", (err, text) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve({
-          path: filePath,
-          data: text
-        });
-      }
-    });
-  });
-}
-function writeTextFile(file) {
-  return new Promise((resolve, reject) => {
-    fs.writeFile(file.path, file.data, (err) => {
-      if (err)
-        reject(err);
-      else
-        resolve();
-    });
-  });
-}
-
-function isManifest(obj) {
-  return obj && typeof obj === "object" && isOptionalString(obj.name) && isOptionalString(obj.version) && isOptionalString(obj.description);
-}
-function isPackageLockManifest(manifest) {
-  return typeof manifest.packages?.[""]?.version === "string";
-}
-function isOptionalString(value) {
-  const type = typeof value;
-  return value === null || type === "undefined" || type === "string";
-}
-
-async function getCurrentVersion(operation) {
-  if (operation.state.currentVersion)
-    return operation;
-  const { cwd, files } = operation.options;
-  const filesToCheck = files.filter((file) => file.endsWith(".json"));
-  if (!filesToCheck.includes("package.json"))
-    filesToCheck.push("package.json");
-  if (!filesToCheck.includes("deno.json"))
-    filesToCheck.push("deno.json");
-  if (!filesToCheck.includes("deno.jsonc"))
-    filesToCheck.push("deno.jsonc");
-  for (const file of filesToCheck) {
-    const version = await readVersion(file, cwd);
-    if (version) {
-      return operation.update({
-        currentVersionSource: file,
-        currentVersion: version
-      });
-    }
-  }
-  throw new Error(
-    `Unable to determine the current version number. Checked ${filesToCheck.join(", ")}.`
-  );
-}
-async function readVersion(file, cwd) {
-  try {
-    const { data: manifest } = await readJsoncFile(file, cwd);
-    if (isManifest(manifest)) {
-      if (valid(manifest.version))
-        return manifest.version;
-    }
-  } catch {
-    return undefined;
-  }
-}
-
-const prereleaseTypes = ["premajor", "preminor", "prepatch", "prerelease"];
-const releaseTypes = prereleaseTypes.concat(["major", "minor", "patch", "next", "conventional"]);
-function isPrerelease(value) {
-  return prereleaseTypes.includes(value);
-}
-function isReleaseType(value) {
-  return releaseTypes.includes(value);
-}
-
-async function getNewVersion(operation, commits) {
-  const { release } = operation.options;
-  const { currentVersion } = operation.state;
-  switch (release.type) {
-    case "prompt":
-      return promptForNewVersion(operation, commits);
-    case "version":
-      return operation.update({
-        newVersion: new SemVer(release.version, true).version
-      });
-    default:
-      return operation.update({
-        release: release.type,
-        newVersion: getNextVersion(currentVersion, release, commits)
-      });
-  }
-}
-function getNextVersion(currentVersion, bump, commits) {
-  const oldSemVer = new SemVer(currentVersion);
-  let type;
-  if (bump.type === "next") {
-    type = oldSemVer.prerelease.length ? "prerelease" : "patch";
-  } else if (bump.type === "conventional") {
-    type = oldSemVer.prerelease.length ? "prerelease" : determineSemverChange(commits);
-  } else {
-    type = bump.type;
-  }
-  const newSemVer = oldSemVer.inc(type, bump.preid);
-  if (isPrerelease(bump.type) && newSemVer.prerelease.length === 2 && newSemVer.prerelease[0] === bump.preid && String(newSemVer.prerelease[1]) === "0") {
-    newSemVer.prerelease[1] = "1";
-    newSemVer.format();
-  }
-  return newSemVer.version;
-}
-function determineSemverChange(commits) {
-  let [hasMajor, hasMinor] = [false, false];
-  for (const commit of commits) {
-    if (commit.isBreaking) {
-      hasMajor = true;
-    } else if (commit.type === "feat") {
-      hasMinor = true;
-    }
-  }
-  return hasMajor ? "major" : hasMinor ? "minor" : "patch";
-}
-function getNextVersions(currentVersion, preid, commits) {
-  const next = {};
-  const parse = semver.parse(currentVersion);
-  if (typeof parse?.prerelease[0] === "string")
-    preid = parse?.prerelease[0] || "preid";
-  for (const type of releaseTypes)
-    next[type] = getNextVersion(currentVersion, { type, preid }, commits);
-  return next;
-}
-async function promptForNewVersion(operation, commits) {
-  const { currentVersion } = operation.state;
-  const release = operation.options.release;
-  const next = getNextVersions(currentVersion, release.preid, commits);
-  const configCustomVersion = await operation.options.customVersion?.(currentVersion, semver);
-  const PADDING = 13;
-  const answers = await prompts([
-    {
-      type: "autocomplete",
-      name: "release",
-      message: `Current version ${c.green(currentVersion)}`,
-      initial: configCustomVersion ? "config" : "next",
-      choices: [
-        { value: "major", title: `${"major".padStart(PADDING, " ")} ${c.bold(next.major)}` },
-        { value: "minor", title: `${"minor".padStart(PADDING, " ")} ${c.bold(next.minor)}` },
-        { value: "patch", title: `${"patch".padStart(PADDING, " ")} ${c.bold(next.patch)}` },
-        { value: "next", title: `${"next".padStart(PADDING, " ")} ${c.bold(next.next)}` },
-        { value: "conventional", title: `${"conventional".padStart(PADDING, " ")} ${c.bold(next.conventional)}` },
-        ...configCustomVersion ? [
-          { value: "config", title: `${"from config".padStart(PADDING, " ")} ${c.bold(configCustomVersion)}` }
-        ] : [],
-        { value: "prepatch", title: `${"pre-patch".padStart(PADDING, " ")} ${c.bold(next.prepatch)}` },
-        { value: "preminor", title: `${"pre-minor".padStart(PADDING, " ")} ${c.bold(next.preminor)}` },
-        { value: "premajor", title: `${"pre-major".padStart(PADDING, " ")} ${c.bold(next.premajor)}` },
-        { value: "none", title: `${"as-is".padStart(PADDING, " ")} ${c.bold(currentVersion)}` },
-        { value: "custom", title: "custom ...".padStart(PADDING + 4, " ") }
-      ]
-    },
-    {
-      type: (prev) => prev === "custom" ? "text" : null,
-      name: "custom",
-      message: "Enter the new version number:",
-      initial: currentVersion,
-      validate: (custom) => {
-        return valid(custom) ? true : "That's not a valid version number";
-      }
-    }
-  ]);
-  const newVersion = answers.release === "none" ? currentVersion : answers.release === "custom" ? clean(answers.custom) : answers.release === "config" ? clean(configCustomVersion) : next[answers.release];
-  if (!newVersion)
-    process$1.exit(1);
-  switch (answers.release) {
-    case "custom":
-    case "config":
-    case "next":
-    case "conventional":
-    case "none":
-      return operation.update({ newVersion });
-    default:
-      return operation.update({ release: answers.release, newVersion });
-  }
-}
-
-var ProgressEvent = /* @__PURE__ */ ((ProgressEvent2) => {
-  ProgressEvent2["FileUpdated"] = "file updated";
-  ProgressEvent2["FileSkipped"] = "file skipped";
-  ProgressEvent2["GitCommit"] = "git commit";
-  ProgressEvent2["GitTag"] = "git tag";
-  ProgressEvent2["GitPush"] = "git push";
-  ProgressEvent2["NpmScript"] = "npm script";
-  return ProgressEvent2;
-})(ProgressEvent || {});
-var NpmScript = /* @__PURE__ */ ((NpmScript2) => {
-  NpmScript2["PreVersion"] = "preversion";
-  NpmScript2["Version"] = "version";
-  NpmScript2["PostVersion"] = "postversion";
-  return NpmScript2;
-})(NpmScript || {});
-
-async function gitCommit(operation) {
-  if (!operation.options.commit)
-    return operation;
-  const { all, noVerify, message } = operation.options.commit;
-  const { updatedFiles, newVersion } = operation.state;
-  let args = ["--allow-empty"];
-  if (all) {
-    args.push("--all");
-  }
-  if (noVerify) {
-    args.push("--no-verify");
-  }
-  if (operation.options.sign) {
-    args.push("--gpg-sign");
-  }
-  const commitMessage = formatVersionString(message, newVersion);
-  args.push("--message", commitMessage);
-  if (!all)
-    args = args.concat(updatedFiles);
-  await x("git", ["commit", ...args], { throwOnError: true });
-  return operation.update({ event: ProgressEvent.GitCommit, commitMessage });
-}
-async function gitTag(operation) {
-  if (!operation.options.tag)
-    return operation;
-  const { commit, tag } = operation.options;
-  const { newVersion } = operation.state;
-  const args = [
-    // Create an annotated tag, which is recommended for releases.
-    // See https://git-scm.com/docs/git-tag
-    "--annotate",
-    // Use the same commit message for the tag
-    "--message",
-    formatVersionString(commit.message, newVersion)
-  ];
-  const tagName = formatVersionString(tag.name, newVersion);
-  args.push(tagName);
-  if (operation.options.sign) {
-    args.push("--sign");
-  }
-  await x("git", ["tag", ...args], { throwOnError: true });
-  return operation.update({ event: ProgressEvent.GitTag, tagName });
-}
-async function gitPush(operation) {
-  if (!operation.options.push)
-    return operation;
-  await x("git", ["push"], { throwOnError: true });
-  if (operation.options.tag) {
-    await x("git", ["push", "--tags"], { throwOnError: true });
-  }
-  return operation.update({ event: ProgressEvent.GitPush });
-}
-function formatVersionString(template, newVersion) {
-  if (template.includes("%s"))
-    return template.replace(/%s/g, newVersion);
-  else
-    return template + newVersion;
-}
-
-async function normalizeOptions(raw) {
-  const preid = typeof raw.preid === "string" ? raw.preid : "beta";
-  const sign = Boolean(raw.sign);
-  const push = Boolean(raw.push);
-  const all = Boolean(raw.all);
-  const install = Boolean(raw.install);
-  const noVerify = Boolean(raw.noVerify);
-  const cwd = raw.cwd || process$1.cwd();
-  const ignoreScripts = Boolean(raw.ignoreScripts);
-  const execute = raw.execute;
-  const recursive = Boolean(raw.recursive);
-  let release;
-  if (!raw.release || raw.release === "prompt")
-    release = { type: "prompt", preid };
-  else if (isReleaseType(raw.release) || raw.release === "next")
-    release = { type: raw.release, preid };
-  else
-    release = { type: "version", version: raw.release };
-  let tag;
-  if (typeof raw.tag === "string")
-    tag = { name: raw.tag };
-  else if (raw.tag)
-    tag = { name: "v" };
-  let commit;
-  if (typeof raw.commit === "string")
-    commit = { all, noVerify, message: raw.commit };
-  else if (raw.commit || tag || push)
-    commit = { all, noVerify, message: "chore: release v" };
-  if (recursive && !raw.files?.length) {
-    raw.files = [
-      "package.json",
-      "package-lock.json",
-      "packages/**/package.json",
-      "jsr.json",
-      "jsr.jsonc",
-      "deno.json",
-      "deno.jsonc"
-    ];
-    if (fs.existsSync("pnpm-workspace.yaml")) {
-      const pnpmWorkspace = await fs$1.readFile("pnpm-workspace.yaml", "utf8");
-      const workspaces = yaml.load(pnpmWorkspace);
-      const workspacesWithPackageJson = workspaces.packages.map((workspace) => `${workspace}/package.json`);
-      const withoutExcludedWorkspaces = workspacesWithPackageJson.filter((workspace) => !workspace.startsWith("!") && !raw.files?.includes(workspace));
-      raw.files = raw.files.concat(withoutExcludedWorkspaces);
-    }
-  } else {
-    raw.files = raw.files?.length ? raw.files : ["package.json", "package-lock.json", "jsr.json", "jsr.jsonc", "deno.json", "deno.jsonc"];
-  }
-  const files = await glob(
-    raw.files,
-    {
-      cwd,
-      onlyFiles: true,
-      expandDirectories: false,
-      ignore: [
-        "**/{.git,node_modules,bower_components,__tests__,fixtures,fixture}/**"
-      ]
-    }
-  );
-  let ui;
-  if (raw.interface === false) {
-    ui = { input: false, output: false };
-  } else if (raw.interface === true || !raw.interface) {
-    ui = { input: process$1.stdin, output: process$1.stdout };
-  } else {
-    let { input, output, ...other } = raw.interface;
-    if (input === true || input !== false && !input)
-      input = process$1.stdin;
-    if (output === true || output !== false && !output)
-      output = process$1.stdout;
-    ui = { input, output, ...other };
-  }
-  if (release.type === "prompt" && !(ui.input && ui.output))
-    throw new Error("Cannot prompt for the version number because input or output has been disabled.");
-  return {
-    release,
-    commit,
-    tag,
-    sign,
-    push,
-    files,
-    cwd,
-    install,
-    interface: ui,
-    ignoreScripts,
-    execute,
-    printCommits: raw.printCommits ?? true,
-    customVersion: raw.customVersion,
-    currentVersion: raw.currentVersion
-  };
-}
-
-class Operation {
-  /**
-   * The options for this operation.
-   */
-  options;
-  /**
-   * The current state of the operation.
-   */
-  state = {
-    release: undefined,
-    currentVersion: "",
-    currentVersionSource: "",
-    newVersion: "",
-    commitMessage: "",
-    tagName: "",
-    updatedFiles: [],
-    skippedFiles: []
-  };
-  /**
-   * The results of the operation.
-   */
-  get results() {
-    const options = this.options;
-    const state = this.state;
-    return {
-      release: state.release,
-      currentVersion: state.currentVersion,
-      newVersion: state.newVersion,
-      commit: options.commit ? state.commitMessage : false,
-      tag: options.tag ? state.tagName : false,
-      updatedFiles: state.updatedFiles.slice(),
-      skippedFiles: state.skippedFiles.slice()
-    };
-  }
-  /**
-   * The callback that's used to report the progress of the operation.
-   */
-  _progress;
-  /**
-   * Private constructor.  Use the `Operation.start()` static method instead.
-   */
-  constructor(options, progress) {
-    this.options = options;
-    this._progress = progress;
-    if (options.currentVersion) {
-      this.update({
-        currentVersion: options.currentVersion,
-        currentVersionSource: "user"
-      });
-    }
-  }
-  /**
-   * Starts a new `versionBump()` operation.
-   */
-  static async start(input) {
-    const options = await normalizeOptions(input);
-    return new Operation(options, input.progress);
-  }
-  /**
-   * Updates the operation state and results, and reports the updated progress to the user.
-   */
-  update({ event, script, ...newState }) {
-    Object.assign(this.state, newState);
-    if (event && this._progress) {
-      this._progress({ event, script, ...this.results });
-    }
-    return this;
-  }
-}
-
-const messageColorMap = {
-  feat: c.green,
-  feature: c.green,
-  refactor: c.cyan,
-  style: c.cyan,
-  docs: c.blue,
-  doc: c.blue,
-  types: c.blue,
-  type: c.blue,
-  chore: c.gray,
-  ci: c.gray,
-  build: c.gray,
-  deps: c.gray,
-  dev: c.gray,
-  fix: c.yellow,
-  test: c.yellow,
-  perf: c.magenta,
-  revert: c.red,
-  breaking: c.red
-};
-function formatParsedCommits(commits) {
-  const typeLength = commits.map(({ type }) => type.length).reduce((a, b) => Math.max(a, b), 0);
-  const scopeLength = commits.map(({ scope }) => scope.length).reduce((a, b) => Math.max(a, b), 0);
-  return commits.map((commit) => {
-    let color = messageColorMap[commit.type] || ((c2) => c2);
-    if (commit.isBreaking) {
-      color = (s) => c.inverse(c.red(s));
-    }
-    const paddedType = commit.type.padStart(typeLength + 1, " ");
-    const paddedScope = !commit.scope ? " ".repeat(scopeLength ? scopeLength + 2 : 0) : c.dim("(") + commit.scope + c.dim(")") + " ".repeat(scopeLength - commit.scope.length);
-    return [
-      c.dim(commit.shortHash),
-      " ",
-      color === c.gray ? color(paddedType) : c.bold(color(paddedType)),
-      " ",
-      paddedScope,
-      c.dim(":"),
-      " ",
-      color === c.gray ? color(commit.description) : commit.description
-    ].join("");
-  });
-}
-function printRecentCommits(commits) {
-  if (!commits.length) {
-    console.log();
-    console.log(c.blue(`i`) + c.gray(` No commits since the last version`));
-    console.log();
-    return;
-  }
-  const prettified = formatParsedCommits(commits);
-  console.log();
-  console.log(
-    c.bold(
-      `${c.green(commits.length)} Commits since the last version:`
-    )
-  );
-  console.log();
-  console.log(prettified.join("\n"));
-  console.log();
-}
-
-async function runNpmScript(script, operation) {
-  const { cwd, ignoreScripts } = operation.options;
-  if (!ignoreScripts) {
-    const { data: manifest } = await readJsoncFile("package.json", cwd);
-    if (isManifest(manifest) && hasScript(manifest, script)) {
-      await x("npm", ["run", script, "--silent"], {
-        nodeOptions: { stdio: "inherit" }
-      });
-      operation.update({ event: ProgressEvent.NpmScript, script });
-    }
-  }
-  return operation;
-}
-function hasScript(manifest, script) {
-  const scripts = manifest.scripts;
-  if (scripts && typeof scripts === "object")
-    return Boolean(scripts[script]);
-  return false;
-}
-
-async function updateFiles(operation) {
-  const { files } = operation.options;
-  for (const relPath of files) {
-    const modified = await updateFile(relPath, operation);
-    if (modified) {
-      operation.update({
-        event: ProgressEvent.FileUpdated,
-        updatedFiles: operation.state.updatedFiles.concat(relPath)
-      });
-    } else {
-      operation.update({
-        event: ProgressEvent.FileSkipped,
-        skippedFiles: operation.state.skippedFiles.concat(relPath)
-      });
-    }
-  }
-  return operation;
-}
-async function updateFile(relPath, operation) {
-  if (!existsSync(path.join(operation.options.cwd, relPath))) {
-    return false;
-  }
-  const name = path.basename(relPath).trim().toLowerCase();
-  switch (name) {
-    case "package.json":
-    case "package-lock.json":
-    case "bower.json":
-    case "component.json":
-    case "jsr.json":
-    case "jsr.jsonc":
-    case "deno.json":
-    case "deno.jsonc":
-      return updateManifestFile(relPath, operation);
-    default:
-      return updateTextFile(relPath, operation);
-  }
-}
-async function updateManifestFile(relPath, operation) {
-  const { cwd } = operation.options;
-  const { newVersion } = operation.state;
-  let modified = false;
-  const file = await readJsoncFile(relPath, cwd);
-  if (!isManifest(file.data)) {
-    return modified;
-  }
-  if (file.data.version == null) {
-    return modified;
-  }
-  if (file.data.version !== newVersion) {
-    file.modified.push([["version"], newVersion]);
-    if (isPackageLockManifest(file.data))
-      file.modified.push([["packages", "", "version"], newVersion]);
-    await writeJsoncFile(file);
-    modified = true;
-  }
-  return modified;
-}
-async function updateTextFile(relPath, operation) {
-  const { cwd } = operation.options;
-  const { currentVersion, newVersion } = operation.state;
-  const modified = false;
-  const file = await readTextFile(relPath, cwd);
-  if (file.data.includes(currentVersion)) {
-    const sanitizedVersion = currentVersion.replace(/(\W)/g, "\\$1");
-    const replacePattern = new RegExp(`(\\b|v)${sanitizedVersion}\\b`, "g");
-    file.data = file.data.replace(replacePattern, `$1${newVersion}`);
-    await writeTextFile(file);
-    return true;
-  }
-  return modified;
-}
-
-async function versionBump(arg = {}) {
-  if (typeof arg === "string")
-    arg = { release: arg };
-  const operation = await Operation.start(arg);
-  const commits = getRecentCommits();
-  if (operation.options.printCommits) {
-    printRecentCommits(commits);
-  }
-  await getCurrentVersion(operation);
-  await getNewVersion(operation, commits);
-  if (arg.confirm) {
-    printSummary(operation);
-    if (!await prompts({
-      name: "yes",
-      type: "confirm",
-      message: "Bump?",
-      initial: true
-    }).then((r) => r.yes)) {
-      process$1.exit(1);
-    }
-  }
-  await runNpmScript(NpmScript.PreVersion, operation);
-  await updateFiles(operation);
-  if (operation.options.install) {
-    const { detect } = await import('package-manager-detector/detect');
-    const pm = await detect();
-    if (!pm?.name) {
-      throw new Error("Could not detect package manager, failed to run npm install");
-    }
-    const { COMMANDS, constructCommand } = await import('package-manager-detector/commands');
-    const command = constructCommand(COMMANDS[pm.name].install, []);
-    if (!command) {
-      throw new Error("Could not find install command for package manager");
-    }
-    console.log(symbols.info, "Installing dependencies with", `${command.command} ${command.args.join(" ")}`);
-    await x(command.command, command.args, {
-      throwOnError: true,
-      nodeOptions: {
-        stdio: "inherit",
-        cwd: operation.options.cwd
-      }
-    });
-    console.log(symbols.success, "Dependencies installed");
-  }
-  if (operation.options.execute) {
-    if (typeof operation.options.execute === "function") {
-      await operation.options.execute(operation);
-    } else {
-      const [command, ...args] = tokenizeArgs(operation.options.execute);
-      console.log(symbols.info, "Executing script", command, ...args);
-      await x(command, args, {
-        throwOnError: true,
-        nodeOptions: {
-          stdio: "inherit",
-          cwd: operation.options.cwd
-        }
-      });
-      console.log(symbols.success, "Script finished");
-    }
-  }
-  await runNpmScript(NpmScript.Version, operation);
-  await gitCommit(operation);
-  await gitTag(operation);
-  await runNpmScript(NpmScript.PostVersion, operation);
-  await gitPush(operation);
-  return operation.results;
-}
-function printSummary(operation) {
-  console.log();
-  console.log(`   files ${operation.options.files.map((i) => c.bold(i)).join("\n         ")}`);
-  if (operation.options.commit)
-    console.log(`  commit ${c.bold(formatVersionString(operation.options.commit.message, operation.state.newVersion))}`);
-  if (operation.options.tag)
-    console.log(`     tag ${c.bold(formatVersionString(operation.options.tag.name, operation.state.newVersion))}`);
-  if (operation.options.execute)
-    console.log(` execute ${c.bold(typeof operation.options.execute === "function" ? "function" : operation.options.execute)}`);
-  if (operation.options.push)
-    console.log(`    push ${c.cyan(c.bold("yes"))}`);
-  if (operation.options.install)
-    console.log(` install ${c.cyan(c.bold("yes"))}`);
-  console.log();
-  console.log(`    from ${c.bold(operation.state.currentVersion)}`);
-  console.log(`      to ${c.green(c.bold(operation.state.newVersion))}`);
-  console.log();
-}
-async function versionBumpInfo(arg = {}) {
-  if (typeof arg === "string")
-    arg = { release: arg };
-  const operation = await Operation.start(arg);
-  const commits = getRecentCommits();
-  await getCurrentVersion(operation);
-  await getNewVersion(operation, commits);
-  return operation;
-}
-
-const bumpConfigDefaults = {
-  commit: true,
-  push: true,
-  tag: true,
-  sign: false,
-  install: false,
-  recursive: false,
-  noVerify: false,
-  confirm: true,
-  ignoreScripts: false,
-  all: false,
-  noGitCheck: true,
-  files: []
-};
-async function loadBumpConfig(overrides, cwd = process$1.cwd()) {
-  const name = "bump";
-  const configFile = findConfigFile(name, cwd);
-  const { config } = await loadConfig({
-    name,
-    defaults: bumpConfigDefaults,
-    overrides: {
-      ...overrides
-    },
-    cwd: configFile ? dirname(configFile) : cwd
-  });
-  return config;
-}
-function findConfigFile(name, cwd) {
-  let foundRepositoryRoot = false;
-  try {
-    const candidates = ["js", "mjs", "ts", "mts", "json"].map((ext) => `${name}.config.${ext}`);
-    return escalade(cwd, (_dir, files) => {
-      const match = files.find((file) => {
-        if (candidates.includes(file))
-          return true;
-        if (file === ".git")
-          foundRepositoryRoot = true;
-        return false;
-      });
-      if (match)
-        return match;
-      if (foundRepositoryRoot) {
-        throw null;
-      }
-      return false;
-    });
-  } catch (error) {
-    if (foundRepositoryRoot)
-      return null;
-    throw error;
-  }
-}
-function defineConfig(config) {
-  return config;
-}
-
-export { NpmScript as N, ProgressEvent as P, versionBumpInfo as a, bumpConfigDefaults as b, c, defineConfig as d, isReleaseType as i, loadBumpConfig as l, symbols as s, versionBump as v };