bumpp 9.11.1 → 10.0.1

package/dist/{chunk-K27IS2ON.js → shared/bumpp.BiZDmkNc.mjs}

@@ -1,137 +1,19 @@
-import {createRequire as __createRequire} from 'module';var require=__createRequire(import.meta.url);
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
-var require_picocolors = __commonJS({
-  "node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js"(exports, module) {
-    var p = process || {};
-    var argv = p.argv || [];
-    var env = p.env || {};
-    var 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);
-    var 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;
-    };
-    var 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);
-    };
-    var 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")
-      };
-    };
-    module.exports = createColors();
-    module.exports.createColors = createColors;
-  }
-});
+import process$1 from 'node:process';
+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';
 
-// src/types/version-bump-progress.ts
-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 || {});
-
-// src/release-type.ts
-var prereleaseTypes = ["premajor", "preminor", "prepatch", "prerelease"];
-var releaseTypes = prereleaseTypes.concat(["major", "minor", "patch", "next", "conventional"]);
-function isPrerelease(value) {
-  return prereleaseTypes.includes(value);
-}
-function isReleaseType(value) {
-  return releaseTypes.includes(value);
-}
-
-// src/version-bump.ts
-import process5 from "node:process";
-
-// node_modules/.pnpm/args-tokenizer@0.3.0/node_modules/args-tokenizer/dist/args-tokenizer.js
+// src/args-tokenizer.ts
 var spaceRegex = /\s/;
 var tokenizeArgs = (argsString, options) => {
   const tokens = [];
@@ -151,7 +33,7 @@ var tokenizeArgs = (argsString, options) => {
       escaped = true;
       continue;
     }
-    if (openningQuote === void 0 && spaceRegex.test(char)) {
+    if (openningQuote === undefined && spaceRegex.test(char)) {
       if (currentToken.length > 0) {
         tokens.push(currentToken);
         currentToken = "";
@@ -159,12 +41,12 @@ var tokenizeArgs = (argsString, options) => {
       continue;
     }
     if (char === "'" || char === '"') {
-      if (openningQuote === void 0) {
+      if (openningQuote === undefined) {
         openningQuote = char;
         continue;
       }
       if (openningQuote === char) {
-        openningQuote = void 0;
+        openningQuote = undefined;
         continue;
       }
     }
@@ -173,123 +55,192 @@ var tokenizeArgs = (argsString, options) => {
   if (currentToken.length > 0) {
     tokens.push(currentToken);
   }
-  if (options?.loose) {
-    return tokens;
-  }
   if (openningQuote) {
     throw Error("Unexpected end of string. Closing quote is missing.");
   }
   return tokens;
 };
 
-// node_modules/.pnpm/log-symbols@7.0.0/node_modules/log-symbols/symbols.js
-var symbols_exports = {};
-__export(symbols_exports, {
-  error: () => error,
-  info: () => info,
-  success: () => success,
-  warning: () => warning
-});
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
 
-// node_modules/.pnpm/yoctocolors@2.1.1/node_modules/yoctocolors/base.js
-import tty from "node:tty";
-var hasColors = tty?.WriteStream?.prototype?.hasColors?.() ?? false;
-var format = (open, close) => {
-  if (!hasColors) {
-    return (input) => input;
-  }
-  const openCode = `\x1B[${open}m`;
-  const closeCode = `\x1B[${close}m`;
-  return (input) => {
-    const string = input + "";
-    let index = string.indexOf(closeCode);
-    if (index === -1) {
-      return openCode + string + closeCode;
-    }
-    let result = openCode;
-    let lastIndex = 0;
-    while (index !== -1) {
-      result += string.slice(lastIndex, index) + openCode;
-      lastIndex = index + closeCode.length;
-      index = string.indexOf(closeCode, lastIndex);
-    }
-    result += string.slice(lastIndex) + closeCode;
-    return result;
-  };
-};
-var reset = format(0, 0);
-var bold = format(1, 22);
-var dim = format(2, 22);
-var italic = format(3, 23);
-var underline = format(4, 24);
-var overline = format(53, 55);
-var inverse = format(7, 27);
-var hidden = format(8, 28);
-var strikethrough = format(9, 29);
-var black = format(30, 39);
-var red = format(31, 39);
-var green = format(32, 39);
-var yellow = format(33, 39);
-var blue = format(34, 39);
-var magenta = format(35, 39);
-var cyan = format(36, 39);
-var white = format(37, 39);
-var gray = format(90, 39);
-var bgBlack = format(40, 49);
-var bgRed = format(41, 49);
-var bgGreen = format(42, 49);
-var bgYellow = format(43, 49);
-var bgBlue = format(44, 49);
-var bgMagenta = format(45, 49);
-var bgCyan = format(46, 49);
-var bgWhite = format(47, 49);
-var bgGray = format(100, 49);
-var redBright = format(91, 39);
-var greenBright = format(92, 39);
-var yellowBright = format(93, 39);
-var blueBright = format(94, 39);
-var magentaBright = format(95, 39);
-var cyanBright = format(96, 39);
-var whiteBright = format(97, 39);
-var bgRedBright = format(101, 49);
-var bgGreenBright = format(102, 49);
-var bgYellowBright = format(103, 49);
-var bgBlueBright = format(104, 49);
-var bgMagentaBright = format(105, 49);
-var bgCyanBright = format(106, 49);
-var bgWhiteBright = format(107, 49);
+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"),
 
-// node_modules/.pnpm/is-unicode-supported@2.1.0/node_modules/is-unicode-supported/index.js
-import process2 from "node:process";
-function isUnicodeSupported() {
-  const { env } = process2;
-  const { TERM, TERM_PROGRAM } = env;
-  if (process2.platform !== "win32") {
-    return TERM !== "linux";
+			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 "";
   }
-  return Boolean(env.WT_SESSION) || Boolean(env.TERMINUS_SUBLIME) || env.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+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);
 }
 
-// node_modules/.pnpm/log-symbols@7.0.0/node_modules/log-symbols/symbols.js
-var _isUnicodeSupported = isUnicodeSupported();
-var info = blue(_isUnicodeSupported ? "\u2139" : "i");
-var success = green(_isUnicodeSupported ? "\u2714" : "\u221A");
-var warning = yellow(_isUnicodeSupported ? "\u26A0" : "\u203C");
-var error = red(_isUnicodeSupported ? "\u2716\uFE0F" : "\xD7");
+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
+  };
+}
 
-// src/version-bump.ts
-var import_picocolors3 = __toESM(require_picocolors(), 1);
-import prompts2 from "prompts";
-import { getRecentCommits } from "tiny-conventional-commits-parser";
-import { x as x3 } from "tinyexec";
+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);
+}
 
