bumpp 7.0.0 → 7.2.0

package/dist/{chunk-TILHCTE7.mjs → chunk-2TP63A7S.mjs}

@@ -1,7 +1,11 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -17,6 +21,14 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
 var __objRest = (source, exclude) => {
   var target = {};
   for (var prop in source)
@@ -29,104 +41,93 @@ var __objRest = (source, exclude) => {
     }
   return target;
 };
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __reExport = (target, module, copyDefault, desc) => {
+  if (module && typeof module === "object" || typeof module === "function") {
+    for (let key of __getOwnPropNames(module))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+  }
+  return target;
 };
+var __toESM = (module, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", !isNodeMode && module && module.__esModule ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
+};
+
+// node_modules/.pnpm/tsup@5.11.9_typescript@4.5.4/node_modules/tsup/assets/esm_shims.js
+var init_esm_shims = __esm({
+  "node_modules/.pnpm/tsup@5.11.9_typescript@4.5.4/node_modules/tsup/assets/esm_shims.js"() {
+  }
+});
+
+// node_modules/.pnpm/is-unicode-supported@0.1.0/node_modules/is-unicode-supported/index.js
+var require_is_unicode_supported = __commonJS({
+  "node_modules/.pnpm/is-unicode-supported@0.1.0/node_modules/is-unicode-supported/index.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    module.exports = () => {
+      if (process.platform !== "win32") {
+        return true;
+      }
+      return Boolean(process.env.CI) || Boolean(process.env.WT_SESSION) || process.env.TERM_PROGRAM === "vscode" || process.env.TERM === "xterm-256color" || process.env.TERM === "alacritty";
+    };
+  }
+});
+
+// node_modules/.pnpm/log-symbols@4.1.0/node_modules/log-symbols/index.js
+var require_log_symbols = __commonJS({
+  "node_modules/.pnpm/log-symbols@4.1.0/node_modules/log-symbols/index.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var chalk = __require("chalk");
+    var isUnicodeSupported = require_is_unicode_supported();
+    var main = {
+      info: chalk.blue("\u2139"),
+      success: chalk.green("\u2714"),
+      warning: chalk.yellow("\u26A0"),
+      error: chalk.red("\u2716")
+    };
+    var fallback = {
+      info: chalk.blue("i"),
+      success: chalk.green("\u221A"),
+      warning: chalk.yellow("\u203C"),
+      error: chalk.red("\xD7")
+    };
+    module.exports = isUnicodeSupported() ? main : fallback;
+  }
+});
 
