@releasekit/version 0.7.45 → 0.7.47

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

@@ -531,14 +531,14 @@ function enableJsonOutput(dryRun = false) {
   _jsonData.commitMessage = void 0;
   _pendingWrites.length = 0;
 }
-function recordPendingWrite(path11, content) {
+function recordPendingWrite(path10, content) {
   if (!_jsonOutputMode) return;
-  _pendingWrites.push({ path: path11, content });
+  _pendingWrites.push({ path: path10, content });
 }
 function flushPendingWrites() {
   try {
-    for (const { path: path11, content } of _pendingWrites) {
-      fs4.writeFileSync(path11, content);
+    for (const { path: path10, content } of _pendingWrites) {
+      fs4.writeFileSync(path10, content);
     }
   } finally {
     _pendingWrites.length = 0;
@@ -582,686 +582,8 @@ function printJsonOutput() {
 
 // src/core/versionCalculator.ts
 import { cwd } from "process";
-
-// ../../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";
+import { Bumper } from "conventional-recommended-bump";
+import semver3 from "semver";
 
 // src/git/repository.ts
 import { existsSync as existsSync3, statSync } from "fs";
@@ -1273,7 +595,7 @@ function getCurrentBranch() {
 
 // src/git/tagsAndBranches.ts
 import { getSemverTags } from "git-semver-tags";
-import semver2 from "semver";
+import semver from "semver";
 
 // src/utils/logging.ts
 import chalk from "chalk";
@@ -1391,9 +713,9 @@ async function getLatestTag(versionPrefix) {
     }
     const chronologicalLatest = tags[0];
     const sortedTags = [...tags].sort((a, b) => {
-      const versionA = semver2.clean(a) || "0.0.0";
-      const versionB = semver2.clean(b) || "0.0.0";
-      return semver2.rcompare(versionA, versionB);
+      const versionA = semver.clean(a) || "0.0.0";
+      const versionB = semver.clean(b) || "0.0.0";
+      return semver.rcompare(versionA, versionB);
     });
     const semanticLatest = sortedTags[0];
     if (semanticLatest !== chronologicalLatest) {
@@ -1485,11 +807,11 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
 
 // src/utils/manifestHelpers.ts
 import fs6 from "fs";
-import path6 from "path";
+import path5 from "path";
 
 // src/cargo/cargoHandler.ts
 import fs5 from "fs";
-import path5 from "path";
+import path4 from "path";
 import * as TOML2 from "smol-toml";
 function getCargoInfo(cargoPath) {
   if (!fs5.existsSync(cargoPath)) {
@@ -1506,7 +828,7 @@ function getCargoInfo(cargoPath) {
       name: cargo.package.name,
       version: cargo.package.version || "0.0.0",
       path: cargoPath,
-      dir: path5.dirname(cargoPath),
+      dir: path4.dirname(cargoPath),
       content: cargo
     };
   } catch (error) {
@@ -1549,8 +871,8 @@ function updateCargoVersion(cargoPath, version, dryRun = false) {
 
 // src/utils/manifestHelpers.ts
 function getVersionFromManifests(packageDir) {
-  const packageJsonPath = path6.join(packageDir, "package.json");
-  const cargoTomlPath = path6.join(packageDir, "Cargo.toml");
+  const packageJsonPath = path5.join(packageDir, "package.json");
+  const cargoTomlPath = path5.join(packageDir, "Cargo.toml");
   if (fs6.existsSync(packageJsonPath)) {
     try {
       const packageJson = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
@@ -1597,7 +919,7 @@ function getVersionFromManifests(packageDir) {
 
 // src/utils/versionUtils.ts
 import fs7 from "fs";
-import semver3 from "semver";
+import semver2 from "semver";
 
 // src/git/tagVerification.ts
 function verifyTag(tagName, cwd3) {
@@ -1639,33 +961,33 @@ function normalizePrereleaseIdentifier(prereleaseIdentifier, config) {
   return void 0;
 }
 function bumpVersion(currentVersion, bumpType, prereleaseIdentifier) {
-  if (prereleaseIdentifier && STANDARD_BUMP_TYPES.includes(bumpType) && !semver3.prerelease(currentVersion)) {
+  if (prereleaseIdentifier && STANDARD_BUMP_TYPES.includes(bumpType) && !semver2.prerelease(currentVersion)) {
     const preBumpType = `pre${bumpType}`;
     log(`Creating prerelease version with identifier '${prereleaseIdentifier}' using ${preBumpType}`, "debug");
-    return semver3.inc(currentVersion, preBumpType, prereleaseIdentifier) || "";
+    return semver2.inc(currentVersion, preBumpType, prereleaseIdentifier) || "";
   }
-  if (semver3.prerelease(currentVersion) && STANDARD_BUMP_TYPES.includes(bumpType)) {
-    const parsed = semver3.parse(currentVersion);
+  if (semver2.prerelease(currentVersion) && STANDARD_BUMP_TYPES.includes(bumpType)) {
+    const parsed = semver2.parse(currentVersion);
     if (!parsed) {
-      return semver3.inc(currentVersion, bumpType) || "";
+      return semver2.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 semver3.inc(currentVersion, bumpType) || "";
+    return semver2.inc(currentVersion, bumpType) || "";
   }
   if (prereleaseIdentifier) {
-    return semver3.inc(currentVersion, bumpType, prereleaseIdentifier) || "";
+    return semver2.inc(currentVersion, bumpType, prereleaseIdentifier) || "";
   }
-  return semver3.inc(currentVersion, bumpType) || "";
+  return semver2.inc(currentVersion, bumpType) || "";
 }
 function detectVersionMismatch(tagVersion, packageVersion) {
-  const tagIsPrerelease = semver3.prerelease(tagVersion) !== null;
-  const packageIsPrerelease = semver3.prerelease(packageVersion) !== null;
-  const tagParsed = semver3.parse(tagVersion);
-  const packageParsed = semver3.parse(packageVersion);
+  const tagIsPrerelease = semver2.prerelease(tagVersion) !== null;
+  const packageIsPrerelease = semver2.prerelease(packageVersion) !== null;
+  const tagParsed = semver2.parse(tagVersion);
+  const packageParsed = semver2.parse(packageVersion);
   if (!tagParsed || !packageParsed) {
     return { isMismatch: false, severity: "minor", message: "" };
   }
@@ -1676,9 +998,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 = semver3.gt(tagVersion, packageVersion);
+  const tagHigher = semver2.gt(tagVersion, packageVersion);
   if (tagHigher) {
-    const diff = semver3.diff(packageVersion, tagVersion);
+    const diff = semver2.diff(packageVersion, tagVersion);
     if (diff === "major" || diff === "minor") {
       return {
         isMismatch: true,
@@ -1777,7 +1099,7 @@ To resolve: delete the conflicting tag, update package.json, or change mismatchS
           };
       }
     }
-    if (semver3.gt(cleanPackageVersion, cleanTagVersion)) {
+    if (semver2.gt(cleanPackageVersion, cleanTagVersion)) {
       log(`Package version ${packageVersion} is newer than git tag ${tagName}, using package version`, "info");
       return {
         source: "package",
@@ -1786,7 +1108,7 @@ To resolve: delete the conflicting tag, update package.json, or change mismatchS
         mismatch: mismatchInfo
       };
     }
-    if (semver3.gt(cleanTagVersion, cleanPackageVersion)) {
+    if (semver2.gt(cleanTagVersion, cleanPackageVersion)) {
       log(`Git tag ${tagName} is newer than package version ${packageVersion}, using git tag`, "info");
       return {
         source: "git",
@@ -1847,12 +1169,12 @@ async function calculateVersion(config, options) {
         if (hasNoTags) {
           return initialVersion;
         }
-        const cleanedTag = semver4.clean(latestTag) || latestTag;
-        return semver4.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+        const cleanedTag = semver3.clean(latestTag) || latestTag;
+        return semver3.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
       }
       if (versionSource.source === "git") {
-        const cleanedTag = semver4.clean(versionSource.version) || versionSource.version;
-        return semver4.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+        const cleanedTag = semver3.clean(versionSource.version) || versionSource.version;
+        return semver3.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
       }
       return versionSource.version;
     };
@@ -1876,7 +1198,7 @@ async function calculateVersion(config, options) {
     const specifiedType = type;
     if (specifiedType) {
       const currentVersion = getCurrentVersionFromSource2();
-      const isCurrentPrerelease = semver4.prerelease(currentVersion);
+      const isCurrentPrerelease = semver3.prerelease(currentVersion);
       const explicitlyRequestedPrerelease = config.isPrerelease;
       if (STANDARD_BUMP_TYPES.includes(specifiedType) && (isCurrentPrerelease || explicitlyRequestedPrerelease)) {
         const prereleaseId2 = explicitlyRequestedPrerelease || isCurrentPrerelease ? normalizedPrereleaseId : void 0;
@@ -1972,7 +1294,7 @@ async function calculateVersion(config, options) {
 
 // src/package/packageProcessor.ts
 import * as fs9 from "fs";
-import path8 from "path";
+import path7 from "path";
 
 // src/changelog/commitParser.ts
 var CONVENTIONAL_COMMIT_REGEX = /^(\w+)(?:\(([^)]+)\))?(!)?: (.+)(?:\n\n([\s\S]*))?/;
@@ -1980,8 +1302,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 output2 = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
-    const commits = output2.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
+    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
+    const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
     return commits.map((commit) => {
       const [hash, ...messageParts] = commit.split("|||");
       const message = messageParts.join("|||").trim();
@@ -1999,14 +1321,14 @@ function extractAllChangelogEntriesWithHash(projectDir, revisionRange) {
 }
 function commitTouchesAnyPackage(projectDir, commitHash, packageDirs, sharedPackageDirs = []) {
   try {
-    const output2 = execSync("git", ["diff-tree", "--no-commit-id", "--name-only", "-r", commitHash], {
+    const output = execSync("git", ["diff-tree", "--no-commit-id", "--name-only", "-r", commitHash], {
       cwd: projectDir,
       encoding: "utf8"
     }).toString().trim();
-    if (!output2) {
+    if (!output) {
       return false;
     }
-    const changedFiles = output2.split("\n");
+    const changedFiles = output.split("\n");
     return changedFiles.some((file) => {
       return packageDirs.some((pkgDir) => {
         if (sharedPackageDirs.some((sharedDir) => pkgDir.includes(sharedDir))) {
@@ -2053,8 +1375,8 @@ function extractCommitsFromGitLog(projectDir, revisionRange, filterToPath) {
     if (filterToPath) {
       args.push("--", ".");
     }
-    const output2 = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
-    const commits = output2.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
+    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
+    const commits = output.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);
@@ -2177,7 +1499,7 @@ function shouldProcessPackage(packageName, skip = []) {
 
 // src/package/packageManagement.ts
 import fs8 from "fs";
-import path7 from "path";
+import path6 from "path";
 function updatePackageVersion(packagePath, version, dryRun = false) {
   if (isCargoToml(packagePath)) {
     updateCargoVersion(packagePath, version, dryRun);
@@ -2362,7 +1684,7 @@ var PackageProcessor = class {
       }
       let repoUrl;
       try {
-        const packageJsonPath2 = path8.join(pkgPath, "package.json");
+        const packageJsonPath2 = path7.join(pkgPath, "package.json");
         if (fs9.existsSync(packageJsonPath2)) {
           const packageJson = JSON.parse(fs9.readFileSync(packageJsonPath2, "utf8"));
           if (packageJson.repository) {
@@ -2390,7 +1712,7 @@ var PackageProcessor = class {
         repoUrl: repoUrl || null,
         entries: changelogEntries
       });
-      const packageJsonPath = path8.join(pkgPath, "package.json");
+      const packageJsonPath = path7.join(pkgPath, "package.json");
       if (fs9.existsSync(packageJsonPath)) {
         updatePackageVersion(packageJsonPath, nextVersion, this.dryRun);
       }
@@ -2401,7 +1723,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 = path8.resolve(pkgPath, cargoPath, "Cargo.toml");
+            const resolvedCargoPath = path7.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");
@@ -2411,7 +1733,7 @@ var PackageProcessor = class {
             }
           }
         } else {
-          const cargoTomlPath = path8.join(pkgPath, "Cargo.toml");
+          const cargoTomlPath = path7.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");
@@ -2480,7 +1802,7 @@ var PackageProcessor = class {
 
 // src/core/versionStrategies.ts
 import fs10 from "fs";
-import * as path9 from "path";
+import * as path8 from "path";
 function shouldProcessPackage2(pkg, config) {
   const pkgName = pkg.packageJson.name;
   return shouldProcessPackage(pkgName, config.skip);
@@ -2494,14 +1816,14 @@ function updateCargoFiles(packageDir, version, cargoConfig, dryRun = false) {
   const cargoPaths = cargoConfig?.paths;
   if (cargoPaths && cargoPaths.length > 0) {
     for (const cargoPath of cargoPaths) {
-      const resolvedCargoPath = path9.resolve(packageDir, cargoPath, "Cargo.toml");
+      const resolvedCargoPath = path8.resolve(packageDir, cargoPath, "Cargo.toml");
       if (fs10.existsSync(resolvedCargoPath)) {
         updatePackageVersion(resolvedCargoPath, version, dryRun);
         updatedFiles.push(resolvedCargoPath);
       }
     }
   } else {
-    const cargoTomlPath = path9.join(packageDir, "Cargo.toml");
+    const cargoTomlPath = path8.join(packageDir, "Cargo.toml");
     if (fs10.existsSync(cargoTomlPath)) {
       updatePackageVersion(cargoTomlPath, version, dryRun);
       updatedFiles.push(cargoTomlPath);
@@ -2582,7 +1904,7 @@ function createSyncStrategy(config) {
       const processedPaths = /* @__PURE__ */ new Set();
       try {
         if (packages.root) {
-          const rootPkgPath = path9.join(packages.root, "package.json");
+          const rootPkgPath = path8.join(packages.root, "package.json");
           if (fs10.existsSync(rootPkgPath)) {
             updatePackageVersion(rootPkgPath, nextVersion, dryRun);
             files.push(rootPkgPath);
@@ -2602,7 +1924,7 @@ function createSyncStrategy(config) {
         if (!shouldProcessPackage2(pkg, config)) {
           continue;
         }
-        const packageJsonPath = path9.join(pkg.dir, "package.json");
+        const packageJsonPath = path8.join(pkg.dir, "package.json");
         if (processedPaths.has(packageJsonPath)) {
           continue;
         }
@@ -2661,7 +1983,7 @@ function createSyncStrategy(config) {
       let repoUrl = null;
       for (const searchPath of [mainPkgPath, versionSourcePath].filter(Boolean)) {
         try {
-          const pkgJsonPath = path9.join(searchPath, "package.json");
+          const pkgJsonPath = path8.join(searchPath, "package.json");
           if (fs10.existsSync(pkgJsonPath)) {
             const pkgJson = JSON.parse(fs10.readFileSync(pkgJsonPath, "utf8"));
             let url;
@@ -2830,7 +2152,7 @@ function createSingleStrategy(config) {
       }
       let repoUrl;
       try {
-        const packageJsonPath2 = path9.join(pkgPath, "package.json");
+        const packageJsonPath2 = path8.join(pkgPath, "package.json");
         if (fs10.existsSync(packageJsonPath2)) {
           const packageJson = JSON.parse(fs10.readFileSync(packageJsonPath2, "utf8"));
           if (packageJson.repository) {
@@ -2858,7 +2180,7 @@ function createSingleStrategy(config) {
         repoUrl: repoUrl || null,
         entries: changelogEntries
       });
-      const packageJsonPath = path9.join(pkgPath, "package.json");
+      const packageJsonPath = path8.join(pkgPath, "package.json");
       updatePackageVersion(packageJsonPath, nextVersion, dryRun);
       const filesToCommit = [packageJsonPath];
       const cargoFiles = updateCargoFiles(pkgPath, nextVersion, config.cargo, dryRun);
@@ -2964,7 +2286,7 @@ var GitError = class extends BaseVersionError {
 };
 
 // src/utils/packageFiltering.ts
-import path10 from "path";
+import path9 from "path";
 import { minimatch as minimatch2 } from "minimatch";
 function filterPackagesByConfig(packages, configTargets, workspaceRoot) {
   if (configTargets.length === 0) {
@@ -2990,7 +2312,7 @@ function filterByDirectoryPattern(packages, pattern, workspaceRoot) {
   }
   const normalizedPattern = pattern.replace(/\\/g, "/");
   return packages.filter((pkg) => {
-    const relativePath = path10.relative(workspaceRoot, pkg.dir);
+    const relativePath = path9.relative(workspaceRoot, pkg.dir);
     const normalizedRelativePath = relativePath.replace(/\\/g, "/");
     if (normalizedPattern === normalizedRelativePath) {
       return true;