@releasekit/version 0.7.32 → 0.7.45

package/dist/{chunk-UBCKZYTO.js → chunk-45DJUNXI.js}

@@ -531,14 +531,14 @@ function enableJsonOutput(dryRun = false) {
   _jsonData.commitMessage = void 0;
   _pendingWrites.length = 0;
 }
-function recordPendingWrite(path10, content) {
+function recordPendingWrite(path11, content) {
   if (!_jsonOutputMode) return;
-  _pendingWrites.push({ path: path10, content });
+  _pendingWrites.push({ path: path11, content });
 }
 function flushPendingWrites() {
   try {
-    for (const { path: path10, content } of _pendingWrites) {
-      fs4.writeFileSync(path10, content);
+    for (const { path: path11, content } of _pendingWrites) {
+      fs4.writeFileSync(path11, content);
     }
   } finally {
     _pendingWrites.length = 0;
@@ -582,8 +582,686 @@ function printJsonOutput() {
 
 // src/core/versionCalculator.ts
 import { cwd } from "process";
-import { Bumper } from "conventional-recommended-bump";
-import semver3 from "semver";
+
+// ../../node_modules/.pnpm/@conventional-changelog+git-client@2.5.1_conventional-commits-filter@5.0.0_conventional-commits-parser@6.2.1/node_modules/@conventional-changelog/git-client/dist/utils.js
+function formatArgs(...args) {
+  return args.reduce((finalArgs, arg) => {
+    if (arg) {
+      finalArgs.push(String(arg));
+    }
+    return finalArgs;
+  }, []);
+}
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+// ../../node_modules/.pnpm/@conventional-changelog+git-client@2.5.1_conventional-commits-filter@5.0.0_conventional-commits-parser@6.2.1/node_modules/@conventional-changelog/git-client/dist/GitClient.js
+import { spawn } from "child_process";
+
+// ../../node_modules/.pnpm/@simple-libs+stream-utils@1.1.0/node_modules/@simple-libs/stream-utils/dist/index.js
+import { Readable } from "stream";
+async function toArray2(iterable) {
+  const result = [];
+  for await (const item of iterable) {
+    result.push(item);
+  }
+  return result;
+}
+async function concatBufferStream(iterable) {
+  return Buffer.concat(await toArray2(iterable));
+}
+async function firstFromStream(stream) {
+  for await (const tag of stream) {
+    return tag;
+  }
+  return null;
+}
+async function* splitStream(stream, separator) {
+  let chunk;
+  let payload;
+  let buffer = "";
+  for await (chunk of stream) {
+    buffer += chunk.toString();
+    if (buffer.includes(separator)) {
+      payload = buffer.split(separator);
+      buffer = payload.pop() || "";
+      yield* payload;
+    }
+  }
+  if (buffer) {
+    yield buffer;
+  }
+}
+
+// ../../node_modules/.pnpm/@simple-libs+child-process-utils@1.0.1/node_modules/@simple-libs/child-process-utils/dist/index.js
+async function exitCode(process2) {
+  if (process2.exitCode !== null) {
+    return process2.exitCode;
+  }
+  return new Promise((resolve2) => process2.once("close", resolve2));
+}
+async function catchProcessError(process2) {
+  let error = new Error("Process exited with non-zero code");
+  let stderr = "";
+  process2.on("error", (err) => {
+    error = err;
+  });
+  if (process2.stderr) {
+    let chunk;
+    for await (chunk of process2.stderr) {
+      stderr += chunk.toString();
+    }
+  }
+  const code = await exitCode(process2);
+  if (stderr) {
+    error = new Error(stderr);
+  }
+  return code ? error : null;
+}
+async function* outputStream(process2) {
+  const { stdout } = process2;
+  const errorPromise = catchProcessError(process2);
+  if (stdout) {
+    stdout.on("error", (err) => {
+      if (err.name === "AbortError" && process2.exitCode === null) {
+        process2.kill("SIGKILL");
+      }
+    });
+    yield* stdout;
+  }
+  const error = await errorPromise;
+  if (error) {
+    throw error;
+  }
+}
+function output(process2) {
+  return concatBufferStream(outputStream(process2));
+}
+
+// ../../node_modules/.pnpm/@conventional-changelog+git-client@2.5.1_conventional-commits-filter@5.0.0_conventional-commits-parser@6.2.1/node_modules/@conventional-changelog/git-client/dist/GitClient.js
+var SCISSOR = "------------------------ >8 ------------------------";
+var GitClient = class {
+  cwd;
+  debug;
+  constructor(cwd3, debug) {
+    this.cwd = cwd3;
+    this.debug = debug;
+  }
+  formatArgs(...args) {
+    const finalArgs = formatArgs(...args);
+    if (this.debug) {
+      this.debug(finalArgs);
+    }
+    return finalArgs;
+  }
+  /**
+   * Raw exec method to run git commands.
+   * @param args
+   * @returns Stdout string output of the command.
+   */
+  async exec(...args) {
+    return (await output(spawn("git", this.formatArgs(...args), {
+      cwd: this.cwd
+    }))).toString().trim();
+  }
+  /**
+   * Raw exec method to run git commands with stream output.
+   * @param args
+   * @returns Stdout stream of the command.
+   */
+  execStream(...args) {
+    return outputStream(spawn("git", this.formatArgs(...args), {
+      cwd: this.cwd
+    }));
+  }
+  /**
+   * Initialize a new git repository.
+   * @returns Boolean result.
+   */
+  async init() {
+    try {
+      await this.exec("init");
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+  /**
+   * Get raw commits stream.
+   * @param params
+   * @param params.path - Read commits from specific path.
+   * @param params.from - Start commits range.
+   * @param params.to - End commits range.
+   * @param params.format - Commits format.
+   * @yields Raw commits data.
+   */
+  async *getRawCommits(params = {}) {
+    const { path: path11, from = "", to = "HEAD", format = "%B", ignore, reverse, merges, since } = params;
+    const shouldNotIgnore = ignore ? (chunk2) => !ignore.test(chunk2) : () => true;
+    const stdout = this.execStream("log", `--format=${format}%n${SCISSOR}`, since && `--since=${since instanceof Date ? since.toISOString() : since}`, reverse && "--reverse", merges && "--merges", merges === false && "--no-merges", [from, to].filter(Boolean).join(".."), ...path11 ? ["--", ...toArray(path11)] : []);
+    const commitsStream = splitStream(stdout, `${SCISSOR}
+`);
+    let chunk;
+    for await (chunk of commitsStream) {
+      if (shouldNotIgnore(chunk)) {
+        yield chunk;
+      }
+    }
+  }
+  /**
+   * Get tags stream.
+   * @param params
+   * @yields Tags
+   */
+  async *getTags(params = {}) {
+    const { path: path11, from = "", to = "HEAD", since } = params;
+    const tagRegex = /tag:\s*(.+?)[,)]/gi;
+    const stdout = this.execStream("log", "--decorate", "--no-color", "--date-order", since && `--since=${since instanceof Date ? since.toISOString() : since}`, [from, to].filter(Boolean).join(".."), ...path11 ? ["--", ...toArray(path11)] : []);
+    let chunk;
+    let matches;
+    let tag;
+    for await (chunk of stdout) {
+      matches = chunk.toString().trim().matchAll(tagRegex);
+      for ([, tag] of matches) {
+        yield tag;
+      }
+    }
+  }
+  /**
+   * Get last tag.
+   * @param params
+   * @returns Last tag, `null` if not found.
+   */
+  async getLastTag(params) {
+    return firstFromStream(this.getTags(params));
+  }
+  /**
+   * Check file is ignored via .gitignore.
+   * @param file - Path to target file.
+   * @returns Boolean value.
+   */
+  async checkIgnore(file) {
+    try {
+      await this.exec("check-ignore", "--", file);
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+  /**
+   * Add files to git index.
+   * @param files - Files to stage.
+   */
+  async add(files) {
+    await this.exec("add", "--", ...toArray(files));
+  }
+  /**
+   * Commit changes.
+   * @param params
+   * @param params.verify
+   * @param params.sign
+   * @param params.files
+   * @param params.allowEmpty
+   * @param params.message
+   */
+  async commit(params) {
+    const { verify = true, sign = false, files = [], allowEmpty = false, message } = params;
+    await this.exec("commit", !verify && "--no-verify", sign && "-S", allowEmpty && "--allow-empty", "-m", message, "--", ...files);
+  }
+  /**
+   * Create a tag for the current commit.
+   * @param params
+   * @param params.sign
+   * @param params.name
+   * @param params.message
+   */
+  async tag(params) {
+    let { sign = false, name, message } = params;
+    if (sign) {
+      message = "";
+    }
+    await this.exec("tag", sign && "-s", message && "-a", ...message ? ["-m", message] : [], "--", name);
+  }
+  /**
+   * Get current branch name.
+   * @returns Current branch name.
+   */
+  async getCurrentBranch() {
+    const branch = await this.exec("rev-parse", "--abbrev-ref", "HEAD");
+    return branch;
+  }
+  /**
+   * Get default branch name.
+   * @returns Default branch name.
+   */
+  async getDefaultBranch() {
+    const branch = (await this.exec("rev-parse", "--abbrev-ref", "origin/HEAD")).replace(/^origin\//, "");
+    return branch;
+  }
+  /**
+   * Push changes to remote.
+   * @param branch
+   * @param params
+   * @param params.verify
+   */
+  async push(branch, params = {}) {
+    const { verify = true, tags = false, followTags = false, force = false } = params;
+    await this.exec("push", followTags && "--follow-tags", tags && "--tags", !verify && "--no-verify", force && "--force", "origin", "--", branch);
+  }
+  /**
+   * Verify rev exists.
+   * @param rev
+   * @param safe - If `true`, will not throw error if rev not found.
+   * @returns Target hash.
+   */
+  async verify(rev, safe) {
+    let git = this.exec("rev-parse", "--verify", rev);
+    if (safe) {
+      git = git.catch(() => "");
+    }
+    return await git;
+  }
+  /**
+   * Get config value by key.
+   * @param key - Config key.
+   * @returns Config value.
+   */
+  async getConfig(key) {
+    return await this.exec("config", "--get", "--", key);
+  }
+  /**
+   * Set config value by key.
+   * @param key - Config key.
+   * @param value - Config value.
+   */
+  async setConfig(key, value) {
+    await this.exec("config", "--", key, value);
+  }
+  /**
+   * Fetch changes from remote.
+   * @param params
+   */
+  async fetch(params = {}) {
+    const { prune = false, unshallow = false, tags = false, all = false, remote, branch } = params;
+    await this.exec("fetch", prune && "--prune", unshallow && "--unshallow", tags && "--tags", all && "--all", ...remote && branch ? [
+      "--",
+      remote,
+      branch
+    ] : []);
+  }
+  /**
+   * Create a new branch.
+   * @param branch - Branch name.
+   */
+  async createBranch(branch) {
+    await this.exec("checkout", "-b", branch);
+  }
+  /**
+   * Delete a branch.
+   * @param branch - Branch name.
+   */
+  async deleteBranch(branch) {
+    await this.exec("branch", "-D", "--", branch);
+  }
+  /**
+   * Checkout a branch.
+   * @param branch - Branch name.
+   */
+  async checkout(branch) {
+    await this.exec("checkout", branch);
+  }
+};
+
+// ../../node_modules/.pnpm/@conventional-changelog+git-client@2.5.1_conventional-commits-filter@5.0.0_conventional-commits-parser@6.2.1/node_modules/@conventional-changelog/git-client/dist/ConventionalGitClient.js
+import semver from "semver";
+var ConventionalGitClient = class extends GitClient {
+  deps = null;
+  loadDeps() {
+    if (this.deps) {
+      return this.deps;
+    }
+    this.deps = Promise.all([
+      import("./dist-3B6ZXCEH.js").then(({ parseCommits }) => parseCommits),
+      import("./dist-XFQOB6BJ.js").then(({ filterRevertedCommits }) => filterRevertedCommits)
+    ]);
+    return this.deps;
+  }
+  /**
+   * Get parsed commits stream.
+   * @param params
+   * @param params.path - Read commits from specific path.
+   * @param params.from - Start commits range.
+   * @param params.to - End commits range.
+   * @param params.format - Commits format.
+   * @param parserOptions - Commit parser options.
+   * @yields Raw commits data.
+   */
+  async *getCommits(params = {}, parserOptions = {}) {
+    const { filterReverts, ...gitLogParams } = params;
+    const [parseCommits, filterRevertedCommits] = await this.loadDeps();
+    if (filterReverts) {
+      yield* filterRevertedCommits(this.getCommits(gitLogParams, parserOptions));
+      return;
+    }
+    const parse2 = parseCommits(parserOptions);
+    const commitsStream = this.getRawCommits(gitLogParams);
+    yield* parse2(commitsStream);
+  }
+  /**
+   * Get semver tags stream.
+   * @param params
+   * @param params.prefix - Get semver tags with specific prefix.
+   * @param params.skipUnstable - Skip semver tags with unstable versions.
+   * @param params.clean - Clean version from prefix and trash.
+   * @yields Semver tags.
+   */
+  async *getSemverTags(params = {}) {
+    const { prefix, skipUnstable, clean } = params;
+    const tagsStream = this.getTags();
+    const unstableTagRegex = /\d+\.\d+\.\d+-.+/;
+    const cleanTag = clean ? (tag2, unprefixed2) => semver.clean(unprefixed2 || tag2) : (tag2) => tag2;
+    let unprefixed;
+    let tag;
+    for await (tag of tagsStream) {
+      if (skipUnstable && unstableTagRegex.test(tag)) {
+        continue;
+      }
+      if (prefix) {
+        const isPrefixed = typeof prefix === "string" ? tag.startsWith(prefix) : prefix.test(tag);
+        if (isPrefixed) {
+          unprefixed = tag.replace(prefix, "");
+          if (semver.valid(unprefixed)) {
+            tag = cleanTag(tag, unprefixed);
+            if (tag) {
+              yield tag;
+            }
+          }
+        }
+      } else if (semver.valid(tag)) {
+        tag = cleanTag(tag);
+        if (tag) {
+          yield tag;
+        }
+      }
+    }
+  }
+  /**
+   * Get last semver tag.
+   * @param params - getSemverTags params.
+   * @returns Last semver tag, `null` if not found.
+   */
+  async getLastSemverTag(params = {}) {
+    return firstFromStream(this.getSemverTags(params));
+  }
+  /**
+   * Get current sematic version from git tags.
+   * @param params - Additional git params.
+   * @returns Current sematic version, `null` if not found.
+   */
+  async getVersionFromTags(params = {}) {
+    const semverTagsStream = this.getSemverTags({
+      clean: true,
+      ...params
+    });
+    const semverTags = [];
+    for await (const tag of semverTagsStream) {
+      semverTags.push(tag);
+    }
+    if (!semverTags.length) {
+      return null;
+    }
+    return semverTags.sort(semver.rcompare)[0] || null;
+  }
+};
+
+// ../../node_modules/.pnpm/conventional-changelog-preset-loader@5.0.0/node_modules/conventional-changelog-preset-loader/dist/presetLoader.js
+import path4 from "path";
+function resolvePresetNameVariants(preset) {
+  if (path4.isAbsolute(preset)) {
+    return [preset];
+  }
+  let scope = "";
+  let name = preset.toLocaleLowerCase();
+  if (preset.startsWith("@")) {
+    const parts = preset.split("/");
+    scope = `${parts.shift()}/`;
+    if (scope === "@conventional-changelog/") {
+      return [preset];
+    }
+    name = parts.join("/");
+  }
+  if (!name.startsWith("conventional-changelog-")) {
+    name = `conventional-changelog-${name}`;
+  }
+  const altPreset = `${scope}${name}`;
+  if (altPreset !== preset) {
+    return [altPreset, preset];
+  }
+  return [preset];
+}
+function getModuleDefaultExport(module) {
+  if (("__esModule" in module || Object.getPrototypeOf(module) === null) && "default" in module) {
+    return module.default;
+  }
+  return module;
+}
+async function loadWithFallbacks(moduleLoader, variants) {
+  let error = null;
+  for (const variant of variants) {
+    try {
+      return getModuleDefaultExport(await moduleLoader(variant));
+    } catch (err) {
+      if (!error) {
+        error = err;
+      }
+    }
+  }
+  throw error;
+}
+function createPresetLoader(moduleLoader) {
+  return async function loadPreset2(presetOrParams) {
+    let preset = "";
+    let params = null;
+    if (typeof presetOrParams === "string") {
+      preset = presetOrParams;
+    } else if (typeof presetOrParams === "object" && typeof presetOrParams.name === "string") {
+      preset = presetOrParams.name;
+      params = presetOrParams;
+    } else {
+      throw Error("Preset must be string or object with property `name`");
+    }
+    const presetNameVariants = resolvePresetNameVariants(preset);
+    let createPreset = null;
+    try {
+      createPreset = await loadWithFallbacks(moduleLoader, presetNameVariants);
+    } catch (err) {
+      throw new Error(`Unable to load the "${preset}" preset. Please make sure it's installed.`, {
+        cause: err
+      });
+    }
+    if (typeof createPreset !== "function") {
+      throw new Error(`The "${preset}" preset does not export a function. Maybe you are using an old version of the preset. Please upgrade.`);
+    }
+    return params ? await createPreset(params) : await createPreset();
+  };
+}
+var loadPreset = createPresetLoader((preset) => import(preset));
+
+// ../../node_modules/.pnpm/conventional-recommended-bump@11.2.0/node_modules/conventional-recommended-bump/dist/utils.js
+function isIterable(value) {
+  return value !== null && (typeof value[Symbol.iterator] === "function" || typeof value[Symbol.asyncIterator] === "function");
+}
+function bindLogNamespace(namespace, logger) {
+  return (messages) => logger(namespace, messages);
+}
+
+// ../../node_modules/.pnpm/conventional-recommended-bump@11.2.0/node_modules/conventional-recommended-bump/dist/bumper.js
+var VERSIONS = [
+  "major",
+  "minor",
+  "patch"
+];
+var Bumper = class {
+  gitClient;
+  params;
+  whatBump;
+  tagGetter;
+  commitsGetter;
+  constructor(cwdOrGitClient = process.cwd()) {
+    this.gitClient = typeof cwdOrGitClient === "string" ? new ConventionalGitClient(cwdOrGitClient) : cwdOrGitClient;
+    this.whatBump = null;
+    this.params = Promise.resolve({
+      commits: {
+        format: "%B%n-hash-%n%H",
+        filterReverts: true
+      }
+    });
+    this.tagGetter = () => this.getLastSemverTag();
+    this.commitsGetter = () => this.getCommits();
+  }
+  composeParams(params) {
+    this.params = Promise.all([params, this.params]).then(([params2, prevParams]) => ({
+      options: {
+        ...prevParams.options,
+        ...params2.options
+      },
+      tags: {
+        ...prevParams.tags,
+        ...params2.tags
+      },
+      commits: {
+        ...prevParams.commits,
+        ...params2.commits
+      },
+      parser: {
+        ...prevParams.parser,
+        ...params2.parser
+      }
+    }));
+  }
+  async getLastSemverTag() {
+    const { tags } = await this.params;
+    return await this.gitClient.getLastSemverTag(tags);
+  }
+  async *getCommits() {
+    const { options, commits, parser } = await this.params;
+    const parserParams = {
+      ...parser
+    };
+    if (!parserParams.warn && options?.warn) {
+      parserParams.warn = bindLogNamespace("parser", options.warn);
+    }
+    yield* this.gitClient.getCommits({
+      from: await this.tagGetter() || "",
+      ...commits
+    }, parserParams);
+  }
+  /**
+   * Load configs from a preset
+   * @param preset
+   * @param loader - Preset module loader, if not provided, will use default loader
+   * @returns this
+   */
+  loadPreset(preset, loader) {
+    const loadPreset2 = loader ? createPresetLoader(loader) : loadPreset;
+    const config = loadPreset2(preset).then((config2) => {
+      if (!config2) {
+        throw Error("Preset is not loaded or have incorrect exports");
+      }
+      return config2;
+    });
+    this.whatBump = async (commits) => {
+      const { whatBump } = await config;
+      return whatBump(commits);
+    };
+    this.composeParams(config);
+    return this;
+  }
+  /**
+   * Set config directly
+   * @param config - Config object
+   * @returns this
+   */
+  config(config) {
+    this.composeParams(config);
+    return this;
+  }
+  /**
+   * Set bumper options
+   * @param options - Bumper options
+   * @returns this
+   */
+  options(options) {
+    this.composeParams({
+      options
+    });
+    return this;
+  }
+  /**
+   * Set params to get the last semver tag
+   * @param paramsOrTag - Params to get the last semver tag or a tag name
+   * @returns this
+   */
+  tag(paramsOrTag) {
+    if (typeof paramsOrTag === "string") {
+      this.tagGetter = () => paramsOrTag;
+    } else {
+      this.tagGetter = () => this.getLastSemverTag();
+      this.composeParams({
+        tags: paramsOrTag
+      });
+    }
+    return this;
+  }
+  commits(paramsOrCommits, parserOptions) {
+    if (isIterable(paramsOrCommits)) {
+      this.commitsGetter = () => paramsOrCommits;
+    } else {
+      this.commitsGetter = () => this.getCommits();
+      this.composeParams({
+        commits: paramsOrCommits,
+        parser: parserOptions
+      });
+    }
+    return this;
+  }
+  /**
+   * Recommend a bump by `whatBump` function
+   * @param whatBump - Function to recommend a bump from commits
+   * @returns Bump recommendation
+   */
+  async bump(whatBump = this.whatBump) {
+    if (typeof whatBump !== "function") {
+      throw Error("`whatBump` must be a function");
+    }
+    const { gitClient } = this;
+    const { options } = await this.params;
+    if (!gitClient.debug && options?.debug) {
+      gitClient.debug = bindLogNamespace("git-client", options.debug);
+    }
+    const commitsStream = this.commitsGetter();
+    const commits = [];
+    let commit;
+    for await (commit of commitsStream) {
+      commits.push(commit);
+    }
+    const result = await whatBump(commits);
+    if (result && "level" in result) {
+      return {
+        ...result,
+        releaseType: VERSIONS[result.level],
+        commits
+      };
+    }
+    return {
+      commits
+    };
+  }
+};
+
+// src/core/versionCalculator.ts
+import semver4 from "semver";
 
 // src/git/repository.ts
 import { existsSync as existsSync3, statSync } from "fs";
@@ -595,7 +1273,7 @@ function getCurrentBranch() {
 
 // src/git/tagsAndBranches.ts
 import { getSemverTags } from "git-semver-tags";
-import semver from "semver";
+import semver2 from "semver";
 
 // src/utils/logging.ts
 import chalk from "chalk";
@@ -713,9 +1391,9 @@ async function getLatestTag(versionPrefix) {
     }
     const chronologicalLatest = tags[0];
     const sortedTags = [...tags].sort((a, b) => {
-      const versionA = semver.clean(a) || "0.0.0";
-      const versionB = semver.clean(b) || "0.0.0";
-      return semver.rcompare(versionA, versionB);
+      const versionA = semver2.clean(a) || "0.0.0";
+      const versionB = semver2.clean(b) || "0.0.0";
+      return semver2.rcompare(versionA, versionB);
     });
     const semanticLatest = sortedTags[0];
     if (semanticLatest !== chronologicalLatest) {
@@ -807,11 +1485,11 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
 
 // src/utils/manifestHelpers.ts
 import fs6 from "fs";
-import path5 from "path";
+import path6 from "path";
 
 // src/cargo/cargoHandler.ts
 import fs5 from "fs";
-import path4 from "path";
+import path5 from "path";
 import * as TOML2 from "smol-toml";
 function getCargoInfo(cargoPath) {
   if (!fs5.existsSync(cargoPath)) {
@@ -828,7 +1506,7 @@ function getCargoInfo(cargoPath) {
       name: cargo.package.name,
       version: cargo.package.version || "0.0.0",
       path: cargoPath,
-      dir: path4.dirname(cargoPath),
+      dir: path5.dirname(cargoPath),
       content: cargo
     };
   } catch (error) {
@@ -871,8 +1549,8 @@ function updateCargoVersion(cargoPath, version, dryRun = false) {
 
 // src/utils/manifestHelpers.ts
 function getVersionFromManifests(packageDir) {
-  const packageJsonPath = path5.join(packageDir, "package.json");
-  const cargoTomlPath = path5.join(packageDir, "Cargo.toml");
+  const packageJsonPath = path6.join(packageDir, "package.json");
+  const cargoTomlPath = path6.join(packageDir, "Cargo.toml");
   if (fs6.existsSync(packageJsonPath)) {
     try {
       const packageJson = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
@@ -919,7 +1597,7 @@ function getVersionFromManifests(packageDir) {
 
 // src/utils/versionUtils.ts
 import fs7 from "fs";
-import semver2 from "semver";
+import semver3 from "semver";
 
 // src/git/tagVerification.ts
 function verifyTag(tagName, cwd3) {
@@ -961,33 +1639,33 @@ function normalizePrereleaseIdentifier(prereleaseIdentifier, config) {
   return void 0;
 }
 function bumpVersion(currentVersion, bumpType, prereleaseIdentifier) {
-  if (prereleaseIdentifier && STANDARD_BUMP_TYPES.includes(bumpType) && !semver2.prerelease(currentVersion)) {
+  if (prereleaseIdentifier && STANDARD_BUMP_TYPES.includes(bumpType) && !semver3.prerelease(currentVersion)) {
     const preBumpType = `pre${bumpType}`;
     log(`Creating prerelease version with identifier '${prereleaseIdentifier}' using ${preBumpType}`, "debug");
-    return semver2.inc(currentVersion, preBumpType, prereleaseIdentifier) || "";
+    return semver3.inc(currentVersion, preBumpType, prereleaseIdentifier) || "";
   }
-  if (semver2.prerelease(currentVersion) && STANDARD_BUMP_TYPES.includes(bumpType)) {
-    const parsed = semver2.parse(currentVersion);
+  if (semver3.prerelease(currentVersion) && STANDARD_BUMP_TYPES.includes(bumpType)) {
+    const parsed = semver3.parse(currentVersion);
     if (!parsed) {
-      return semver2.inc(currentVersion, bumpType) || "";
+      return semver3.inc(currentVersion, bumpType) || "";
     }
     if (bumpType === "major" && parsed.minor === 0 && parsed.patch === 0 || bumpType === "minor" && parsed.patch === 0 || bumpType === "patch") {
       log(`Cleaning prerelease identifier from ${currentVersion} for ${bumpType} bump`, "debug");
       return `${parsed.major}.${parsed.minor}.${parsed.patch}`;
     }
     log(`Standard increment for ${currentVersion} with ${bumpType} bump`, "debug");
-    return semver2.inc(currentVersion, bumpType) || "";
+    return semver3.inc(currentVersion, bumpType) || "";
   }
   if (prereleaseIdentifier) {
-    return semver2.inc(currentVersion, bumpType, prereleaseIdentifier) || "";
+    return semver3.inc(currentVersion, bumpType, prereleaseIdentifier) || "";
   }
-  return semver2.inc(currentVersion, bumpType) || "";
+  return semver3.inc(currentVersion, bumpType) || "";
 }
 function detectVersionMismatch(tagVersion, packageVersion) {
-  const tagIsPrerelease = semver2.prerelease(tagVersion) !== null;
-  const packageIsPrerelease = semver2.prerelease(packageVersion) !== null;
-  const tagParsed = semver2.parse(tagVersion);
-  const packageParsed = semver2.parse(packageVersion);
+  const tagIsPrerelease = semver3.prerelease(tagVersion) !== null;
+  const packageIsPrerelease = semver3.prerelease(packageVersion) !== null;
+  const tagParsed = semver3.parse(tagVersion);
+  const packageParsed = semver3.parse(packageVersion);
   if (!tagParsed || !packageParsed) {
     return { isMismatch: false, severity: "minor", message: "" };
   }
@@ -998,9 +1676,9 @@ function detectVersionMismatch(tagVersion, packageVersion) {
       message: `Git tag ${tagVersion} (stable) is ahead of package ${packageVersion} (prerelease). This may indicate a reverted release. Consider deleting tag ${tagVersion} or updating package.json.`
     };
   }
-  const tagHigher = semver2.gt(tagVersion, packageVersion);
+  const tagHigher = semver3.gt(tagVersion, packageVersion);
   if (tagHigher) {
-    const diff = semver2.diff(packageVersion, tagVersion);
+    const diff = semver3.diff(packageVersion, tagVersion);
     if (diff === "major" || diff === "minor") {
       return {
         isMismatch: true,
@@ -1099,7 +1777,7 @@ To resolve: delete the conflicting tag, update package.json, or change mismatchS
           };
       }
     }
-    if (semver2.gt(cleanPackageVersion, cleanTagVersion)) {
+    if (semver3.gt(cleanPackageVersion, cleanTagVersion)) {
       log(`Package version ${packageVersion} is newer than git tag ${tagName}, using package version`, "info");
       return {
         source: "package",
@@ -1108,7 +1786,7 @@ To resolve: delete the conflicting tag, update package.json, or change mismatchS
         mismatch: mismatchInfo
       };
     }
-    if (semver2.gt(cleanTagVersion, cleanPackageVersion)) {
+    if (semver3.gt(cleanTagVersion, cleanPackageVersion)) {
       log(`Git tag ${tagName} is newer than package version ${packageVersion}, using git tag`, "info");
       return {
         source: "git",
@@ -1169,12 +1847,12 @@ async function calculateVersion(config, options) {
         if (hasNoTags) {
           return initialVersion;
         }
-        const cleanedTag = semver3.clean(latestTag) || latestTag;
-        return semver3.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+        const cleanedTag = semver4.clean(latestTag) || latestTag;
+        return semver4.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
       }
       if (versionSource.source === "git") {
-        const cleanedTag = semver3.clean(versionSource.version) || versionSource.version;
-        return semver3.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+        const cleanedTag = semver4.clean(versionSource.version) || versionSource.version;
+        return semver4.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
       }
       return versionSource.version;
     };
@@ -1198,7 +1876,7 @@ async function calculateVersion(config, options) {
     const specifiedType = type;
     if (specifiedType) {
       const currentVersion = getCurrentVersionFromSource2();
-      const isCurrentPrerelease = semver3.prerelease(currentVersion);
+      const isCurrentPrerelease = semver4.prerelease(currentVersion);
       const explicitlyRequestedPrerelease = config.isPrerelease;
       if (STANDARD_BUMP_TYPES.includes(specifiedType) && (isCurrentPrerelease || explicitlyRequestedPrerelease)) {
         const prereleaseId2 = explicitlyRequestedPrerelease || isCurrentPrerelease ? normalizedPrereleaseId : void 0;
@@ -1294,7 +1972,7 @@ async function calculateVersion(config, options) {
 
 // src/package/packageProcessor.ts
 import * as fs9 from "fs";
-import path7 from "path";
+import path8 from "path";
 
 // src/changelog/commitParser.ts
 var CONVENTIONAL_COMMIT_REGEX = /^(\w+)(?:\(([^)]+)\))?(!)?: (.+)(?:\n\n([\s\S]*))?/;
@@ -1302,8 +1980,8 @@ var BREAKING_CHANGE_REGEX = /BREAKING CHANGE: ([\s\S]+?)(?:\n\n|$)/;
 function extractAllChangelogEntriesWithHash(projectDir, revisionRange) {
   try {
     const args = ["log", revisionRange, "--pretty=format:%H|||%B---COMMIT_DELIMITER---", "--no-merges"];
-    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
-    const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
+    const output2 = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
+    const commits = output2.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
     return commits.map((commit) => {
       const [hash, ...messageParts] = commit.split("|||");
       const message = messageParts.join("|||").trim();
@@ -1321,14 +1999,14 @@ function extractAllChangelogEntriesWithHash(projectDir, revisionRange) {
 }
 function commitTouchesAnyPackage(projectDir, commitHash, packageDirs, sharedPackageDirs = []) {
   try {
-    const output = execSync("git", ["diff-tree", "--no-commit-id", "--name-only", "-r", commitHash], {
+    const output2 = execSync("git", ["diff-tree", "--no-commit-id", "--name-only", "-r", commitHash], {
       cwd: projectDir,
       encoding: "utf8"
     }).toString().trim();
-    if (!output) {
+    if (!output2) {
       return false;
     }
-    const changedFiles = output.split("\n");
+    const changedFiles = output2.split("\n");
     return changedFiles.some((file) => {
       return packageDirs.some((pkgDir) => {
         if (sharedPackageDirs.some((sharedDir) => pkgDir.includes(sharedDir))) {
@@ -1375,8 +2053,8 @@ function extractCommitsFromGitLog(projectDir, revisionRange, filterToPath) {
     if (filterToPath) {
       args.push("--", ".");
     }
-    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
-    const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
+    const output2 = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
+    const commits = output2.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
     return commits.map((commit) => parseCommitMessage(commit)).filter((entry) => entry !== null);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -1499,7 +2177,7 @@ function shouldProcessPackage(packageName, skip = []) {
 
 // src/package/packageManagement.ts
 import fs8 from "fs";
-import path6 from "path";
+import path7 from "path";
 function updatePackageVersion(packagePath, version, dryRun = false) {
   if (isCargoToml(packagePath)) {
     updateCargoVersion(packagePath, version, dryRun);
@@ -1684,7 +2362,7 @@ var PackageProcessor = class {
       }
       let repoUrl;
       try {
-        const packageJsonPath2 = path7.join(pkgPath, "package.json");
+        const packageJsonPath2 = path8.join(pkgPath, "package.json");
         if (fs9.existsSync(packageJsonPath2)) {
           const packageJson = JSON.parse(fs9.readFileSync(packageJsonPath2, "utf8"));
           if (packageJson.repository) {
@@ -1712,7 +2390,7 @@ var PackageProcessor = class {
         repoUrl: repoUrl || null,
         entries: changelogEntries
       });
-      const packageJsonPath = path7.join(pkgPath, "package.json");
+      const packageJsonPath = path8.join(pkgPath, "package.json");
       if (fs9.existsSync(packageJsonPath)) {
         updatePackageVersion(packageJsonPath, nextVersion, this.dryRun);
       }
@@ -1723,7 +2401,7 @@ var PackageProcessor = class {
         log(`Cargo paths config for ${name}: ${JSON.stringify(cargoPaths)}`, "debug");
         if (cargoPaths && cargoPaths.length > 0) {
           for (const cargoPath of cargoPaths) {
-            const resolvedCargoPath = path7.resolve(pkgPath, cargoPath, "Cargo.toml");
+            const resolvedCargoPath = path8.resolve(pkgPath, cargoPath, "Cargo.toml");
             log(`Checking cargo path for ${name}: ${resolvedCargoPath}`, "debug");
             if (fs9.existsSync(resolvedCargoPath)) {
               log(`Found Cargo.toml for ${name} at ${resolvedCargoPath}, updating...`, "debug");
@@ -1733,7 +2411,7 @@ var PackageProcessor = class {
             }
           }
         } else {
-          const cargoTomlPath = path7.join(pkgPath, "Cargo.toml");
+          const cargoTomlPath = path8.join(pkgPath, "Cargo.toml");
           log(`Checking default cargo path for ${name}: ${cargoTomlPath}`, "debug");
           if (fs9.existsSync(cargoTomlPath)) {
             log(`Found Cargo.toml for ${name} at ${cargoTomlPath}, updating...`, "debug");
@@ -1802,7 +2480,7 @@ var PackageProcessor = class {
 
 // src/core/versionStrategies.ts
 import fs10 from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
 function shouldProcessPackage2(pkg, config) {
   const pkgName = pkg.packageJson.name;
   return shouldProcessPackage(pkgName, config.skip);
@@ -1816,14 +2494,14 @@ function updateCargoFiles(packageDir, version, cargoConfig, dryRun = false) {
   const cargoPaths = cargoConfig?.paths;
   if (cargoPaths && cargoPaths.length > 0) {
     for (const cargoPath of cargoPaths) {
-      const resolvedCargoPath = path8.resolve(packageDir, cargoPath, "Cargo.toml");
+      const resolvedCargoPath = path9.resolve(packageDir, cargoPath, "Cargo.toml");
       if (fs10.existsSync(resolvedCargoPath)) {
         updatePackageVersion(resolvedCargoPath, version, dryRun);
         updatedFiles.push(resolvedCargoPath);
       }
     }
   } else {
-    const cargoTomlPath = path8.join(packageDir, "Cargo.toml");
+    const cargoTomlPath = path9.join(packageDir, "Cargo.toml");
     if (fs10.existsSync(cargoTomlPath)) {
       updatePackageVersion(cargoTomlPath, version, dryRun);
       updatedFiles.push(cargoTomlPath);
@@ -1904,7 +2582,7 @@ function createSyncStrategy(config) {
       const processedPaths = /* @__PURE__ */ new Set();
       try {
         if (packages.root) {
-          const rootPkgPath = path8.join(packages.root, "package.json");
+          const rootPkgPath = path9.join(packages.root, "package.json");
           if (fs10.existsSync(rootPkgPath)) {
             updatePackageVersion(rootPkgPath, nextVersion, dryRun);
             files.push(rootPkgPath);
@@ -1924,7 +2602,7 @@ function createSyncStrategy(config) {
         if (!shouldProcessPackage2(pkg, config)) {
           continue;
         }
-        const packageJsonPath = path8.join(pkg.dir, "package.json");
+        const packageJsonPath = path9.join(pkg.dir, "package.json");
         if (processedPaths.has(packageJsonPath)) {
           continue;
         }
@@ -1983,7 +2661,7 @@ function createSyncStrategy(config) {
       let repoUrl = null;
       for (const searchPath of [mainPkgPath, versionSourcePath].filter(Boolean)) {
         try {
-          const pkgJsonPath = path8.join(searchPath, "package.json");
+          const pkgJsonPath = path9.join(searchPath, "package.json");
           if (fs10.existsSync(pkgJsonPath)) {
             const pkgJson = JSON.parse(fs10.readFileSync(pkgJsonPath, "utf8"));
             let url;
@@ -2152,7 +2830,7 @@ function createSingleStrategy(config) {
       }
       let repoUrl;
       try {
-        const packageJsonPath2 = path8.join(pkgPath, "package.json");
+        const packageJsonPath2 = path9.join(pkgPath, "package.json");
         if (fs10.existsSync(packageJsonPath2)) {
           const packageJson = JSON.parse(fs10.readFileSync(packageJsonPath2, "utf8"));
           if (packageJson.repository) {
@@ -2180,7 +2858,7 @@ function createSingleStrategy(config) {
         repoUrl: repoUrl || null,
         entries: changelogEntries
       });
-      const packageJsonPath = path8.join(pkgPath, "package.json");
+      const packageJsonPath = path9.join(pkgPath, "package.json");
       updatePackageVersion(packageJsonPath, nextVersion, dryRun);
       const filesToCommit = [packageJsonPath];
       const cargoFiles = updateCargoFiles(pkgPath, nextVersion, config.cargo, dryRun);
@@ -2286,7 +2964,7 @@ var GitError = class extends BaseVersionError {
 };
 
 // src/utils/packageFiltering.ts
-import path9 from "path";
+import path10 from "path";
 import { minimatch as minimatch2 } from "minimatch";
 function filterPackagesByConfig(packages, configTargets, workspaceRoot) {
   if (configTargets.length === 0) {
@@ -2312,7 +2990,7 @@ function filterByDirectoryPattern(packages, pattern, workspaceRoot) {
   }
   const normalizedPattern = pattern.replace(/\\/g, "/");
   return packages.filter((pkg) => {
-    const relativePath = path9.relative(workspaceRoot, pkg.dir);
+    const relativePath = path10.relative(workspaceRoot, pkg.dir);
     const normalizedRelativePath = relativePath.replace(/\\/g, "/");
     if (normalizedPattern === normalizedRelativePath) {
       return true;