-// package.json
-var require_package = __commonJS({
-  "package.json"(exports, module) {
-    module.exports = {
-      name: "bumpp",
-      version: "7.0.0",
-      description: "Automatically (or with prompts) bump your version number, commit changes, tag, and push to Git",
-      keywords: [
-        "version",
-        "bump",
-        "npm",
-        "node",
-        "bower",
-        "package",
-        "git",
-        "tag",
-        "push",
-        "prompt"
-      ],
-      author: {
-        name: "James Messinger",
-        url: "https://jamesmessinger.com"
-      },
-      license: "MIT",
-      homepage: "https://jstools.dev/version-bump-prompt",
-      repository: {
-        type: "git",
-        url: "https://github.com/antfu/bumpp.git"
-      },
-      main: "dist/index.js",
-      types: "dist/index.d.ts",
-      bin: {
-        bump: "bin/bumpp.js"
-      },
-      files: [
-        "bin",
-        "dist"
-      ],
-      scripts: {
-        clean: "rimraf .nyc_output coverage dist",
-        lint: "eslint src test",
-        build: "tsup src/index.ts src/cli/index.ts --format esm,cjs --dts",
-        watch: "npm run build -- --watch src",
-        test: "mocha && npm run lint",
-        coverage: "nyc node_modules/mocha/bin/mocha",
-        upgrade: "npm-check -u && npm audit fix",
-        bump: "esno src/cli/run.ts --tag --push --all",
-        prepublishOnly: "npm run clean && npm run build",
-        release: "npm run bump && npm publish"
-      },
-      devDependencies: {
-        "@jsdevtools/chai-exec": "^2.1.1",
-        "@jsdevtools/eslint-config": "^1.1.4",
-        "@types/chai": "^4.2.12",
-        "@types/command-line-args": "^5.0.0",
-        "@types/globby": "^9.1.0",
-        "@types/inquirer": "^7.3.1",
-        "@types/mocha": "^8.0.3",
-        "@types/node": "^14.6.2",
-        "@types/semver": "^7.3.3",
-        chai: "^4.2.0",
-        del: "^5.1.0",
-        eslint: "^7.7.0",
-        esno: "^0.9.1",
-        mocha: "^8.1.3",
-        "npm-check": "^5.9.0",
-        nyc: "^15.1.0",
-        rimraf: "^3.0.2",
-        shx: "^0.3.2",
-        "strip-ansi": "^6.0.0",
-        tsup: "^4.14.0",
-        typescript: "^4.0.2"
-      },
-      dependencies: {
-        "@jsdevtools/ez-spawn": "^3.0.4",
-        "command-line-args": "^5.1.1",
-        "detect-indent": "^6.0.0",
-        "detect-newline": "^3.1.0",
-        globby: "^11.0.1",
-        inquirer: "^7.3.3",
-        "log-symbols": "^4.0.0",
-        semver: "^7.3.2"
-      },
-      engines: {
-        node: ">=10"
-      },
-      engineStrict: true
+// node_modules/.pnpm/detect-newline@3.1.0/node_modules/detect-newline/index.js
+var require_detect_newline = __commonJS({
+  "node_modules/.pnpm/detect-newline@3.1.0/node_modules/detect-newline/index.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var detectNewline2 = (string) => {
+      if (typeof string !== "string") {
+        throw new TypeError("Expected a string");
+      }
+      const newlines = string.match(/(?:\r?\n)/g) || [];
+      if (newlines.length === 0) {
+        return;
+      }
+      const crlf = newlines.filter((newline) => newline === "\r\n").length;
+      const lf = newlines.length - crlf;
+      return crlf > lf ? "\r\n" : "\n";
     };
+    module.exports = detectNewline2;
+    module.exports.graceful = (string) => typeof string === "string" && detectNewline2(string) || "\n";
   }
 });
 
 // src/release-type.ts
+init_esm_shims();
 import { ReleaseType } from "semver";
-var prereleaseTypes = ["premajor", "preminor", "prepatch", "prerelease"];
+var prereleaseTypes = ["prerelease"];
 var releaseTypes = prereleaseTypes.concat(["major", "minor", "patch"]);
 function isPrerelease(value) {
   return prereleaseTypes.includes(value);
@@ -135,48 +136,34 @@ function isReleaseType(value) {
   return releaseTypes.includes(value);
 }
 
-// src/manifest.ts
-var manifest = require_package();
-function isManifest(obj) {
-  return obj && typeof obj === "object" && isOptionalString(obj.name) && isOptionalString(obj.version) && isOptionalString(obj.description);
-}
-function isOptionalString(value) {
-  let type = typeof value;
-  return value === null || type === "undefined" || type === "string";
-}
-
 // src/types/version-bump-progress.ts
-var ProgressEvent;
-(function(ProgressEvent2) {
+init_esm_shims();
+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";
-})(ProgressEvent || (ProgressEvent = {}));
-var NpmScript;
-(function(NpmScript3) {
+  return ProgressEvent2;
+})(ProgressEvent || {});
+var NpmScript = /* @__PURE__ */ ((NpmScript3) => {
   NpmScript3["PreVersion"] = "preversion";
   NpmScript3["Version"] = "version";
   NpmScript3["PostVersion"] = "postversion";
-})(NpmScript || (NpmScript = {}));
+  return NpmScript3;
+})(NpmScript || {});
 
 // src/version-bump.ts
-import {
-  async as async3
-} from "@jsdevtools/ez-spawn";
+init_esm_shims();
+import * as ezSpawn3 from "@jsdevtools/ez-spawn";
 
 // src/get-new-version.ts
-import {
-  Separator,
-  createPromptModule
-} from "inquirer";
-import {
-  clean,
-  valid
-} from "semver";
-import { SemVer } from "semver";
+init_esm_shims();
+import { bold, green } from "chalk";
+import prompts from "prompts";
+import { valid as isValidVersion, clean as cleanVersion } from "semver";
+import semver, { SemVer } from "semver";
 async function getNewVersion(operation) {
   let { release } = operation.options;
   let { oldVersion } = operation.state;
@@ -205,80 +192,176 @@ function getNextVersion(oldVersion, bump) {
   return newSemVer.version;
 }
 function getNextVersions(oldVersion, preid) {
+  var _a;
   let next = {};
+  const parse = semver.parse(oldVersion);
+  if (typeof (parse == null ? void 0 : parse.prerelease[0]) === "string") {
+    preid = (parse == null ? void 0 : parse.prerelease[0]) || "preid";
+  }
   for (let type of releaseTypes) {
-    next[type] = getNextVersion(oldVersion, { type, preid });
+    next[type] = semver.inc(oldVersion, type, preid);
   }
+  next.next = ((_a = parse == null ? void 0 : parse.prerelease) == null ? void 0 : _a.length) ? semver.inc(oldVersion, "prerelease", preid) : semver.inc(oldVersion, "patch");
   return next;
 }
 async function promptForNewVersion(operation) {
-  let { oldVersion, oldVersionSource } = operation.state;
+  let { oldVersion } = operation.state;
   let release = operation.options.release;
-  let prompts = createPromptModule(operation.options.interface);
   let next = getNextVersions(oldVersion, release.preid);
   let answers;
   answers = await prompts([
     {
-      type: "list",
+      type: "autocomplete",
       name: "release",
-      message: `
-The current version in ${oldVersionSource} is ${oldVersion}
-How would you like to bump it?`,
-      default: "patch",
-      pageSize: 10,
+      message: `Current version: ${green(oldVersion)}`,
+      initial: "next",
       choices: [
-        { value: "major", name: `major (${next.major})` },
-        { value: "minor", name: `minor (${next.minor})` },
-        { value: "patch", name: `patch (${next.patch})` },
-        { value: "premajor", name: `pre-release major (${next.premajor})` },
-        { value: "preminor", name: `pre-release minor (${next.preminor})` },
-        { value: "prepatch", name: `pre-release patch (${next.prepatch})` },
-        { value: "prerelease", name: `pre-release (${next.prerelease})` },
-        new Separator(),
-        { value: "none", name: `leave as-is (${oldVersion})` },
-        { value: "custom", name: "custom..." }
+        { value: "major", title: "major - " + bold(next.major) },
+        { value: "minor", title: "minor - " + bold(next.minor) },
+        { value: "patch", title: "patch - " + bold(next.patch) },
+        { value: "next", title: "next - " + bold(next.next) },
+        { value: "prerelease", title: "pre-release - " + bold(next.prerelease) },
+        { value: "none", title: "as-is - " + bold(oldVersion) },
+        { value: "custom", title: "custom..." }
       ]
     },
     {
-      type: "input",
-      name: "newVersion",
+      type: (prev) => prev === "custom" ? "text" : null,
+      name: "custom",
       message: "Enter the new version number:",
-      default: oldVersion,
-      when: (previousAnswer) => previousAnswer.release === "custom",
-      filter: clean,
-      validate: (newVersion) => {
-        return valid(newVersion) ? true : "That's not a valid version number";
+      initial: oldVersion,
+      validate: (custom) => {
+        return isValidVersion(custom) ? true : "That's not a valid version number";
       }
     }
   ]);
+  const newVersion = answers.release === "none" ? oldVersion : answers.release === "custom" ? cleanVersion(answers.custom) : next[answers.release];
+  if (!newVersion) {
+    process.exit(1);
+  }
   switch (answers.release) {
-    case "none":
-      return operation.update({ newVersion: oldVersion });
     case "custom":
-      return operation.update({ newVersion: answers.newVersion });
+    case "none":
+      return operation.update({ newVersion });
     default:
-      return operation.update({
-        release: answers.release,
-        newVersion: next[answers.release]
-      });
+      return operation.update({ release: answers.release, newVersion });
   }
 }
 
 // src/get-old-version.ts
-import {
-  valid as valid2
-} from "semver";
+init_esm_shims();
+import { valid as isValidVersion2 } from "semver";
 
 // src/fs.ts
-import detectIndent from "detect-indent";
-import detectNewline from "detect-newline";
+init_esm_shims();
+
+// node_modules/.pnpm/detect-indent@7.0.0/node_modules/detect-indent/index.js
+init_esm_shims();
+var INDENT_REGEX = /^(?:( )+|\t+)/;
+var INDENT_TYPE_SPACE = "space";
+var INDENT_TYPE_TAB = "tab";
+function makeIndentsMap(string, ignoreSingleSpaces) {
+  const indents = /* @__PURE__ */ new Map();
+  let previousSize = 0;
+  let previousIndentType;
+  let key;
+  for (const line of string.split(/\n/g)) {
+    if (!line) {
+      continue;
+    }
+    let indent;
+    let indentType;
+    let weight;
+    let entry;
+    const matches = line.match(INDENT_REGEX);
+    if (matches === null) {
+      previousSize = 0;
+      previousIndentType = "";
+    } else {
+      indent = matches[0].length;
+      indentType = matches[1] ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
+      if (ignoreSingleSpaces && indentType === INDENT_TYPE_SPACE && indent === 1) {
+        continue;
+      }
+      if (indentType !== previousIndentType) {
+        previousSize = 0;
+      }
+      previousIndentType = indentType;
+      weight = 0;
+      const indentDifference = indent - previousSize;
+      previousSize = indent;
+      if (indentDifference === 0) {
+        weight++;
+      } else {
+        const absoluteIndentDifference = indentDifference > 0 ? indentDifference : -indentDifference;
+        key = encodeIndentsKey(indentType, absoluteIndentDifference);
+      }
+      entry = indents.get(key);
+      entry = entry === void 0 ? [1, 0] : [++entry[0], entry[1] + weight];
+      indents.set(key, entry);
+    }
+  }
+  return indents;
+}
+function encodeIndentsKey(indentType, indentAmount) {
+  const typeCharacter = indentType === INDENT_TYPE_SPACE ? "s" : "t";
+  return typeCharacter + String(indentAmount);
+}
+function decodeIndentsKey(indentsKey) {
+  const keyHasTypeSpace = indentsKey[0] === "s";
+  const type = keyHasTypeSpace ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
+  const amount = Number(indentsKey.slice(1));
+  return { type, amount };
+}
+function getMostUsedKey(indents) {
+  let result;
+  let maxUsed = 0;
+  let maxWeight = 0;
+  for (const [key, [usedCount, weight]] of indents) {
+    if (usedCount > maxUsed || usedCount === maxUsed && weight > maxWeight) {
+      maxUsed = usedCount;
+      maxWeight = weight;
+      result = key;
+    }
+  }
+  return result;
+}
+function makeIndentString(type, amount) {
+  const indentCharacter = type === INDENT_TYPE_SPACE ? " " : "	";
+  return indentCharacter.repeat(amount);
+}
+function detectIndent(string) {
+  if (typeof string !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  let indents = makeIndentsMap(string, true);
+  if (indents.size === 0) {
+    indents = makeIndentsMap(string, false);
+  }
+  const keyOfMostUsedIndent = getMostUsedKey(indents);
+  let type;
+  let amount = 0;
+  let indent = "";
+  if (keyOfMostUsedIndent !== void 0) {
+    ({ type, amount } = decodeIndentsKey(keyOfMostUsedIndent));
+    indent = makeIndentString(type, amount);
+  }
+  return {
+    amount,
+    type,
+    indent
+  };
+}
+
+// src/fs.ts
+var import_detect_newline = __toESM(require_detect_newline());
 import fs from "fs";
 import path from "path";
 async function readJsonFile(name, cwd) {
   let file = await readTextFile(name, cwd);
   let data = JSON.parse(file.data);
   let indent = detectIndent(file.data).indent;
-  let newline = detectNewline(file.data);
+  let newline = (0, import_detect_newline.default)(file.data);
   return __spreadProps(__spreadValues({}, file), { data, indent, newline });
 }
 async function writeJsonFile(file) {
@@ -315,6 +398,16 @@ function writeTextFile(file) {
   });
 }
 
+// src/manifest.ts
+init_esm_shims();
+function isManifest(obj) {
+  return obj && typeof obj === "object" && isOptionalString(obj.name) && isOptionalString(obj.version) && isOptionalString(obj.description);
+}
+function isOptionalString(value) {
+  let type = typeof value;
+  return value === null || type === "undefined" || type === "string";
+}
+
 // src/get-old-version.ts
 async function getOldVersion(operation) {
   let { cwd, files } = operation.options;
@@ -335,10 +428,10 @@ async function getOldVersion(operation) {
 }
 async function readVersion(file, cwd) {
   try {
-    let { data: manifest2 } = await readJsonFile(file, cwd);
-    if (isManifest(manifest2)) {
-      if (valid2(manifest2.version)) {
-        return manifest2.version;
+    let { data: manifest } = await readJsonFile(file, cwd);
+    if (isManifest(manifest)) {
+      if (isValidVersion2(manifest.version)) {
+        return manifest.version;
       }
     }
   } catch (error) {
@@ -347,9 +440,8 @@ async function readVersion(file, cwd) {
 }
 
 // src/git.ts
-import {
-  async
-} from "@jsdevtools/ez-spawn";
+init_esm_shims();
+import * as ezSpawn from "@jsdevtools/ez-spawn";
 async function gitCommit(operation) {
   if (!operation.options.commit) {
     return operation;
@@ -368,8 +460,8 @@ async function gitCommit(operation) {
   if (!all) {
     args = args.concat(updatedFiles);
   }
-  await async("git", ["commit", ...args]);
-  return operation.update({ event: ProgressEvent.GitCommit, commitMessage });
+  await ezSpawn.async("git", ["commit", ...args]);
+  return operation.update({ event: "git commit" /* GitCommit */, commitMessage });
 }
 async function gitTag(operation) {
   if (!operation.options.tag) {
@@ -384,18 +476,18 @@ async function gitTag(operation) {
   ];
   let tagName = formatVersionString(tag.name, newVersion);
   args.push(tagName);
-  await async("git", ["tag", ...args]);
-  return operation.update({ event: ProgressEvent.GitTag, tagName });
+  await ezSpawn.async("git", ["tag", ...args]);
+  return operation.update({ event: "git tag" /* GitTag */, tagName });
 }
 async function gitPush(operation) {
   if (!operation.options.push) {
     return operation;
   }
-  await async("git", "push");
+  await ezSpawn.async("git", "push");
   if (operation.options.tag) {
-    await async("git", ["push", "--tags"]);
+    await ezSpawn.async("git", ["push", "--tags"]);
   }
-  return operation.update({ event: ProgressEvent.GitPush });
+  return operation.update({ event: "git push" /* GitPush */ });
 }
 function formatVersionString(template, newVersion) {
   if (template.includes("%s")) {
@@ -405,7 +497,11 @@ function formatVersionString(template, newVersion) {
   }
 }
 
+// src/operation.ts
+init_esm_shims();
+
 // src/normalize-options.ts
+init_esm_shims();
 import globby from "globby";
 import { hasMagic } from "globby";
 async function normalizeOptions(raw) {
@@ -464,7 +560,7 @@ async function normalizeOptions(raw) {
 }
 async function strictGlobMatches(files, options) {
   let matches = await Promise.all(files.map((file) => strictGlobMatch(file, options)));
-  let matchedFiles = new Set();
+  let matchedFiles = /* @__PURE__ */ new Set();
   for (let match of matches) {
     for (let file of match) {
       matchedFiles.add(file);
@@ -528,22 +624,21 @@ var Operation = class {
 };
 
 // src/run-npm-script.ts
-import {
-  async as async2
-} from "@jsdevtools/ez-spawn";
+init_esm_shims();
+import * as ezSpawn2 from "@jsdevtools/ez-spawn";
 async function runNpmScript(script, operation) {
   let { cwd, ignoreScripts } = operation.options;
   if (!ignoreScripts) {
-    let { data: manifest2 } = await readJsonFile("package.json", cwd);
-    if (isManifest(manifest2) && hasScript(manifest2, script)) {
-      await async2("npm", ["run", script, "--silent"], { stdio: "inherit" });
-      operation.update({ event: ProgressEvent.NpmScript, script });
+    let { data: manifest } = await readJsonFile("package.json", cwd);
+    if (isManifest(manifest) && hasScript(manifest, script)) {
+      await ezSpawn2.async("npm", ["run", script, "--silent"], { stdio: "inherit" });
+      operation.update({ event: "npm script" /* NpmScript */, script });
     }
   }
   return operation;
 }
-function hasScript(manifest2, script) {
-  let scripts = manifest2.scripts;
+function hasScript(manifest, script) {
+  let scripts = manifest.scripts;
   if (scripts && typeof scripts === "object") {
     return Boolean(scripts[script]);
   }
@@ -551,21 +646,20 @@ function hasScript(manifest2, script) {
 }
 
 // src/update-files.ts
-import {
-  basename
-} from "path";
+init_esm_shims();
+import * as path2 from "path";
 async function updateFiles(operation) {
   let { files } = operation.options;
   for (let relPath of files) {
     let modified = await updateFile(relPath, operation);
     if (modified) {
       operation.update({
-        event: ProgressEvent.FileUpdated,
+        event: "file updated" /* FileUpdated */,
         updatedFiles: operation.state.updatedFiles.concat(relPath)
       });
     } else {
       operation.update({
-        event: ProgressEvent.FileSkipped,
+        event: "file skipped" /* FileSkipped */,
         skippedFiles: operation.state.skippedFiles.concat(relPath)
       });
     }
@@ -573,7 +667,7 @@ async function updateFiles(operation) {
   return operation;
 }
 async function updateFile(relPath, operation) {
-  let name = basename(relPath).trim().toLowerCase();
+  let name = path2.basename(relPath).trim().toLowerCase();
   switch (name) {
     case "package.json":
     case "package-lock.json":
@@ -612,6 +706,7 @@ async function updateTextFile(relPath, operation) {
 }
 
 // src/version-bump.ts
+var import_log_symbols = __toESM(require_log_symbols());
 async function versionBump(arg = {}) {
   if (typeof arg === "string") {
     arg = { release: arg };
@@ -619,24 +714,28 @@ async function versionBump(arg = {}) {
   let operation = await Operation.start(arg);
   await getOldVersion(operation);
   await getNewVersion(operation);
-  await runNpmScript(NpmScript.PreVersion, operation);
+  await runNpmScript("preversion" /* PreVersion */, operation);
   await updateFiles(operation);
   if (operation.options.execute) {
-    await async3(operation.options.execute, { stdio: "inherit" });
+    console.log(import_log_symbols.info, "Executing script", operation.options.execute);
+    await ezSpawn3.async(operation.options.execute, { stdio: "inherit" });
+    console.log(import_log_symbols.success, "Script finished");
   }
-  await runNpmScript(NpmScript.Version, operation);
+  await runNpmScript("version" /* Version */, operation);
   await gitCommit(operation);
   await gitTag(operation);
-  await runNpmScript(NpmScript.PostVersion, operation);
+  await runNpmScript("postversion" /* PostVersion */, operation);
   await gitPush(operation);
   return operation.results;
 }
 
 export {
+  __toESM,
+  init_esm_shims,
   ReleaseType,
   isReleaseType,
-  manifest,
   ProgressEvent,
   NpmScript,
+  require_log_symbols,
   versionBump
 };