-// src/get-current-version.ts
-import { valid as isValidVersion } from "semver";
+const symbols = {
+  success: c.green("\u2714"),
+  info: c.blue("\u2139")
+};
 
-// src/fs.ts
-import fs from "node:fs";
-import path from "node:path";
-import * as jsonc from "jsonc-parser";
 async function readJsoncFile(name, cwd) {
   const file = await readTextFile(name, cwd);
   const data = jsonc.parse(file.data);
@@ -306,7 +257,7 @@ async function writeJsoncFile(file) {
 }
 function readTextFile(name, cwd) {
   return new Promise((resolve, reject) => {
-    const filePath = path.join(cwd, name);
+    const filePath = path__default.join(cwd, name);
     fs.readFile(filePath, "utf8", (err, text) => {
       if (err) {
         reject(err);
@@ -330,7 +281,6 @@ function writeTextFile(file) {
   });
 }
 
-// src/manifest.ts
 function isManifest(obj) {
   return obj && typeof obj === "object" && isOptionalString(obj.name) && isOptionalString(obj.version) && isOptionalString(obj.description);
 }
@@ -342,7 +292,6 @@ function isOptionalString(value) {
   return value === null || type === "undefined" || type === "string";
 }
 
-// src/get-current-version.ts
 async function getCurrentVersion(operation) {
   if (operation.state.currentVersion)
     return operation;
@@ -371,19 +320,23 @@ async function readVersion(file, cwd) {
   try {
     const { data: manifest } = await readJsoncFile(file, cwd);
     if (isManifest(manifest)) {
-      if (isValidVersion(manifest.version))
+      if (valid(manifest.version))
         return manifest.version;
     }
   } catch {
-    return void 0;
+    return undefined;
   }
 }
 
-// src/get-new-version.ts
-var import_picocolors = __toESM(require_picocolors(), 1);
-import process3 from "node:process";
-import prompts from "prompts";
-import semver, { clean as cleanVersion, valid as isValidVersion2, SemVer } from "semver";
+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;
@@ -431,9 +384,9 @@ function determineSemverChange(commits) {
 }
 function getNextVersions(currentVersion, preid, commits) {
   const next = {};
-  const parse2 = semver.parse(currentVersion);
-  if (typeof parse2?.prerelease[0] === "string")
-    preid = parse2?.prerelease[0] || "preid";
+  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;
@@ -448,21 +401,21 @@ async function promptForNewVersion(operation, commits) {
     {
       type: "autocomplete",
       name: "release",
-      message: `Current version ${import_picocolors.default.green(currentVersion)}`,
+      message: `Current version ${c.green(currentVersion)}`,
       initial: configCustomVersion ? "config" : "next",
       choices: [
-        { value: "major", title: `${"major".padStart(PADDING, " ")} ${import_picocolors.default.bold(next.major)}` },
-        { value: "minor", title: `${"minor".padStart(PADDING, " ")} ${import_picocolors.default.bold(next.minor)}` },
-        { value: "patch", title: `${"patch".padStart(PADDING, " ")} ${import_picocolors.default.bold(next.patch)}` },
-        { value: "next", title: `${"next".padStart(PADDING, " ")} ${import_picocolors.default.bold(next.next)}` },
-        { value: "conventional", title: `${"conventional".padStart(PADDING, " ")} ${import_picocolors.default.bold(next.conventional)}` },
+        { 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, " ")} ${import_picocolors.default.bold(configCustomVersion)}` }
+          { value: "config", title: `${"from config".padStart(PADDING, " ")} ${c.bold(configCustomVersion)}` }
         ] : [],
-        { value: "prepatch", title: `${"pre-patch".padStart(PADDING, " ")} ${import_picocolors.default.bold(next.prepatch)}` },
-        { value: "preminor", title: `${"pre-minor".padStart(PADDING, " ")} ${import_picocolors.default.bold(next.preminor)}` },
-        { value: "premajor", title: `${"pre-major".padStart(PADDING, " ")} ${import_picocolors.default.bold(next.premajor)}` },
-        { value: "none", title: `${"as-is".padStart(PADDING, " ")} ${import_picocolors.default.bold(currentVersion)}` },
+        { 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, " ") }
       ]
     },
@@ -472,13 +425,13 @@ async function promptForNewVersion(operation, commits) {
       message: "Enter the new version number:",
       initial: currentVersion,
       validate: (custom) => {
-        return isValidVersion2(custom) ? true : "That's not a valid version number";
+        return valid(custom) ? true : "That's not a valid version number";
       }
     }
   ]);
-  const newVersion = answers.release === "none" ? currentVersion : answers.release === "custom" ? cleanVersion(answers.custom) : answers.release === "config" ? cleanVersion(configCustomVersion) : next[answers.release];
+  const newVersion = answers.release === "none" ? currentVersion : answers.release === "custom" ? clean(answers.custom) : answers.release === "config" ? clean(configCustomVersion) : next[answers.release];
   if (!newVersion)
-    process3.exit(1);
+    process$1.exit(1);
   switch (answers.release) {
     case "custom":
     case "config":
@@ -491,8 +444,22 @@ async function promptForNewVersion(operation, commits) {
   }
 }
 
-// src/git.ts
-import { x } from "tinyexec";
+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;
@@ -513,7 +480,7 @@ async function gitCommit(operation) {
   if (!all)
     args = args.concat(updatedFiles);
   await x("git", ["commit", ...args], { throwOnError: true });
-  return operation.update({ event: "git commit" /* GitCommit */, commitMessage });
+  return operation.update({ event: ProgressEvent.GitCommit, commitMessage });
 }
 async function gitTag(operation) {
   if (!operation.options.tag)
@@ -534,7 +501,7 @@ async function gitTag(operation) {
     args.push("--sign");
   }
   await x("git", ["tag", ...args], { throwOnError: true });
-  return operation.update({ event: "git tag" /* GitTag */, tagName });
+  return operation.update({ event: ProgressEvent.GitTag, tagName });
 }
 async function gitPush(operation) {
   if (!operation.options.push)
@@ -543,7 +510,7 @@ async function gitPush(operation) {
   if (operation.options.tag) {
     await x("git", ["push", "--tags"], { throwOnError: true });
   }
-  return operation.update({ event: "git push" /* GitPush */ });
+  return operation.update({ event: ProgressEvent.GitPush });
 }
 function formatVersionString(template, newVersion) {
   if (template.includes("%s"))
@@ -552,12 +519,6 @@ function formatVersionString(template, newVersion) {
     return template + newVersion;
 }
 
-// src/normalize-options.ts
-import fsSync from "node:fs";
-import fs2 from "node:fs/promises";
-import process4 from "node:process";
-import yaml from "js-yaml";
-import { glob } from "tinyglobby";
 async function normalizeOptions(raw) {
   const preid = typeof raw.preid === "string" ? raw.preid : "beta";
   const sign = Boolean(raw.sign);
@@ -565,7 +526,7 @@ async function normalizeOptions(raw) {
   const all = Boolean(raw.all);
   const install = Boolean(raw.install);
   const noVerify = Boolean(raw.noVerify);
-  const cwd = raw.cwd || process4.cwd();
+  const cwd = raw.cwd || process$1.cwd();
   const ignoreScripts = Boolean(raw.ignoreScripts);
   const execute = raw.execute;
   const recursive = Boolean(raw.recursive);
@@ -596,8 +557,8 @@ async function normalizeOptions(raw) {
       "deno.json",
       "deno.jsonc"
     ];
-    if (fsSync.existsSync("pnpm-workspace.yaml")) {
-      const pnpmWorkspace = await fs2.readFile("pnpm-workspace.yaml", "utf8");
+    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));
@@ -621,13 +582,13 @@ async function normalizeOptions(raw) {
   if (raw.interface === false) {
     ui = { input: false, output: false };
   } else if (raw.interface === true || !raw.interface) {
-    ui = { input: process4.stdin, output: process4.stdout };
+    ui = { input: process$1.stdin, output: process$1.stdout };
   } else {
     let { input, output, ...other } = raw.interface;
     if (input === true || input !== false && !input)
-      input = process4.stdin;
+      input = process$1.stdin;
     if (output === true || output !== false && !output)
-      output = process4.stdout;
+      output = process$1.stdout;
     ui = { input, output, ...other };
   }
   if (release.type === "prompt" && !(ui.input && ui.output))
@@ -650,8 +611,7 @@ async function normalizeOptions(raw) {
   };
 }
 
-// src/operation.ts
-var Operation = class _Operation {
+class Operation {
   /**
    * The options for this operation.
    */
@@ -660,7 +620,7 @@ var Operation = class _Operation {
    * The current state of the operation.
    */
   state = {
-    release: void 0,
+    release: undefined,
     currentVersion: "",
     currentVersionSource: "",
     newVersion: "",
@@ -707,7 +667,7 @@ var Operation = class _Operation {
    */
   static async start(input) {
     const options = await normalizeOptions(input);
-    return new _Operation(options, input.progress);
+    return new Operation(options, input.progress);
   }
   /**
    * Updates the operation state and results, and reports the updated progress to the user.
@@ -719,64 +679,62 @@ var Operation = class _Operation {
     }
     return this;
   }
-};
+}
 
-// src/print-commits.ts
-var import_picocolors2 = __toESM(require_picocolors(), 1);
-var messageColorMap = {
-  feat: import_picocolors2.default.green,
-  feature: import_picocolors2.default.green,
-  refactor: import_picocolors2.default.cyan,
-  style: import_picocolors2.default.cyan,
-  docs: import_picocolors2.default.blue,
-  doc: import_picocolors2.default.blue,
-  types: import_picocolors2.default.blue,
-  type: import_picocolors2.default.blue,
-  chore: import_picocolors2.default.gray,
-  ci: import_picocolors2.default.gray,
-  build: import_picocolors2.default.gray,
-  deps: import_picocolors2.default.gray,
-  dev: import_picocolors2.default.gray,
-  fix: import_picocolors2.default.yellow,
-  test: import_picocolors2.default.yellow,
-  perf: import_picocolors2.default.magenta,
-  revert: import_picocolors2.default.red,
-  breaking: import_picocolors2.default.red
+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] || ((c4) => c4);
+    let color = messageColorMap[commit.type] || ((c2) => c2);
     if (commit.isBreaking) {
-      color = (s) => import_picocolors2.default.inverse(import_picocolors2.default.red(s));
+      color = (s) => c.inverse(c.red(s));
     }
     const paddedType = commit.type.padStart(typeLength + 1, " ");
-    const paddedScope = !commit.scope ? " ".repeat(scopeLength ? scopeLength + 2 : 0) : import_picocolors2.default.dim("(") + commit.scope + import_picocolors2.default.dim(")") + " ".repeat(scopeLength - commit.scope.length);
+    const paddedScope = !commit.scope ? " ".repeat(scopeLength ? scopeLength + 2 : 0) : c.dim("(") + commit.scope + c.dim(")") + " ".repeat(scopeLength - commit.scope.length);
     return [
-      import_picocolors2.default.dim(commit.shortHash),
+      c.dim(commit.shortHash),
       " ",
-      color === import_picocolors2.default.gray ? color(paddedType) : import_picocolors2.default.bold(color(paddedType)),
+      color === c.gray ? color(paddedType) : c.bold(color(paddedType)),
       " ",
       paddedScope,
-      import_picocolors2.default.dim(":"),
+      c.dim(":"),
       " ",
-      color === import_picocolors2.default.gray ? color(commit.description) : commit.description
+      color === c.gray ? color(commit.description) : commit.description
     ].join("");
   });
 }
 function printRecentCommits(commits) {
   if (!commits.length) {
     console.log();
-    console.log(import_picocolors2.default.blue(`i`) + import_picocolors2.default.gray(` No commits since the last version`));
+    console.log(c.blue(`i`) + c.gray(` No commits since the last version`));
     console.log();
     return;
   }
   const prettified = formatParsedCommits(commits);
   console.log();
   console.log(
-    import_picocolors2.default.bold(
-      `${import_picocolors2.default.green(commits.length)} Commits since the last version:`
+    c.bold(
+      `${c.green(commits.length)} Commits since the last version:`
     )
   );
   console.log();
@@ -784,17 +742,15 @@ function printRecentCommits(commits) {
   console.log();
 }
 
-// src/run-npm-script.ts
-import { x as x2 } from "tinyexec";
 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 x2("npm", ["run", script, "--silent"], {
+      await x("npm", ["run", script, "--silent"], {
         nodeOptions: { stdio: "inherit" }
       });
-      operation.update({ event: "npm script" /* NpmScript */, script });
+      operation.update({ event: ProgressEvent.NpmScript, script });
     }
   }
   return operation;
@@ -806,21 +762,18 @@ function hasScript(manifest, script) {
   return false;
 }
 
-// src/update-files.ts
-import { existsSync } from "node:fs";
-import * as path2 from "node:path";
 async function updateFiles(operation) {
   const { files } = operation.options;
   for (const relPath of files) {
     const modified = await updateFile(relPath, operation);
     if (modified) {
       operation.update({
-        event: "file updated" /* FileUpdated */,
+        event: ProgressEvent.FileUpdated,
         updatedFiles: operation.state.updatedFiles.concat(relPath)
       });
     } else {
       operation.update({
-        event: "file skipped" /* FileSkipped */,
+        event: ProgressEvent.FileSkipped,
         skippedFiles: operation.state.skippedFiles.concat(relPath)
       });
     }
@@ -828,10 +781,10 @@ async function updateFiles(operation) {
   return operation;
 }
 async function updateFile(relPath, operation) {
-  if (!existsSync(path2.join(operation.options.cwd, relPath))) {
+  if (!existsSync(path.join(operation.options.cwd, relPath))) {
     return false;
   }
-  const name = path2.basename(relPath).trim().toLowerCase();
+  const name = path.basename(relPath).trim().toLowerCase();
   switch (name) {
     case "package.json":
     case "package-lock.json":
@@ -881,7 +834,6 @@ async function updateTextFile(relPath, operation) {
   return modified;
 }
 
-// src/version-bump.ts
 async function versionBump(arg = {}) {
   if (typeof arg === "string")
     arg = { release: arg };
@@ -894,77 +846,77 @@ async function versionBump(arg = {}) {
   await getNewVersion(operation, commits);
   if (arg.confirm) {
     printSummary(operation);
-    if (!await prompts2({
+    if (!await prompts({
       name: "yes",
       type: "confirm",
       message: "Bump?",
       initial: true
     }).then((r) => r.yes)) {
-      process5.exit(1);
+      process$1.exit(1);
     }
   }
-  await runNpmScript("preversion" /* PreVersion */, operation);
+  await runNpmScript(NpmScript.PreVersion, operation);
   await updateFiles(operation);
   if (operation.options.install) {
-    const { detect } = await import("package-manager-detector/detect");
+    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 { 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_exports.info, "Installing dependencies with", `${command.command} ${command.args.join(" ")}`);
-    await x3(command.command, command.args, {
+    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_exports.success, "Dependencies installed");
+    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_exports.info, "Executing script", command, ...args);
-      await x3(command, args, {
+      console.log(symbols.info, "Executing script", command, ...args);
+      await x(command, args, {
         throwOnError: true,
         nodeOptions: {
           stdio: "inherit",
           cwd: operation.options.cwd
         }
       });
-      console.log(symbols_exports.success, "Script finished");
+      console.log(symbols.success, "Script finished");
     }
   }
-  await runNpmScript("version" /* Version */, operation);
+  await runNpmScript(NpmScript.Version, operation);
   await gitCommit(operation);
   await gitTag(operation);
-  await runNpmScript("postversion" /* PostVersion */, 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) => import_picocolors3.default.bold(i)).join("\n         ")}`);
+  console.log(`   files ${operation.options.files.map((i) => c.bold(i)).join("\n         ")}`);
   if (operation.options.commit)
-    console.log(`  commit ${import_picocolors3.default.bold(formatVersionString(operation.options.commit.message, operation.state.newVersion))}`);
+    console.log(`  commit ${c.bold(formatVersionString(operation.options.commit.message, operation.state.newVersion))}`);
   if (operation.options.tag)
-    console.log(`     tag ${import_picocolors3.default.bold(formatVersionString(operation.options.tag.name, operation.state.newVersion))}`);
+    console.log(`     tag ${c.bold(formatVersionString(operation.options.tag.name, operation.state.newVersion))}`);
   if (operation.options.execute)
-    console.log(` execute ${import_picocolors3.default.bold(typeof operation.options.execute === "function" ? "function" : operation.options.execute)}`);
+    console.log(` execute ${c.bold(typeof operation.options.execute === "function" ? "function" : operation.options.execute)}`);
   if (operation.options.push)
-    console.log(`    push ${import_picocolors3.default.cyan(import_picocolors3.default.bold("yes"))}`);
+    console.log(`    push ${c.cyan(c.bold("yes"))}`);
   if (operation.options.install)
-    console.log(` install ${import_picocolors3.default.cyan(import_picocolors3.default.bold("yes"))}`);
+    console.log(` install ${c.cyan(c.bold("yes"))}`);
   console.log();
-  console.log(`    from ${import_picocolors3.default.bold(operation.state.currentVersion)}`);
-  console.log(`      to ${import_picocolors3.default.green(import_picocolors3.default.bold(operation.state.newVersion))}`);
+  console.log(`    from ${c.bold(operation.state.currentVersion)}`);
+  console.log(`      to ${c.green(c.bold(operation.state.newVersion))}`);
   console.log();
 }
 async function versionBumpInfo(arg = {}) {
@@ -977,12 +929,7 @@ async function versionBumpInfo(arg = {}) {
   return operation;
 }
 
-// src/config.ts
-import { dirname } from "node:path";
-import process6 from "node:process";
-import { loadConfig } from "c12";
-import escalade from "escalade/sync";
-var bumpConfigDefaults = {
+const bumpConfigDefaults = {
   commit: true,
   push: true,
   tag: true,
@@ -996,7 +943,7 @@ var bumpConfigDefaults = {
   noGitCheck: true,
   files: []
 };
-async function loadBumpConfig(overrides, cwd = process6.cwd()) {
+async function loadBumpConfig(overrides, cwd = process$1.cwd()) {
   const name = "bump";
   const configFile = findConfigFile(name, cwd);
   const { config } = await loadConfig({
@@ -1028,26 +975,14 @@ function findConfigFile(name, cwd) {
       }
       return false;
     });
-  } catch (error2) {
+  } catch (error) {
     if (foundRepositoryRoot)
       return null;
-    throw error2;
+    throw error;
   }
 }
 function defineConfig(config) {
   return config;
 }
 
-export {
-  __toESM,
-  symbols_exports,
-  ProgressEvent,
-  NpmScript,
-  require_picocolors,
-  isReleaseType,
-  versionBump,
-  versionBumpInfo,
-  bumpConfigDefaults,
-  loadBumpConfig,
-  defineConfig
-};
+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 };