@releasekit/release 0.7.16 → 0.7.18

package/dist/cli.js

@@ -40,8 +40,1430 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ANSI_BACKGROUND_OFFSET, wrapAnsi16, wrapAnsi256, wrapAnsi16m, styles, modifierNames, foregroundColorNames, backgroundColorNames, colorNames, ansiStyles, ansi_styles_default;
+var init_ansi_styles = __esm({
+  "../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js"() {
+    "use strict";
+    ANSI_BACKGROUND_OFFSET = 10;
+    wrapAnsi16 = (offset2 = 0) => (code) => `\x1B[${code + offset2}m`;
+    wrapAnsi256 = (offset2 = 0) => (code) => `\x1B[${38 + offset2};5;${code}m`;
+    wrapAnsi16m = (offset2 = 0) => (red, green, blue) => `\x1B[${38 + offset2};2;${red};${green};${blue}m`;
+    styles = {
+      modifier: {
+        reset: [0, 0],
+        // 21 isn't widely supported and 22 does the same thing
+        bold: [1, 22],
+        dim: [2, 22],
+        italic: [3, 23],
+        underline: [4, 24],
+        overline: [53, 55],
+        inverse: [7, 27],
+        hidden: [8, 28],
+        strikethrough: [9, 29]
+      },
+      color: {
+        black: [30, 39],
+        red: [31, 39],
+        green: [32, 39],
+        yellow: [33, 39],
+        blue: [34, 39],
+        magenta: [35, 39],
+        cyan: [36, 39],
+        white: [37, 39],
+        // Bright color
+        blackBright: [90, 39],
+        gray: [90, 39],
+        // Alias of `blackBright`
+        grey: [90, 39],
+        // Alias of `blackBright`
+        redBright: [91, 39],
+        greenBright: [92, 39],
+        yellowBright: [93, 39],
+        blueBright: [94, 39],
+        magentaBright: [95, 39],
+        cyanBright: [96, 39],
+        whiteBright: [97, 39]
+      },
+      bgColor: {
+        bgBlack: [40, 49],
+        bgRed: [41, 49],
+        bgGreen: [42, 49],
+        bgYellow: [43, 49],
+        bgBlue: [44, 49],
+        bgMagenta: [45, 49],
+        bgCyan: [46, 49],
+        bgWhite: [47, 49],
+        // Bright color
+        bgBlackBright: [100, 49],
+        bgGray: [100, 49],
+        // Alias of `bgBlackBright`
+        bgGrey: [100, 49],
+        // Alias of `bgBlackBright`
+        bgRedBright: [101, 49],
+        bgGreenBright: [102, 49],
+        bgYellowBright: [103, 49],
+        bgBlueBright: [104, 49],
+        bgMagentaBright: [105, 49],
+        bgCyanBright: [106, 49],
+        bgWhiteBright: [107, 49]
+      }
+    };
+    modifierNames = Object.keys(styles.modifier);
+    foregroundColorNames = Object.keys(styles.color);
+    backgroundColorNames = Object.keys(styles.bgColor);
+    colorNames = [...foregroundColorNames, ...backgroundColorNames];
+    ansiStyles = assembleStyles();
+    ansi_styles_default = ansiStyles;
+  }
+});
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
+import process2 from "process";
+import os from "os";
+import tty from "tty";
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2.platform === "win32") {
+    const osRelease = os.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var env, flagForceColor, supportsColor, supports_color_default;
+var init_supports_color = __esm({
+  "../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js"() {
+    "use strict";
+    ({ env } = process2);
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      flagForceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      flagForceColor = 1;
+    }
+    supportsColor = {
+      stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+      stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+    };
+    supports_color_default = supportsColor;
+  }
+});
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+var init_utilities = __esm({
+  "../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
+function createChalk(options) {
+  return chalkFactory(options);
+}
+var stdoutColor, stderrColor, GENERATOR, STYLER, IS_EMPTY, levelMapping, styles2, applyOptions, chalkFactory, getModelAnsi, usedModels, proto, createStyler, createBuilder, applyStyle, chalk, chalkStderr, source_default;
+var init_source = __esm({
+  "../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js"() {
+    "use strict";
+    init_ansi_styles();
+    init_supports_color();
+    init_utilities();
+    ({ stdout: stdoutColor, stderr: stderrColor } = supports_color_default);
+    GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
+    STYLER = /* @__PURE__ */ Symbol("STYLER");
+    IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
+    levelMapping = [
+      "ansi",
+      "ansi",
+      "ansi256",
+      "ansi16m"
+    ];
+    styles2 = /* @__PURE__ */ Object.create(null);
+    applyOptions = (object, options = {}) => {
+      if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+        throw new Error("The `level` option should be an integer from 0 to 3");
+      }
+      const colorLevel = stdoutColor ? stdoutColor.level : 0;
+      object.level = options.level === void 0 ? colorLevel : options.level;
+    };
+    chalkFactory = (options) => {
+      const chalk2 = (...strings) => strings.join(" ");
+      applyOptions(chalk2, options);
+      Object.setPrototypeOf(chalk2, createChalk.prototype);
+      return chalk2;
+    };
+    Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+    for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+      styles2[styleName] = {
+        get() {
+          const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+          Object.defineProperty(this, styleName, { value: builder });
+          return builder;
+        }
+      };
+    }
+    styles2.visible = {
+      get() {
+        const builder = createBuilder(this, this[STYLER], true);
+        Object.defineProperty(this, "visible", { value: builder });
+        return builder;
+      }
+    };
+    getModelAnsi = (model, level, type2, ...arguments_) => {
+      if (model === "rgb") {
+        if (level === "ansi16m") {
+          return ansi_styles_default[type2].ansi16m(...arguments_);
+        }
+        if (level === "ansi256") {
+          return ansi_styles_default[type2].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+        }
+        return ansi_styles_default[type2].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+      }
+      if (model === "hex") {
+        return getModelAnsi("rgb", level, type2, ...ansi_styles_default.hexToRgb(...arguments_));
+      }
+      return ansi_styles_default[type2][model](...arguments_);
+    };
+    usedModels = ["rgb", "hex", "ansi256"];
+    for (const model of usedModels) {
+      styles2[model] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+            return createBuilder(this, styler, this[IS_EMPTY]);
+          };
+        }
+      };
+      const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+      styles2[bgModel] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+            return createBuilder(this, styler, this[IS_EMPTY]);
+          };
+        }
+      };
+    }
+    proto = Object.defineProperties(() => {
+    }, {
+      ...styles2,
+      level: {
+        enumerable: true,
+        get() {
+          return this[GENERATOR].level;
+        },
+        set(level) {
+          this[GENERATOR].level = level;
+        }
+      }
+    });
+    createStyler = (open, close, parent) => {
+      let openAll;
+      let closeAll;
+      if (parent === void 0) {
+        openAll = open;
+        closeAll = close;
+      } else {
+        openAll = parent.openAll + open;
+        closeAll = close + parent.closeAll;
+      }
+      return {
+        open,
+        close,
+        openAll,
+        closeAll,
+        parent
+      };
+    };
+    createBuilder = (self, _styler, _isEmpty) => {
+      const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+      Object.setPrototypeOf(builder, proto);
+      builder[GENERATOR] = self;
+      builder[STYLER] = _styler;
+      builder[IS_EMPTY] = _isEmpty;
+      return builder;
+    };
+    applyStyle = (self, string) => {
+      if (self.level <= 0 || !string) {
+        return self[IS_EMPTY] ? "" : string;
+      }
+      let styler = self[STYLER];
+      if (styler === void 0) {
+        return string;
+      }
+      const { openAll, closeAll } = styler;
+      if (string.includes("\x1B")) {
+        while (styler !== void 0) {
+          string = stringReplaceAll(string, styler.close, styler.open);
+          styler = styler.parent;
+        }
+      }
+      const lfIndex = string.indexOf("\n");
+      if (lfIndex !== -1) {
+        string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+      }
+      return openAll + string + closeAll;
+    };
+    Object.defineProperties(createChalk.prototype, styles2);
+    chalk = createChalk();
+    chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+    source_default = chalk;
+  }
+});
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/error.js
+function getLineColFromPtr(string, ptr) {
+  let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+  return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+  let lines = string.split(/\r\n|\n|\r/g);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1; i <= line + 1; i++) {
+    let l = lines[i - 1];
+    if (!l)
+      continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += "\n";
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += "^\n";
+    }
+  }
+  return codeblock;
+}
+var TomlError;
+var init_error = __esm({
+  "../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/error.js"() {
+    "use strict";
+    TomlError = class extends Error {
+      line;
+      column;
+      codeblock;
+      constructor(message, options) {
+        const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+        const codeblock = makeCodeBlock(options.toml, line, column);
+        super(`Invalid TOML document: ${message}
+
+${codeblock}`, options);
+        this.line = line;
+        this.column = column;
+        this.codeblock = codeblock;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/util.js
+function isEscaped(str3, ptr) {
+  let i = 0;
+  while (str3[ptr - ++i] === "\\")
+    ;
+  return --i && i % 2;
+}
+function indexOfNewline(str3, start = 0, end = str3.length) {
+  let idx = str3.indexOf("\n", start);
+  if (str3[idx - 1] === "\r")
+    idx--;
+  return idx <= end ? idx : -1;
+}
+function skipComment(str3, ptr) {
+  for (let i = ptr; i < str3.length; i++) {
+    let c = str3[i];
+    if (c === "\n")
+      return i;
+    if (c === "\r" && str3[i + 1] === "\n")
+      return i + 1;
+    if (c < " " && c !== "	" || c === "\x7F") {
+      throw new TomlError("control characters are not allowed in comments", {
+        toml: str3,
+        ptr
+      });
+    }
+  }
+  return str3.length;
+}
+function skipVoid(str3, ptr, banNewLines, banComments) {
+  let c;
+  while (1) {
+    while ((c = str3[ptr]) === " " || c === "	" || !banNewLines && (c === "\n" || c === "\r" && str3[ptr + 1] === "\n"))
+      ptr++;
+    if (banComments || c !== "#")
+      break;
+    ptr = skipComment(str3, ptr);
+  }
+  return ptr;
+}
+function skipUntil(str3, ptr, sep4, end, banNewLines = false) {
+  if (!end) {
+    ptr = indexOfNewline(str3, ptr);
+    return ptr < 0 ? str3.length : ptr;
+  }
+  for (let i = ptr; i < str3.length; i++) {
+    let c = str3[i];
+    if (c === "#") {
+      i = indexOfNewline(str3, i);
+    } else if (c === sep4) {
+      return i + 1;
+    } else if (c === end || banNewLines && (c === "\n" || c === "\r" && str3[i + 1] === "\n")) {
+      return i;
+    }
+  }
+  throw new TomlError("cannot find end of structure", {
+    toml: str3,
+    ptr
+  });
+}
+function getStringEnd(str3, seek) {
+  let first2 = str3[seek];
+  let target = first2 === str3[seek + 1] && str3[seek + 1] === str3[seek + 2] ? str3.slice(seek, seek + 3) : first2;
+  seek += target.length - 1;
+  do
+    seek = str3.indexOf(target, ++seek);
+  while (seek > -1 && first2 !== "'" && isEscaped(str3, seek));
+  if (seek > -1) {
+    seek += target.length;
+    if (target.length > 1) {
+      if (str3[seek] === first2)
+        seek++;
+      if (str3[seek] === first2)
+        seek++;
+    }
+  }
+  return seek;
+}
+var init_util = __esm({
+  "../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/util.js"() {
+    "use strict";
+    init_error();
+  }
+});
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/date.js
+var DATE_TIME_RE, TomlDate;
+var init_date = __esm({
+  "../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/date.js"() {
+    "use strict";
+    DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+    TomlDate = class _TomlDate extends Date {
+      #hasDate = false;
+      #hasTime = false;
+      #offset = null;
+      constructor(date2) {
+        let hasDate = true;
+        let hasTime = true;
+        let offset2 = "Z";
+        if (typeof date2 === "string") {
+          let match2 = date2.match(DATE_TIME_RE);
+          if (match2) {
+            if (!match2[1]) {
+              hasDate = false;
+              date2 = `0000-01-01T${date2}`;
+            }
+            hasTime = !!match2[2];
+            hasTime && date2[10] === " " && (date2 = date2.replace(" ", "T"));
+            if (match2[2] && +match2[2] > 23) {
+              date2 = "";
+            } else {
+              offset2 = match2[3] || null;
+              date2 = date2.toUpperCase();
+              if (!offset2 && hasTime)
+                date2 += "Z";
+            }
+          } else {
+            date2 = "";
+          }
+        }
+        super(date2);
+        if (!isNaN(this.getTime())) {
+          this.#hasDate = hasDate;
+          this.#hasTime = hasTime;
+          this.#offset = offset2;
+        }
+      }
+      isDateTime() {
+        return this.#hasDate && this.#hasTime;
+      }
+      isLocal() {
+        return !this.#hasDate || !this.#hasTime || !this.#offset;
+      }
+      isDate() {
+        return this.#hasDate && !this.#hasTime;
+      }
+      isTime() {
+        return this.#hasTime && !this.#hasDate;
+      }
+      isValid() {
+        return this.#hasDate || this.#hasTime;
+      }
+      toISOString() {
+        let iso = super.toISOString();
+        if (this.isDate())
+          return iso.slice(0, 10);
+        if (this.isTime())
+          return iso.slice(11, 23);
+        if (this.#offset === null)
+          return iso.slice(0, -1);
+        if (this.#offset === "Z")
+          return iso;
+        let offset2 = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+        offset2 = this.#offset[0] === "-" ? offset2 : -offset2;
+        let offsetDate = new Date(this.getTime() - offset2 * 6e4);
+        return offsetDate.toISOString().slice(0, -1) + this.#offset;
+      }
+      static wrapAsOffsetDateTime(jsDate, offset2 = "Z") {
+        let date2 = new _TomlDate(jsDate);
+        date2.#offset = offset2;
+        return date2;
+      }
+      static wrapAsLocalDateTime(jsDate) {
+        let date2 = new _TomlDate(jsDate);
+        date2.#offset = null;
+        return date2;
+      }
+      static wrapAsLocalDate(jsDate) {
+        let date2 = new _TomlDate(jsDate);
+        date2.#hasTime = false;
+        date2.#offset = null;
+        return date2;
+      }
+      static wrapAsLocalTime(jsDate) {
+        let date2 = new _TomlDate(jsDate);
+        date2.#hasDate = false;
+        date2.#offset = null;
+        return date2;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/primitive.js
+function parseString(str3, ptr = 0, endPtr = str3.length) {
+  let isLiteral = str3[ptr] === "'";
+  let isMultiline = str3[ptr++] === str3[ptr] && str3[ptr] === str3[ptr + 1];
+  if (isMultiline) {
+    endPtr -= 2;
+    if (str3[ptr += 2] === "\r")
+      ptr++;
+    if (str3[ptr] === "\n")
+      ptr++;
+  }
+  let tmp = 0;
+  let isEscape;
+  let parsed = "";
+  let sliceStart = ptr;
+  while (ptr < endPtr - 1) {
+    let c = str3[ptr++];
+    if (c === "\n" || c === "\r" && str3[ptr] === "\n") {
+      if (!isMultiline) {
+        throw new TomlError("newlines are not allowed in strings", {
+          toml: str3,
+          ptr: ptr - 1
+        });
+      }
+    } else if (c < " " && c !== "	" || c === "\x7F") {
+      throw new TomlError("control characters are not allowed in strings", {
+        toml: str3,
+        ptr: ptr - 1
+      });
+    }
+    if (isEscape) {
+      isEscape = false;
+      if (c === "x" || c === "u" || c === "U") {
+        let code = str3.slice(ptr, ptr += c === "x" ? 2 : c === "u" ? 4 : 8);
+        if (!ESCAPE_REGEX.test(code)) {
+          throw new TomlError("invalid unicode escape", {
+            toml: str3,
+            ptr: tmp
+          });
+        }
+        try {
+          parsed += String.fromCodePoint(parseInt(code, 16));
+        } catch {
+          throw new TomlError("invalid unicode escape", {
+            toml: str3,
+            ptr: tmp
+          });
+        }
+      } else if (isMultiline && (c === "\n" || c === " " || c === "	" || c === "\r")) {
+        ptr = skipVoid(str3, ptr - 1, true);
+        if (str3[ptr] !== "\n" && str3[ptr] !== "\r") {
+          throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+            toml: str3,
+            ptr: tmp
+          });
+        }
+        ptr = skipVoid(str3, ptr);
+      } else if (c in ESC_MAP) {
+        parsed += ESC_MAP[c];
+      } else {
+        throw new TomlError("unrecognized escape sequence", {
+          toml: str3,
+          ptr: tmp
+        });
+      }
+      sliceStart = ptr;
+    } else if (!isLiteral && c === "\\") {
+      tmp = ptr - 1;
+      isEscape = true;
+      parsed += str3.slice(sliceStart, tmp);
+    }
+  }
+  return parsed + str3.slice(sliceStart, endPtr - 1);
+}
+function parseValue(value, toml, ptr, integersAsBigInt) {
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (value === "-inf")
+    return -Infinity;
+  if (value === "inf" || value === "+inf")
+    return Infinity;
+  if (value === "nan" || value === "+nan" || value === "-nan")
+    return NaN;
+  if (value === "-0")
+    return integersAsBigInt ? 0n : 0;
+  let isInt = INT_REGEX.test(value);
+  if (isInt || FLOAT_REGEX.test(value)) {
+    if (LEADING_ZERO.test(value)) {
+      throw new TomlError("leading zeroes are not allowed", {
+        toml,
+        ptr
+      });
+    }
+    value = value.replace(/_/g, "");
+    let numeric2 = +value;
+    if (isNaN(numeric2)) {
+      throw new TomlError("invalid number", {
+        toml,
+        ptr
+      });
+    }
+    if (isInt) {
+      if ((isInt = !Number.isSafeInteger(numeric2)) && !integersAsBigInt) {
+        throw new TomlError("integer value cannot be represented losslessly", {
+          toml,
+          ptr
+        });
+      }
+      if (isInt || integersAsBigInt === true)
+        numeric2 = BigInt(value);
+    }
+    return numeric2;
+  }
+  const date2 = new TomlDate(value);
+  if (!date2.isValid()) {
+    throw new TomlError("invalid value", {
+      toml,
+      ptr
+    });
+  }
+  return date2;
+}
+var INT_REGEX, FLOAT_REGEX, LEADING_ZERO, ESCAPE_REGEX, ESC_MAP;
+var init_primitive = __esm({
+  "../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/primitive.js"() {
+    "use strict";
+    init_util();
+    init_date();
+    init_error();
+    INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+    FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+    LEADING_ZERO = /^[+-]?0[0-9_]/;
+    ESCAPE_REGEX = /^[0-9a-f]{2,8}$/i;
+    ESC_MAP = {
+      b: "\b",
+      t: "	",
+      n: "\n",
+      f: "\f",
+      r: "\r",
+      e: "\x1B",
+      '"': '"',
+      "\\": "\\"
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/extract.js
+function sliceAndTrimEndOf(str3, startPtr, endPtr) {
+  let value = str3.slice(startPtr, endPtr);
+  let commentIdx = value.indexOf("#");
+  if (commentIdx > -1) {
+    skipComment(str3, commentIdx);
+    value = value.slice(0, commentIdx);
+  }
+  return [value.trimEnd(), commentIdx];
+}
+function extractValue(str3, ptr, end, depth, integersAsBigInt) {
+  if (depth === 0) {
+    throw new TomlError("document contains excessively nested structures. aborting.", {
+      toml: str3,
+      ptr
+    });
+  }
+  let c = str3[ptr];
+  if (c === "[" || c === "{") {
+    let [value, endPtr2] = c === "[" ? parseArray(str3, ptr, depth, integersAsBigInt) : parseInlineTable(str3, ptr, depth, integersAsBigInt);
+    if (end) {
+      endPtr2 = skipVoid(str3, endPtr2);
+      if (str3[endPtr2] === ",")
+        endPtr2++;
+      else if (str3[endPtr2] !== end) {
+        throw new TomlError("expected comma or end of structure", {
+          toml: str3,
+          ptr: endPtr2
+        });
+      }
+    }
+    return [value, endPtr2];
+  }
+  let endPtr;
+  if (c === '"' || c === "'") {
+    endPtr = getStringEnd(str3, ptr);
+    let parsed = parseString(str3, ptr, endPtr);
+    if (end) {
+      endPtr = skipVoid(str3, endPtr);
+      if (str3[endPtr] && str3[endPtr] !== "," && str3[endPtr] !== end && str3[endPtr] !== "\n" && str3[endPtr] !== "\r") {
+        throw new TomlError("unexpected character encountered", {
+          toml: str3,
+          ptr: endPtr
+        });
+      }
+      endPtr += +(str3[endPtr] === ",");
+    }
+    return [parsed, endPtr];
+  }
+  endPtr = skipUntil(str3, ptr, ",", end);
+  let slice2 = sliceAndTrimEndOf(str3, ptr, endPtr - +(str3[endPtr - 1] === ","));
+  if (!slice2[0]) {
+    throw new TomlError("incomplete key-value declaration: no value specified", {
+      toml: str3,
+      ptr
+    });
+  }
+  if (end && slice2[1] > -1) {
+    endPtr = skipVoid(str3, ptr + slice2[1]);
+    endPtr += +(str3[endPtr] === ",");
+  }
+  return [
+    parseValue(slice2[0], str3, ptr, integersAsBigInt),
+    endPtr
+  ];
+}
+var init_extract = __esm({
+  "../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/extract.js"() {
+    "use strict";
+    init_primitive();
+    init_struct();
+    init_util();
+    init_error();
+  }
+});
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/struct.js
+function parseKey(str3, ptr, end = "=") {
+  let dot = ptr - 1;
+  let parsed = [];
+  let endPtr = str3.indexOf(end, ptr);
+  if (endPtr < 0) {
+    throw new TomlError("incomplete key-value: cannot find end of key", {
+      toml: str3,
+      ptr
+    });
+  }
+  do {
+    let c = str3[ptr = ++dot];
+    if (c !== " " && c !== "	") {
+      if (c === '"' || c === "'") {
+        if (c === str3[ptr + 1] && c === str3[ptr + 2]) {
+          throw new TomlError("multiline strings are not allowed in keys", {
+            toml: str3,
+            ptr
+          });
+        }
+        let eos = getStringEnd(str3, ptr);
+        if (eos < 0) {
+          throw new TomlError("unfinished string encountered", {
+            toml: str3,
+            ptr
+          });
+        }
+        dot = str3.indexOf(".", eos);
+        let strEnd = str3.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
+        let newLine = indexOfNewline(strEnd);
+        if (newLine > -1) {
+          throw new TomlError("newlines are not allowed in keys", {
+            toml: str3,
+            ptr: ptr + dot + newLine
+          });
+        }
+        if (strEnd.trimStart()) {
+          throw new TomlError("found extra tokens after the string part", {
+            toml: str3,
+            ptr: eos
+          });
+        }
+        if (endPtr < eos) {
+          endPtr = str3.indexOf(end, eos);
+          if (endPtr < 0) {
+            throw new TomlError("incomplete key-value: cannot find end of key", {
+              toml: str3,
+              ptr
+            });
+          }
+        }
+        parsed.push(parseString(str3, ptr, eos));
+      } else {
+        dot = str3.indexOf(".", ptr);
+        let part = str3.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
+        if (!KEY_PART_RE.test(part)) {
+          throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
+            toml: str3,
+            ptr
+          });
+        }
+        parsed.push(part.trimEnd());
+      }
+    }
+  } while (dot + 1 && dot < endPtr);
+  return [parsed, skipVoid(str3, endPtr + 1, true, true)];
+}
+function parseInlineTable(str3, ptr, depth, integersAsBigInt) {
+  let res = {};
+  let seen = /* @__PURE__ */ new Set();
+  let c;
+  ptr++;
+  while ((c = str3[ptr++]) !== "}" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str3,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str3, ptr);
+    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
+      let k;
+      let t = res;
+      let hasOwn4 = false;
+      let [key, keyEndPtr] = parseKey(str3, ptr - 1);
+      for (let i = 0; i < key.length; i++) {
+        if (i)
+          t = hasOwn4 ? t[k] : t[k] = {};
+        k = key[i];
+        if ((hasOwn4 = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+          throw new TomlError("trying to redefine an already defined value", {
+            toml: str3,
+            ptr
+          });
+        }
+        if (!hasOwn4 && k === "__proto__") {
+          Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        }
+      }
+      if (hasOwn4) {
+        throw new TomlError("trying to redefine an already defined value", {
+          toml: str3,
+          ptr
+        });
+      }
+      let [value, valueEndPtr] = extractValue(str3, keyEndPtr, "}", depth - 1, integersAsBigInt);
+      seen.add(value);
+      t[k] = value;
+      ptr = valueEndPtr;
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished table encountered", {
+      toml: str3,
+      ptr
+    });
+  }
+  return [res, ptr];
+}
+function parseArray(str3, ptr, depth, integersAsBigInt) {
+  let res = [];
+  let c;
+  ptr++;
+  while ((c = str3[ptr++]) !== "]" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str3,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str3, ptr);
+    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
+      let e = extractValue(str3, ptr - 1, "]", depth - 1, integersAsBigInt);
+      res.push(e[0]);
+      ptr = e[1];
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished array encountered", {
+      toml: str3,
+      ptr
+    });
+  }
+  return [res, ptr];
+}
+var KEY_PART_RE;
+var init_struct = __esm({
+  "../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/struct.js"() {
+    "use strict";
+    init_primitive();
+    init_extract();
+    init_util();
+    init_error();
+    KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+  }
+});
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/parse.js
+function peekTable(key, table, meta, type2) {
+  let t = table;
+  let m = meta;
+  let k;
+  let hasOwn4 = false;
+  let state;
+  for (let i = 0; i < key.length; i++) {
+    if (i) {
+      t = hasOwn4 ? t[k] : t[k] = {};
+      m = (state = m[k]).c;
+      if (type2 === 0 && (state.t === 1 || state.t === 2)) {
+        return null;
+      }
+      if (state.t === 2) {
+        let l = t.length - 1;
+        t = t[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i];
+    if ((hasOwn4 = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) {
+      return null;
+    }
+    if (!hasOwn4) {
+      if (k === "__proto__") {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+      }
+      m[k] = {
+        t: i < key.length - 1 && type2 === 2 ? 3 : type2,
+        d: false,
+        i: 0,
+        c: {}
+      };
+    }
+  }
+  state = m[k];
+  if (state.t !== type2 && !(type2 === 1 && state.t === 3)) {
+    return null;
+  }
+  if (type2 === 2) {
+    if (!state.d) {
+      state.d = true;
+      t[k] = [];
+    }
+    t[k].push(t = {});
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} };
+  }
+  if (state.d) {
+    return null;
+  }
+  state.d = true;
+  if (type2 === 1) {
+    t = hasOwn4 ? t[k] : t[k] = {};
+  } else if (type2 === 0 && hasOwn4) {
+    return null;
+  }
+  return [k, t, state.c];
+}
+function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+  let res = {};
+  let meta = {};
+  let tbl = res;
+  let m = meta;
+  for (let ptr = skipVoid(toml, 0); ptr < toml.length; ) {
+    if (toml[ptr] === "[") {
+      let isTableArray = toml[++ptr] === "[";
+      let k = parseKey(toml, ptr += +isTableArray, "]");
+      if (isTableArray) {
+        if (toml[k[1] - 1] !== "]") {
+          throw new TomlError("expected end of table declaration", {
+            toml,
+            ptr: k[1] - 1
+          });
+        }
+        k[1]++;
+      }
+      let p = peekTable(
+        k[0],
+        res,
+        meta,
+        isTableArray ? 2 : 1
+        /* Type.EXPLICIT */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      m = p[2];
+      tbl = p[1];
+      ptr = k[1];
+    } else {
+      let k = parseKey(toml, ptr);
+      let p = peekTable(
+        k[0],
+        tbl,
+        m,
+        0
+        /* Type.DOTTED */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      let v = extractValue(toml, k[1], void 0, maxDepth, integersAsBigInt);
+      p[1][p[0]] = v[0];
+      ptr = v[1];
+    }
+    ptr = skipVoid(toml, ptr, true);
+    if (toml[ptr] && toml[ptr] !== "\n" && toml[ptr] !== "\r") {
+      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+        toml,
+        ptr
+      });
+    }
+    ptr = skipVoid(toml, ptr);
+  }
+  return res;
+}
+var init_parse = __esm({
+  "../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/parse.js"() {
+    "use strict";
+    init_struct();
+    init_extract();
+    init_util();
+    init_error();
+  }
+});
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/stringify.js
+function extendedTypeOf(obj) {
+  let type2 = typeof obj;
+  if (type2 === "object") {
+    if (Array.isArray(obj))
+      return "array";
+    if (obj instanceof Date)
+      return "date";
+  }
+  return type2;
+}
+function isArrayOfTables(obj) {
+  for (let i = 0; i < obj.length; i++) {
+    if (extendedTypeOf(obj[i]) !== "object")
+      return false;
+  }
+  return obj.length != 0;
+}
+function formatString(s) {
+  return JSON.stringify(s).replace(/\x7f/g, "\\u007f");
+}
+function stringifyValue(val, type2, depth, numberAsFloat) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  if (type2 === "number") {
+    if (isNaN(val))
+      return "nan";
+    if (val === Infinity)
+      return "inf";
+    if (val === -Infinity)
+      return "-inf";
+    if (numberAsFloat && Number.isInteger(val))
+      return val.toFixed(1);
+    return val.toString();
+  }
+  if (type2 === "bigint" || type2 === "boolean") {
+    return val.toString();
+  }
+  if (type2 === "string") {
+    return formatString(val);
+  }
+  if (type2 === "date") {
+    if (isNaN(val.getTime())) {
+      throw new TypeError("cannot serialize invalid date");
+    }
+    return val.toISOString();
+  }
+  if (type2 === "object") {
+    return stringifyInlineTable(val, depth, numberAsFloat);
+  }
+  if (type2 === "array") {
+    return stringifyArray(val, depth, numberAsFloat);
+  }
+}
+function stringifyInlineTable(obj, depth, numberAsFloat) {
+  let keys = Object.keys(obj);
+  if (keys.length === 0)
+    return "{}";
+  let res = "{ ";
+  for (let i = 0; i < keys.length; i++) {
+    let k = keys[i];
+    if (i)
+      res += ", ";
+    res += BARE_KEY.test(k) ? k : formatString(k);
+    res += " = ";
+    res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat);
+  }
+  return res + " }";
+}
+function stringifyArray(array, depth, numberAsFloat) {
+  if (array.length === 0)
+    return "[]";
+  let res = "[ ";
+  for (let i = 0; i < array.length; i++) {
+    if (i)
+      res += ", ";
+    if (array[i] === null || array[i] === void 0) {
+      throw new TypeError("arrays cannot contain null or undefined values");
+    }
+    res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1, numberAsFloat);
+  }
+  return res + " ]";
+}
+function stringifyArrayTable(array, key, depth, numberAsFloat) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  let res = "";
+  for (let i = 0; i < array.length; i++) {
+    res += `${res && "\n"}[[${key}]]
+`;
+    res += stringifyTable(0, array[i], key, depth, numberAsFloat);
+  }
+  return res;
+}
+function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  let preamble = "";
+  let tables = "";
+  let keys = Object.keys(obj);
+  for (let i = 0; i < keys.length; i++) {
+    let k = keys[i];
+    if (obj[k] !== null && obj[k] !== void 0) {
+      let type2 = extendedTypeOf(obj[k]);
+      if (type2 === "symbol" || type2 === "function") {
+        throw new TypeError(`cannot serialize values of type '${type2}'`);
+      }
+      let key = BARE_KEY.test(k) ? k : formatString(k);
+      if (type2 === "array" && isArrayOfTables(obj[k])) {
+        tables += (tables && "\n") + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat);
+      } else if (type2 === "object") {
+        let tblKey = prefix ? `${prefix}.${key}` : key;
+        tables += (tables && "\n") + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat);
+      } else {
+        preamble += key;
+        preamble += " = ";
+        preamble += stringifyValue(obj[k], type2, depth, numberAsFloat);
+        preamble += "\n";
+      }
+    }
+  }
+  if (tableKey && (preamble || !tables))
+    preamble = preamble ? `[${tableKey}]
+${preamble}` : `[${tableKey}]`;
+  return preamble && tables ? `${preamble}
+${tables}` : preamble || tables;
+}
+function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
+  if (extendedTypeOf(obj) !== "object") {
+    throw new TypeError("stringify can only be called with an object");
+  }
+  let str3 = stringifyTable(0, obj, "", maxDepth, numbersAsFloat);
+  if (str3[str3.length - 1] !== "\n")
+    return str3 + "\n";
+  return str3;
+}
+var BARE_KEY;
+var init_stringify = __esm({
+  "../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/stringify.js"() {
+    "use strict";
+    BARE_KEY = /^[a-z0-9-_]+$/i;
+  }
+});
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/index.js
+var init_dist = __esm({
+  "../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/index.js"() {
+    "use strict";
+    init_parse();
+    init_stringify();
+    init_date();
+    init_error();
+  }
+});
+
 // ../version/dist/chunk-Q3FHZORY.js
-import chalk2 from "chalk";
 function shouldLog2(level) {
   if (quietMode2 && level !== "error") return false;
   return LOG_LEVELS2[level] <= LOG_LEVELS2[currentLevel2];
@@ -58,6 +1480,7 @@ var LOG_LEVELS2, PREFIXES2, COLORS2, currentLevel2, quietMode2, ReleaseKitError2
 var init_chunk_Q3FHZORY = __esm({
   "../version/dist/chunk-Q3FHZORY.js"() {
     "use strict";
+    init_source();
     LOG_LEVELS2 = {
       error: 0,
       warn: 1,
@@ -73,11 +1496,11 @@ var init_chunk_Q3FHZORY = __esm({
       trace: "[TRACE]"
     };
     COLORS2 = {
-      error: chalk2.red,
-      warn: chalk2.yellow,
-      info: chalk2.blue,
-      debug: chalk2.gray,
-      trace: chalk2.dim
+      error: source_default.red,
+      warn: source_default.yellow,
+      info: source_default.blue,
+      debug: source_default.gray,
+      trace: source_default.dim
     };
     currentLevel2 = "info";
     quietMode2 = false;
@@ -194,44 +1617,44 @@ async function* splitStream(stream, separator) {
     yield buffer;
   }
 }
-var init_dist = __esm({
+var init_dist2 = __esm({
   "../../node_modules/.pnpm/@simple-libs+stream-utils@1.1.0/node_modules/@simple-libs/stream-utils/dist/index.js"() {
     "use strict";
   }
 });
 
 // ../../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;
+async function exitCode(process3) {
+  if (process3.exitCode !== null) {
+    return process3.exitCode;
   }
-  return new Promise((resolve11) => process2.once("close", resolve11));
+  return new Promise((resolve11) => process3.once("close", resolve11));
 }
-async function catchProcessError(process2) {
+async function catchProcessError(process3) {
   let error3 = new Error("Process exited with non-zero code");
   let stderr = "";
-  process2.on("error", (err) => {
+  process3.on("error", (err) => {
     error3 = err;
   });
-  if (process2.stderr) {
+  if (process3.stderr) {
     let chunk;
-    for await (chunk of process2.stderr) {
+    for await (chunk of process3.stderr) {
       stderr += chunk.toString();
     }
   }
-  const code = await exitCode(process2);
+  const code = await exitCode(process3);
   if (stderr) {
     error3 = new Error(stderr);
   }
   return code ? error3 : null;
 }
-async function* outputStream(process2) {
-  const { stdout } = process2;
-  const errorPromise = catchProcessError(process2);
+async function* outputStream(process3) {
+  const { stdout } = process3;
+  const errorPromise = catchProcessError(process3);
   if (stdout) {
     stdout.on("error", (err) => {
-      if (err.name === "AbortError" && process2.exitCode === null) {
-        process2.kill("SIGKILL");
+      if (err.name === "AbortError" && process3.exitCode === null) {
+        process3.kill("SIGKILL");
       }
     });
     yield* stdout;
@@ -241,13 +1664,13 @@ async function* outputStream(process2) {
     throw error3;
   }
 }
-function output(process2) {
-  return concatBufferStream(outputStream(process2));
+function output(process3) {
+  return concatBufferStream(outputStream(process3));
 }
-var init_dist2 = __esm({
+var init_dist3 = __esm({
   "../../node_modules/.pnpm/@simple-libs+child-process-utils@1.0.1/node_modules/@simple-libs/child-process-utils/dist/index.js"() {
     "use strict";
-    init_dist();
+    init_dist2();
   }
 });
 
@@ -257,8 +1680,8 @@ var SCISSOR, GitClient;
 var init_GitClient = __esm({
   "../../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"() {
     "use strict";
-    init_dist();
     init_dist2();
+    init_dist3();
     init_utils();
     SCISSOR = "------------------------ >8 ------------------------";
     GitClient = class {
@@ -953,7 +2376,7 @@ var require_parse = __commonJS({
   "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/parse.js"(exports2, module2) {
     "use strict";
     var SemVer = require_semver();
-    var parse4 = (version, options, throwErrors = false) => {
+    var parse2 = (version, options, throwErrors = false) => {
       if (version instanceof SemVer) {
         return version;
       }
@@ -966,7 +2389,7 @@ var require_parse = __commonJS({
         throw er;
       }
     };
-    module2.exports = parse4;
+    module2.exports = parse2;
   }
 });
 
@@ -974,9 +2397,9 @@ var require_parse = __commonJS({
 var require_valid = __commonJS({
   "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/valid.js"(exports2, module2) {
     "use strict";
-    var parse4 = require_parse();
+    var parse2 = require_parse();
     var valid = (version, options) => {
-      const v = parse4(version, options);
+      const v = parse2(version, options);
       return v ? v.version : null;
     };
     module2.exports = valid;
@@ -987,9 +2410,9 @@ var require_valid = __commonJS({
 var require_clean = __commonJS({
   "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/clean.js"(exports2, module2) {
     "use strict";
-    var parse4 = require_parse();
+    var parse2 = require_parse();
     var clean = (version, options) => {
-      const s = parse4(version.trim().replace(/^[=v]+/, ""), options);
+      const s = parse2(version.trim().replace(/^[=v]+/, ""), options);
       return s ? s.version : null;
     };
     module2.exports = clean;
@@ -1024,10 +2447,10 @@ var require_inc = __commonJS({
 var require_diff = __commonJS({
   "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/diff.js"(exports2, module2) {
     "use strict";
-    var parse4 = require_parse();
+    var parse2 = require_parse();
     var diff = (version1, version2) => {
-      const v1 = parse4(version1, null, true);
-      const v2 = parse4(version2, null, true);
+      const v1 = parse2(version1, null, true);
+      const v2 = parse2(version2, null, true);
       const comparison = v1.compare(v2);
       if (comparison === 0) {
         return null;
@@ -1098,9 +2521,9 @@ var require_patch = __commonJS({
 var require_prerelease = __commonJS({
   "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/prerelease.js"(exports2, module2) {
     "use strict";
-    var parse4 = require_parse();
+    var parse2 = require_parse();
     var prerelease = (version, options) => {
-      const parsed = parse4(version, options);
+      const parsed = parse2(version, options);
       return parsed && parsed.prerelease.length ? parsed.prerelease : null;
     };
     module2.exports = prerelease;
@@ -1286,7 +2709,7 @@ var require_coerce = __commonJS({
   "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/coerce.js"(exports2, module2) {
     "use strict";
     var SemVer = require_semver();
-    var parse4 = require_parse();
+    var parse2 = require_parse();
     var { safeRe: re, t } = require_re();
     var coerce = (version, options) => {
       if (version instanceof SemVer) {
@@ -1321,7 +2744,7 @@ var require_coerce = __commonJS({
       const patch = match2[4] || "0";
       const prerelease = options.includePrerelease && match2[5] ? `-${match2[5]}` : "";
       const build2 = options.includePrerelease && match2[6] ? `+${match2[6]}` : "";
-      return parse4(`${major}.${minor}.${patch}${prerelease}${build2}`, options);
+      return parse2(`${major}.${minor}.${patch}${prerelease}${build2}`, options);
     };
     module2.exports = coerce;
   }
@@ -2338,7 +3761,7 @@ var require_semver2 = __commonJS({
     var constants = require_constants();
     var SemVer = require_semver();
     var identifiers = require_identifiers();
-    var parse4 = require_parse();
+    var parse2 = require_parse();
     var valid = require_valid();
     var clean = require_clean();
     var inc = require_inc();
@@ -2376,7 +3799,7 @@ var require_semver2 = __commonJS({
     var simplifyRange = require_simplify();
     var subset = require_subset();
     module2.exports = {
-      parse: parse4,
+      parse: parse2,
       valid,
       clean,
       inc,
@@ -2869,7 +4292,7 @@ function parseCommits(options = {}) {
     throw err;
   } : warnOption ? (err) => warnOption(err.toString()) : () => {
   };
-  return async function* parse4(rawCommits) {
+  return async function* parse2(rawCommits) {
     const parser = new CommitParser(options);
     let rawCommit;
     for await (rawCommit of rawCommits) {
@@ -2892,14 +4315,14 @@ var init_stream = __esm({
 });
 
 // ../../node_modules/.pnpm/conventional-commits-parser@6.2.1/node_modules/conventional-commits-parser/dist/index.js
-var dist_exports = {};
-__export(dist_exports, {
+var dist_exports2 = {};
+__export(dist_exports2, {
   CommitParser: () => CommitParser,
   createCommitObject: () => createCommitObject,
   parseCommits: () => parseCommits,
   parseCommitsStream: () => parseCommitsStream
 });
-var init_dist3 = __esm({
+var init_dist4 = __esm({
   "../../node_modules/.pnpm/conventional-commits-parser@6.2.1/node_modules/conventional-commits-parser/dist/index.js"() {
     "use strict";
     init_types2();
@@ -3024,14 +4447,14 @@ var init_filters = __esm({
 });
 
 // ../../node_modules/.pnpm/conventional-commits-filter@5.0.0/node_modules/conventional-commits-filter/dist/index.js
-var dist_exports2 = {};
-__export(dist_exports2, {
+var dist_exports3 = {};
+__export(dist_exports3, {
   RevertedCommitsFilter: () => RevertedCommitsFilter,
   filterRevertedCommits: () => filterRevertedCommits,
   filterRevertedCommitsStream: () => filterRevertedCommitsStream,
   filterRevertedCommitsSync: () => filterRevertedCommitsSync
 });
-var init_dist4 = __esm({
+var init_dist5 = __esm({
   "../../node_modules/.pnpm/conventional-commits-filter@5.0.0/node_modules/conventional-commits-filter/dist/index.js"() {
     "use strict";
     init_RevertedCommitsFilter();
@@ -3045,7 +4468,7 @@ var init_ConventionalGitClient = __esm({
   "../../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"() {
     "use strict";
     import_semver = __toESM(require_semver2(), 1);
-    init_dist();
+    init_dist2();
     init_GitClient();
     ConventionalGitClient = class extends GitClient {
       deps = null;
@@ -3054,8 +4477,8 @@ var init_ConventionalGitClient = __esm({
           return this.deps;
         }
         this.deps = Promise.all([
-          Promise.resolve().then(() => (init_dist3(), dist_exports)).then(({ parseCommits: parseCommits2 }) => parseCommits2),
-          Promise.resolve().then(() => (init_dist4(), dist_exports2)).then(({ filterRevertedCommits: filterRevertedCommits2 }) => filterRevertedCommits2)
+          Promise.resolve().then(() => (init_dist4(), dist_exports2)).then(({ parseCommits: parseCommits2 }) => parseCommits2),
+          Promise.resolve().then(() => (init_dist5(), dist_exports3)).then(({ filterRevertedCommits: filterRevertedCommits2 }) => filterRevertedCommits2)
         ]);
         return this.deps;
       }
@@ -3076,9 +4499,9 @@ var init_ConventionalGitClient = __esm({
           yield* filterRevertedCommits2(this.getCommits(gitLogParams, parserOptions));
           return;
         }
-        const parse4 = parseCommits2(parserOptions);
+        const parse2 = parseCommits2(parserOptions);
         const commitsStream = this.getRawCommits(gitLogParams);
-        yield* parse4(commitsStream);
+        yield* parse2(commitsStream);
       }
       /**
        * Get semver tags stream.
@@ -3150,7 +4573,7 @@ var init_ConventionalGitClient = __esm({
 });
 
 // ../../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/index.js
-var init_dist5 = __esm({
+var init_dist6 = __esm({
   "../../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/index.js"() {
     "use strict";
     init_types();
@@ -3247,7 +4670,7 @@ var init_presetLoader = __esm({
 });
 
 // ../../node_modules/.pnpm/conventional-changelog-preset-loader@5.0.0/node_modules/conventional-changelog-preset-loader/dist/index.js
-var init_dist6 = __esm({
+var init_dist7 = __esm({
   "../../node_modules/.pnpm/conventional-changelog-preset-loader@5.0.0/node_modules/conventional-changelog-preset-loader/dist/index.js"() {
     "use strict";
     init_types3();
@@ -3273,8 +4696,8 @@ var VERSIONS, Bumper;
 var init_bumper = __esm({
   "../../node_modules/.pnpm/conventional-recommended-bump@11.2.0/node_modules/conventional-recommended-bump/dist/bumper.js"() {
     "use strict";
-    init_dist5();
     init_dist6();
+    init_dist7();
     init_utils4();
     VERSIONS = [
       "major",
@@ -3442,7 +4865,7 @@ var init_bumper = __esm({
 });
 
 // ../../node_modules/.pnpm/conventional-recommended-bump@11.2.0/node_modules/conventional-recommended-bump/dist/index.js
-var init_dist7 = __esm({
+var init_dist8 = __esm({
   "../../node_modules/.pnpm/conventional-recommended-bump@11.2.0/node_modules/conventional-recommended-bump/dist/index.js"() {
     "use strict";
     init_bumper();
@@ -3507,44 +4930,44 @@ async function* splitStream2(stream, separator) {
     yield buffer;
   }
 }
-var init_dist8 = __esm({
+var init_dist9 = __esm({
   "../../node_modules/.pnpm/@simple-libs+stream-utils@1.2.0/node_modules/@simple-libs/stream-utils/dist/index.js"() {
     "use strict";
   }
 });
 
 // ../../node_modules/.pnpm/@simple-libs+child-process-utils@1.0.2/node_modules/@simple-libs/child-process-utils/dist/index.js
-async function exitCode2(process2) {
-  if (process2.exitCode !== null) {
-    return process2.exitCode;
+async function exitCode2(process3) {
+  if (process3.exitCode !== null) {
+    return process3.exitCode;
   }
-  return new Promise((resolve11) => process2.once("close", resolve11));
+  return new Promise((resolve11) => process3.once("close", resolve11));
 }
-async function catchProcessError2(process2) {
+async function catchProcessError2(process3) {
   let error3 = new Error("Process exited with non-zero code");
   let stderr = "";
-  process2.on("error", (err) => {
+  process3.on("error", (err) => {
     error3 = err;
   });
-  if (process2.stderr) {
+  if (process3.stderr) {
     let chunk;
-    for await (chunk of process2.stderr) {
+    for await (chunk of process3.stderr) {
       stderr += chunk.toString();
     }
   }
-  const code = await exitCode2(process2);
+  const code = await exitCode2(process3);
   if (stderr) {
     error3 = new Error(stderr);
   }
   return code ? error3 : null;
 }
-async function* outputStream2(process2) {
-  const { stdout } = process2;
-  const errorPromise = catchProcessError2(process2);
+async function* outputStream2(process3) {
+  const { stdout } = process3;
+  const errorPromise = catchProcessError2(process3);
   if (stdout) {
     stdout.on("error", (err) => {
-      if (err.name === "AbortError" && process2.exitCode === null) {
-        process2.kill("SIGKILL");
+      if (err.name === "AbortError" && process3.exitCode === null) {
+        process3.kill("SIGKILL");
       }
     });
     yield* stdout;
@@ -3554,13 +4977,13 @@ async function* outputStream2(process2) {
     throw error3;
   }
 }
-function output2(process2) {
-  return concatBufferStream2(outputStream2(process2));
+function output2(process3) {
+  return concatBufferStream2(outputStream2(process3));
 }
-var init_dist9 = __esm({
+var init_dist10 = __esm({
   "../../node_modules/.pnpm/@simple-libs+child-process-utils@1.0.2/node_modules/@simple-libs/child-process-utils/dist/index.js"() {
     "use strict";
-    init_dist8();
+    init_dist9();
   }
 });
 
@@ -3570,8 +4993,8 @@ var SCISSOR3, GitClient2;
 var init_GitClient2 = __esm({
   "../../node_modules/.pnpm/@conventional-changelog+git-client@2.6.0_conventional-commits-filter@5.0.0_conventional-commits-parser@6.2.1/node_modules/@conventional-changelog/git-client/dist/GitClient.js"() {
     "use strict";
-    init_dist8();
     init_dist9();
+    init_dist10();
     init_utils5();
     SCISSOR3 = "------------------------ >8 ------------------------";
     GitClient2 = class {
@@ -3820,7 +5243,7 @@ var init_ConventionalGitClient2 = __esm({
   "../../node_modules/.pnpm/@conventional-changelog+git-client@2.6.0_conventional-commits-filter@5.0.0_conventional-commits-parser@6.2.1/node_modules/@conventional-changelog/git-client/dist/ConventionalGitClient.js"() {
     "use strict";
     import_semver2 = __toESM(require_semver2(), 1);
-    init_dist8();
+    init_dist9();
     init_GitClient2();
     ConventionalGitClient2 = class extends GitClient2 {
       deps = null;
@@ -3829,8 +5252,8 @@ var init_ConventionalGitClient2 = __esm({
           return this.deps;
         }
         this.deps = Promise.all([
-          Promise.resolve().then(() => (init_dist3(), dist_exports)).then(({ parseCommits: parseCommits2 }) => parseCommits2),
-          Promise.resolve().then(() => (init_dist4(), dist_exports2)).then(({ filterRevertedCommits: filterRevertedCommits2 }) => filterRevertedCommits2)
+          Promise.resolve().then(() => (init_dist4(), dist_exports2)).then(({ parseCommits: parseCommits2 }) => parseCommits2),
+          Promise.resolve().then(() => (init_dist5(), dist_exports3)).then(({ filterRevertedCommits: filterRevertedCommits2 }) => filterRevertedCommits2)
         ]);
         return this.deps;
       }
@@ -3851,9 +5274,9 @@ var init_ConventionalGitClient2 = __esm({
           yield* filterRevertedCommits2(this.getCommits(gitLogParams, parserOptions));
           return;
         }
-        const parse4 = parseCommits2(parserOptions);
+        const parse2 = parseCommits2(parserOptions);
         const commitsStream = this.getRawCommits(gitLogParams);
-        yield* parse4(commitsStream);
+        yield* parse2(commitsStream);
       }
       /**
        * Get semver tags stream.
@@ -3925,7 +5348,7 @@ var init_ConventionalGitClient2 = __esm({
 });
 
 // ../../node_modules/.pnpm/@conventional-changelog+git-client@2.6.0_conventional-commits-filter@5.0.0_conventional-commits-parser@6.2.1/node_modules/@conventional-changelog/git-client/dist/index.js
-var init_dist10 = __esm({
+var init_dist11 = __esm({
   "../../node_modules/.pnpm/@conventional-changelog+git-client@2.6.0_conventional-commits-filter@5.0.0_conventional-commits-parser@6.2.1/node_modules/@conventional-changelog/git-client/dist/index.js"() {
     "use strict";
     init_types4();
@@ -3962,7 +5385,7 @@ async function getSemverTags(options = {}) {
 var init_src = __esm({
   "../../node_modules/.pnpm/git-semver-tags@8.0.1_conventional-commits-filter@5.0.0_conventional-commits-parser@6.2.1/node_modules/git-semver-tags/src/index.js"() {
     "use strict";
-    init_dist10();
+    init_dist11();
   }
 });
 
@@ -7394,7 +8817,7 @@ function sync(root, options) {
   return walker.start();
 }
 var __require2, SLASHES_REGEX, WINDOWS_ROOT_DIR_REGEX, pushDirectory, pushDirectoryFilter, empty$2, pushFileFilterAndCount, pushFileFilter, pushFileCount, pushFile, empty$1, getArray, getArrayGroup, groupFiles, empty, resolveSymlinksAsync, resolveSymlinks, onlyCountsSync, groupsSync, defaultSync, limitFilesSync, onlyCountsAsync, defaultAsync, limitFilesAsync, groupsAsync, readdirOpts, walkAsync, walkSync, Queue, Counter, Aborter, Walker, APIBuilder, pm, Builder;
-var init_dist11 = __esm({
+var init_dist12 = __esm({
   "../../node_modules/.pnpm/fdir@6.5.0_picomatch@4.0.4/node_modules/fdir/dist/index.mjs"() {
     "use strict";
     __require2 = /* @__PURE__ */ createRequire(import.meta.url);
@@ -8616,7 +10039,7 @@ var require_parse2 = __commonJS({
       }
       return { risky: false };
     };
-    var parse4 = (input, options) => {
+    var parse2 = (input, options) => {
       if (typeof input !== "string") {
         throw new TypeError("Expected a string");
       }
@@ -8786,7 +10209,7 @@ var require_parse2 = __commonJS({
             output3 = token.close = `)$))${extglobStar}`;
           }
           if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
-            const expression = parse4(rest, { ...options, fastpaths: false }).output;
+            const expression = parse2(rest, { ...options, fastpaths: false }).output;
             output3 = token.close = `)${expression})${extglobStar})`;
           }
           if (token.prev.type === "bos") {
@@ -9308,7 +10731,7 @@ var require_parse2 = __commonJS({
       }
       return state;
     };
-    parse4.fastpaths = (input, options) => {
+    parse2.fastpaths = (input, options) => {
       const opts = { ...options };
       const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
       const len = input.length;
@@ -9373,7 +10796,7 @@ var require_parse2 = __commonJS({
       }
       return source;
     };
-    module2.exports = parse4;
+    module2.exports = parse2;
   }
 });
 
@@ -9382,7 +10805,7 @@ var require_picomatch = __commonJS({
   "../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/picomatch.js"(exports2, module2) {
     "use strict";
     var scan = require_scan();
-    var parse4 = require_parse2();
+    var parse2 = require_parse2();
     var utils2 = require_utils();
     var constants = require_constants2();
     var isObject3 = (val) => val && typeof val === "object" && !Array.isArray(val);
@@ -9470,7 +10893,7 @@ var require_picomatch = __commonJS({
     picomatch2.isMatch = (str3, patterns, options) => picomatch2(patterns, options)(str3);
     picomatch2.parse = (pattern, options) => {
       if (Array.isArray(pattern)) return pattern.map((p) => picomatch2.parse(p, options));
-      return parse4(pattern, { ...options, fastpaths: false });
+      return parse2(pattern, { ...options, fastpaths: false });
     };
     picomatch2.scan = (input, options) => scan(input, options);
     picomatch2.compileRe = (state, options, returnOutput = false, returnState = false) => {
@@ -9496,10 +10919,10 @@ var require_picomatch = __commonJS({
       }
       let parsed = { negated: false, fastpaths: true };
       if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
-        parsed.output = parse4.fastpaths(input, options);
+        parsed.output = parse2.fastpaths(input, options);
       }
       if (!parsed.output) {
-        parsed = parse4(input, options);
+        parsed = parse2(input, options);
       }
       return picomatch2.compileRe(parsed, options, returnOutput, returnState);
     };
@@ -9798,10 +11221,10 @@ function globSync(patternsOrOptions, options) {
   return formatPaths(crawler.sync(), relative2);
 }
 var import_picomatch, isReadonlyArray, isWin, ONLY_PARENT_DIRECTORIES, WIN32_ROOT_DIR, isRoot, splitPatternOptions, POSIX_UNESCAPED_GLOB_SYMBOLS, WIN32_UNESCAPED_GLOB_SYMBOLS, escapePosixPath, escapeWin32Path, escapePath, PARENT_DIRECTORY, ESCAPING_BACKSLASHES, BACKSLASHES;
-var init_dist12 = __esm({
+var init_dist13 = __esm({
   "../../node_modules/.pnpm/tinyglobby@0.2.15/node_modules/tinyglobby/dist/index.mjs"() {
     "use strict";
-    init_dist11();
+    init_dist12();
     import_picomatch = __toESM(require_picomatch2(), 1);
     isReadonlyArray = Array.isArray;
     isWin = process.platform === "win32";
@@ -12527,7 +13950,7 @@ var require_parse3 = __commonJS({
       }
       return result + "\n" + srcline + "\n" + underline;
     }
-    function parse4(input, options) {
+    function parse2(input, options) {
       var json5 = false;
       var cjson = false;
       if (options.legacy || options.mode === "json") {
@@ -12595,13 +14018,13 @@ var require_parse3 = __commonJS({
           tokenStart();
           var chr = input[position++];
           if (chr === '"' || chr === "'" && json5) {
-            return tokenEnd(parseString(chr), "literal");
+            return tokenEnd(parseString2(chr), "literal");
           } else if (chr === "{") {
             tokenEnd(void 0, "separator");
             return parseObject();
           } else if (chr === "[") {
             tokenEnd(void 0, "separator");
-            return parseArray();
+            return parseArray2();
           } else if (chr === "-" || chr === "." || isDecDigit(chr) || json5 && (chr === "+" || chr === "I" || chr === "N")) {
             return tokenEnd(parseNumber(), "literal");
           } else if (chr === "n") {
@@ -12619,19 +14042,19 @@ var require_parse3 = __commonJS({
           }
         }
       }
-      function parseKey() {
+      function parseKey2() {
         var result;
         while (position < length) {
           tokenStart();
           var chr = input[position++];
           if (chr === '"' || chr === "'" && json5) {
-            return tokenEnd(parseString(chr), "key");
+            return tokenEnd(parseString2(chr), "key");
           } else if (chr === "{") {
             tokenEnd(void 0, "separator");
             return parseObject();
           } else if (chr === "[") {
             tokenEnd(void 0, "separator");
-            return parseArray();
+            return parseArray2();
           } else if (chr === "." || isDecDigit(chr)) {
             return tokenEnd(parseNumber(true), "key");
           } else if (json5 && Uni.isIdentifierStart(chr) || chr === "\\" && input[position] === "u") {
@@ -12667,7 +14090,7 @@ var require_parse3 = __commonJS({
             tokenEnd(void 0, "whitespace");
             tokenStart();
             position++;
-            skipComment(input[position++] === "*");
+            skipComment2(input[position++] === "*");
             tokenEnd(void 0, "comment");
             tokenStart();
           } else {
@@ -12677,7 +14100,7 @@ var require_parse3 = __commonJS({
         }
         return tokenEnd(void 0, "whitespace");
       }
-      function skipComment(multi) {
+      function skipComment2(multi) {
         while (position < length) {
           var chr = input[position++];
           if (isLineTerminator(chr)) {
@@ -12713,7 +14136,7 @@ var require_parse3 = __commonJS({
         var result = options.null_prototype ? /* @__PURE__ */ Object.create(null) : {}, empty_object = {}, is_non_empty = false;
         while (position < length) {
           skipWhiteSpace();
-          var item1 = parseKey();
+          var item1 = parseKey2();
           skipWhiteSpace();
           tokenStart();
           var chr = input[position++];
@@ -12772,7 +14195,7 @@ var require_parse3 = __commonJS({
         }
         fail();
       }
-      function parseArray() {
+      function parseArray2() {
         var result = [];
         while (position < length) {
           skipWhiteSpace();
@@ -12898,7 +14321,7 @@ var require_parse3 = __commonJS({
         }
         fail();
       }
-      function parseString(endChar) {
+      function parseString2(endChar) {
         var result = "";
         while (position < length) {
           var chr = input[position++];
@@ -12985,7 +14408,7 @@ var require_parse3 = __commonJS({
         }
       }
       try {
-        return parse4(input, options);
+        return parse2(input, options);
       } catch (err) {
         if (err instanceof SyntaxError && err.row != null && err.column != null) {
           var old_err = err;
@@ -13356,7 +14779,7 @@ var require_document = __commonJS({
     "use strict";
     var assert2 = __require("assert");
     var tokenize2 = require_parse3().tokenize;
-    var stringify5 = require_stringify().stringify;
+    var stringify4 = require_stringify().stringify;
     var analyze2 = require_analyze().analyze;
     function isObject3(x) {
       return typeof x === "object" && x !== null;
@@ -13371,7 +14794,7 @@ var require_document = __commonJS({
       }
       if (options._splitMin == null) options._splitMin = 0;
       if (options._splitMax == null) options._splitMax = 0;
-      var stringified = stringify5(value, options);
+      var stringified = stringify4(value, options);
       if (is_key) {
         return [{ raw: stringified, type: "key", stack, value }];
       }
@@ -13839,7 +15262,7 @@ var import_jju, InvalidMonorepoError, readJson, readJsonSync, BunTool, LernaTool
 var init_manypkg_tools = __esm({
   "../../node_modules/.pnpm/@manypkg+tools@2.1.0/node_modules/@manypkg/tools/dist/manypkg-tools.js"() {
     "use strict";
-    init_dist12();
+    init_dist13();
     init_js_yaml();
     import_jju = __toESM(require_jju(), 1);
     InvalidMonorepoError = class extends Error {
@@ -14511,22 +15934,19 @@ var init_baseError_DQHIJACF = __esm({
 // ../version/dist/chunk-UBCKZYTO.js
 import * as fs9 from "fs";
 import * as path12 from "path";
-import * as TOML2 from "smol-toml";
 import * as fs32 from "fs";
 import * as path32 from "path";
 import { z as z22 } from "zod";
 import { z as z3 } from "zod";
 import * as fs22 from "fs";
-import * as os2 from "os";
+import * as os3 from "os";
 import * as path22 from "path";
 import fs42 from "fs";
 import { cwd } from "process";
-import chalk3 from "chalk";
 import fs62 from "fs";
 import path52 from "path";
 import fs52 from "fs";
 import path42 from "path";
-import * as TOML22 from "smol-toml";
 import * as fs92 from "fs";
 import path72 from "path";
 import fs82 from "fs";
@@ -14537,7 +15957,7 @@ import path92 from "path";
 import { Command } from "commander";
 function parseCargoToml(cargoPath) {
   const content = fs9.readFileSync(cargoPath, "utf-8");
-  return TOML2.parse(content);
+  return parse(content);
 }
 function isCargoToml(filePath) {
   return path12.basename(filePath) === "Cargo.toml";
@@ -14564,7 +15984,7 @@ function substituteVariables2(value) {
     return process.env[varName] ?? "";
   });
   result = result.replace(filePattern, (_, filePath) => {
-    const expandedPath = filePath.startsWith("~") ? path22.join(os2.homedir(), filePath.slice(1)) : filePath;
+    const expandedPath = filePath.startsWith("~") ? path22.join(os3.homedir(), filePath.slice(1)) : filePath;
     try {
       return fs22.readFileSync(expandedPath, "utf-8").trim();
     } catch {
@@ -14809,19 +16229,19 @@ function log4(message, level = "info") {
   let chalkFn;
   switch (level) {
     case "success":
-      chalkFn = chalk3.green;
+      chalkFn = source_default.green;
       break;
     case "warning":
-      chalkFn = chalk3.yellow;
+      chalkFn = source_default.yellow;
       break;
     case "error":
-      chalkFn = chalk3.red;
+      chalkFn = source_default.red;
       break;
     case "debug":
-      chalkFn = chalk3.gray;
+      chalkFn = source_default.gray;
       break;
     default:
-      chalkFn = chalk3.blue;
+      chalkFn = source_default.blue;
   }
   const formattedMessage = level === "debug" ? `[DEBUG] ${message}` : message;
   if (isJsonOutputMode()) {
@@ -15040,7 +16460,7 @@ function updateCargoVersion(cargoPath, version, dryRun = false) {
     } else {
       cargo.package.version = version;
     }
-    const updatedContent = TOML22.stringify(cargo);
+    const updatedContent = stringify(cargo);
     if (dryRun) {
       recordPendingWrite(cargoPath, updatedContent);
     } else {
@@ -16302,11 +17722,14 @@ var init_chunk_UBCKZYTO = __esm({
     "use strict";
     init_chunk_Q3FHZORY();
     init_chunk_LMPZV35Z();
-    init_dist7();
+    init_dist();
+    init_dist8();
     import_semver3 = __toESM(require_semver2(), 1);
     init_src();
     import_semver4 = __toESM(require_semver2(), 1);
+    init_source();
     init_node_figlet();
+    init_dist();
     import_semver5 = __toESM(require_semver2(), 1);
     init_esm3();
     init_manypkg_get_packages();
@@ -16613,7 +18036,7 @@ var init_chunk_UBCKZYTO = __esm({
     });
     MAX_INPUT_LENGTH2 = 1e4;
     SOLE_REFERENCE_PATTERN2 = /^\{(?:env|file):[^}]+\}$/;
-    AUTH_DIR2 = path22.join(os2.homedir(), ".config", "releasekit");
+    AUTH_DIR2 = path22.join(os3.homedir(), ".config", "releasekit");
     AUTH_FILE2 = path22.join(AUTH_DIR2, "auth.json");
     CONFIG_FILE2 = "releasekit.config.json";
     VersionError = class extends BaseVersionError {
@@ -17019,8 +18442,8 @@ var init_chunk_UBCKZYTO = __esm({
 });
 
 // ../version/dist/index.js
-var dist_exports3 = {};
-__export(dist_exports3, {
+var dist_exports4 = {};
+__export(dist_exports4, {
   BaseVersionError: () => BaseVersionError,
   PackageProcessor: () => PackageProcessor,
   VersionEngine: () => VersionEngine,
@@ -17036,7 +18459,7 @@ __export(dist_exports3, {
   getJsonData: () => getJsonData,
   loadConfig: () => loadConfig22
 });
-var init_dist13 = __esm({
+var init_dist14 = __esm({
   "../version/dist/index.js"() {
     "use strict";
     init_chunk_UBCKZYTO();
@@ -17046,7 +18469,6 @@ var init_dist13 = __esm({
 });
 
 // ../notes/dist/chunk-7TJSPQPW.js
-import chalk4 from "chalk";
 import * as fs23 from "fs";
 import * as path23 from "path";
 function setLogLevel2(level) {
@@ -17075,7 +18497,7 @@ function info2(message) {
 }
 function success2(message) {
   if (!shouldLog3("info")) return;
-  console.error(chalk4.green(`[SUCCESS] ${message}`));
+  console.error(source_default.green(`[SUCCESS] ${message}`));
 }
 function debug(message) {
   log5(message, "debug");
@@ -17198,6 +18620,7 @@ var LOG_LEVELS3, PREFIXES3, COLORS3, currentLevel3, quietMode3, ReleaseKitError3
 var init_chunk_7TJSPQPW = __esm({
   "../notes/dist/chunk-7TJSPQPW.js"() {
     "use strict";
+    init_source();
     LOG_LEVELS3 = {
       error: 0,
       warn: 1,
@@ -17213,11 +18636,11 @@ var init_chunk_7TJSPQPW = __esm({
       trace: "[TRACE]"
     };
     COLORS3 = {
-      error: chalk4.red,
-      warn: chalk4.yellow,
-      info: chalk4.blue,
-      debug: chalk4.gray,
-      trace: chalk4.dim
+      error: source_default.red,
+      warn: source_default.yellow,
+      info: source_default.blue,
+      debug: source_default.gray,
+      trace: source_default.dim
     };
     currentLevel3 = "info";
     quietMode3 = false;
@@ -17343,7 +18766,7 @@ var init_errors = __esm({
 
 // ../../node_modules/.pnpm/@anthropic-ai+sdk@0.82.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/core/error.mjs
 var AnthropicError, APIError, APIUserAbortError, APIConnectionError, APIConnectionTimeoutError, BadRequestError, AuthenticationError, PermissionDeniedError, NotFoundError, ConflictError, UnprocessableEntityError, RateLimitError, InternalServerError;
-var init_error = __esm({
+var init_error2 = __esm({
   "../../node_modules/.pnpm/@anthropic-ai+sdk@0.82.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/core/error.mjs"() {
     "use strict";
     init_errors();
@@ -17461,7 +18884,7 @@ var startsWithSchemeRegexp, isAbsoluteURL, isArray, isReadonlyArray2, validatePo
 var init_values = __esm({
   "../../node_modules/.pnpm/@anthropic-ai+sdk@0.82.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/internal/utils/values.mjs"() {
     "use strict";
-    init_error();
+    init_error2();
     startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
     isAbsoluteURL = (url) => {
       return startsWithSchemeRegexp.test(url);
@@ -17753,7 +19176,7 @@ function stringifyQuery(query) {
 var init_query = __esm({
   "../../node_modules/.pnpm/@anthropic-ai+sdk@0.82.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/internal/utils/query.mjs"() {
     "use strict";
-    init_error();
+    init_error2();
   }
 });
 
@@ -18007,7 +19430,7 @@ var init_streaming = __esm({
   "../../node_modules/.pnpm/@anthropic-ai+sdk@0.82.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/core/streaming.mjs"() {
     "use strict";
     init_tslib();
-    init_error();
+    init_error2();
     init_shims();
     init_line();
     init_shims();
@@ -18015,7 +19438,7 @@ var init_streaming = __esm({
     init_values();
     init_bytes();
     init_log();
-    init_error();
+    init_error2();
     Stream = class _Stream {
       constructor(iterator, controller, client) {
         this.iterator = iterator;
@@ -18264,7 +19687,7 @@ function addRequestID(value, response) {
     enumerable: false
   });
 }
-var init_parse = __esm({
+var init_parse2 = __esm({
   "../../node_modules/.pnpm/@anthropic-ai+sdk@0.82.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/internal/parse.mjs"() {
     "use strict";
     init_streaming();
@@ -18278,7 +19701,7 @@ var init_api_promise = __esm({
   "../../node_modules/.pnpm/@anthropic-ai+sdk@0.82.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/core/api-promise.mjs"() {
     "use strict";
     init_tslib();
-    init_parse();
+    init_parse2();
     APIPromise = class _APIPromise extends Promise {
       constructor(client, responsePromise, parseResponse2 = defaultParseResponse) {
         super((resolve11) => {
@@ -18348,8 +19771,8 @@ var init_pagination = __esm({
   "../../node_modules/.pnpm/@anthropic-ai+sdk@0.82.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/core/pagination.mjs"() {
     "use strict";
     init_tslib();
-    init_error();
-    init_parse();
+    init_error2();
+    init_parse2();
     init_api_promise();
     init_values();
     AbstractPage = class {
@@ -18520,8 +19943,8 @@ var init_uploads = __esm({
     init_shims();
     checkFileSupport = () => {
       if (typeof File === "undefined") {
-        const { process: process2 } = globalThis;
-        const isOldNode = typeof process2?.versions?.node === "string" && parseInt(process2.versions.node.split(".")) < 20;
+        const { process: process3 } = globalThis;
+        const isOldNode = typeof process3?.versions?.node === "string" && parseInt(process3.versions.node.split(".")) < 20;
         throw new Error("`File` is not defined as a global, which is required for file uploads." + (isOldNode ? " Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`." : ""));
       }
     };
@@ -18788,7 +20211,7 @@ var EMPTY, createPathTagFunction, path13;
 var init_path = __esm({
   "../../node_modules/.pnpm/@anthropic-ai+sdk@0.82.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/internal/utils/path.mjs"() {
     "use strict";
-    init_error();
+    init_error2();
     EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
     createPathTagFunction = (pathEncoder = encodeURIPath) => function path18(statics, ...params) {
       if (statics.length === 1)
@@ -19031,10 +20454,10 @@ var init_models = __esm({
 });
 
 // ../../node_modules/.pnpm/@anthropic-ai+sdk@0.82.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/error.mjs
-var init_error2 = __esm({
+var init_error3 = __esm({
   "../../node_modules/.pnpm/@anthropic-ai+sdk@0.82.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/error.mjs"() {
     "use strict";
-    init_error();
+    init_error2();
   }
 });
 
@@ -19131,7 +20554,7 @@ function parseBetaOutputFormat(params, content) {
 var init_beta_parser = __esm({
   "../../node_modules/.pnpm/@anthropic-ai+sdk@0.82.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/lib/beta-parser.mjs"() {
     "use strict";
-    init_error();
+    init_error2();
   }
 });
 
@@ -19381,7 +20804,7 @@ var init_BetaMessageStream = __esm({
     "use strict";
     init_tslib();
     init_parser();
-    init_error2();
+    init_error3();
     init_errors();
     init_streaming2();
     init_beta_parser();
@@ -20083,7 +21506,7 @@ var init_BetaToolRunner = __esm({
     "use strict";
     init_tslib();
     init_ToolError();
-    init_error();
+    init_error2();
     init_headers();
     init_CompactionControl();
     init_stainless_helper_header();
@@ -20365,7 +21788,7 @@ var JSONLDecoder;
 var init_jsonl = __esm({
   "../../node_modules/.pnpm/@anthropic-ai+sdk@0.82.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/internal/decoders/jsonl.mjs"() {
     "use strict";
-    init_error();
+    init_error2();
     init_shims();
     init_line();
     JSONLDecoder = class _JSONLDecoder {
@@ -20410,7 +21833,7 @@ var init_batches = __esm({
     init_pagination();
     init_headers();
     init_jsonl();
-    init_error2();
+    init_error3();
     init_path();
     Batches = class extends APIResource {
       /**
@@ -20626,7 +22049,7 @@ var DEPRECATED_MODELS, MODELS_TO_WARN_WITH_THINKING_ENABLED, Messages;
 var init_messages = __esm({
   "../../node_modules/.pnpm/@anthropic-ai+sdk@0.82.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/resources/beta/messages/messages.mjs"() {
     "use strict";
-    init_error2();
+    init_error3();
     init_resource();
     init_constants();
     init_headers();
@@ -21077,7 +22500,7 @@ function parseOutputFormat(params, content) {
 var init_parser2 = __esm({
   "../../node_modules/.pnpm/@anthropic-ai+sdk@0.82.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/lib/parser.mjs"() {
     "use strict";
-    init_error();
+    init_error2();
   }
 });
 
@@ -21093,7 +22516,7 @@ var init_MessageStream = __esm({
     "use strict";
     init_tslib();
     init_errors();
-    init_error2();
+    init_error3();
     init_streaming2();
     init_parser();
     init_parser2();
@@ -21668,7 +23091,7 @@ var init_batches2 = __esm({
     init_pagination();
     init_headers();
     init_jsonl();
-    init_error2();
+    init_error3();
     init_path();
     Batches2 = class extends APIResource {
       /**
@@ -22003,12 +23426,12 @@ var readEnv;
 var init_env = __esm({
   "../../node_modules/.pnpm/@anthropic-ai+sdk@0.82.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/internal/utils/env.mjs"() {
     "use strict";
-    readEnv = (env) => {
+    readEnv = (env2) => {
       if (typeof globalThis.process !== "undefined") {
-        return globalThis.process.env?.[env]?.trim() ?? void 0;
+        return globalThis.process.env?.[env2]?.trim() ?? void 0;
       }
       if (typeof globalThis.Deno !== "undefined") {
-        return globalThis.Deno.env?.get?.(env)?.trim();
+        return globalThis.Deno.env?.get?.(env2)?.trim();
       }
       return void 0;
     };
@@ -22030,7 +23453,7 @@ var init_client = __esm({
     init_request_options();
     init_query();
     init_version();
-    init_error();
+    init_error2();
     init_pagination();
     init_uploads2();
     init_resources();
@@ -22521,7 +23944,7 @@ var init_sdk = __esm({
     init_api_promise();
     init_client();
     init_pagination();
-    init_error();
+    init_error2();
   }
 });
 
@@ -22605,7 +24028,7 @@ var init_errors2 = __esm({
 
 // ../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/core/error.mjs
 var OpenAIError, APIError2, APIUserAbortError2, APIConnectionError2, APIConnectionTimeoutError2, BadRequestError2, AuthenticationError2, PermissionDeniedError2, NotFoundError2, ConflictError2, UnprocessableEntityError2, RateLimitError2, InternalServerError2, LengthFinishReasonError, ContentFilterFinishReasonError, InvalidWebhookSignatureError;
-var init_error3 = __esm({
+var init_error4 = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/core/error.mjs"() {
     "use strict";
     init_errors2();
@@ -22743,7 +24166,7 @@ var startsWithSchemeRegexp2, isAbsoluteURL2, isArray2, isReadonlyArray3, validat
 var init_values2 = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/internal/utils/values.mjs"() {
     "use strict";
-    init_error3();
+    init_error4();
     startsWithSchemeRegexp2 = /^[a-z][a-z0-9+.-]*:/i;
     isAbsoluteURL2 = (url) => {
       return startsWithSchemeRegexp2.test(url);
@@ -23361,7 +24784,7 @@ function stringify2(object, opts = {}) {
   return joined.length > 0 ? prefix + joined : "";
 }
 var array_prefix_generators, push_to_array, toISOString, defaults2, sentinel;
-var init_stringify = __esm({
+var init_stringify2 = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/internal/qs/stringify.mjs"() {
     "use strict";
     init_utils6();
@@ -23415,7 +24838,7 @@ function stringifyQuery2(query) {
 var init_query2 = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/internal/utils/query.mjs"() {
     "use strict";
-    init_stringify();
+    init_stringify2();
   }
 });
 
@@ -23669,14 +25092,14 @@ var init_streaming3 = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/core/streaming.mjs"() {
     "use strict";
     init_tslib2();
-    init_error3();
+    init_error4();
     init_shims2();
     init_line2();
     init_shims2();
     init_errors2();
     init_bytes2();
     init_log2();
-    init_error3();
+    init_error4();
     Stream2 = class _Stream {
       constructor(iterator, controller, client) {
         this.iterator = iterator;
@@ -23932,7 +25355,7 @@ function addRequestID2(value, response) {
     enumerable: false
   });
 }
-var init_parse2 = __esm({
+var init_parse3 = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/internal/parse.mjs"() {
     "use strict";
     init_streaming3();
@@ -23946,7 +25369,7 @@ var init_api_promise2 = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/core/api-promise.mjs"() {
     "use strict";
     init_tslib2();
-    init_parse2();
+    init_parse3();
     APIPromise2 = class _APIPromise extends Promise {
       constructor(client, responsePromise, parseResponse2 = defaultParseResponse2) {
         super((resolve11) => {
@@ -24016,8 +25439,8 @@ var init_pagination2 = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/core/pagination.mjs"() {
     "use strict";
     init_tslib2();
-    init_error3();
-    init_parse2();
+    init_error4();
+    init_parse3();
     init_api_promise2();
     init_values2();
     AbstractPage2 = class {
@@ -24186,8 +25609,8 @@ var init_uploads3 = __esm({
     init_shims2();
     checkFileSupport2 = () => {
       if (typeof File === "undefined") {
-        const { process: process2 } = globalThis;
-        const isOldNode = typeof process2?.versions?.node === "string" && parseInt(process2.versions.node.split(".")) < 20;
+        const { process: process3 } = globalThis;
+        const isOldNode = typeof process3?.versions?.node === "string" && parseInt(process3.versions.node.split(".")) < 20;
         throw new Error("`File` is not defined as a global, which is required for file uploads." + (isOldNode ? " Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`." : ""));
       }
     };
@@ -24338,7 +25761,7 @@ var EMPTY2, createPathTagFunction2, path14;
 var init_path2 = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/internal/utils/path.mjs"() {
     "use strict";
-    init_error3();
+    init_error4();
     EMPTY2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
     createPathTagFunction2 = (pathEncoder = encodeURIPath2) => function path18(statics, ...params) {
       if (statics.length === 1)
@@ -24423,10 +25846,10 @@ var init_messages3 = __esm({
 });
 
 // ../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/error.mjs
-var init_error4 = __esm({
+var init_error5 = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/error.mjs"() {
     "use strict";
-    init_error3();
+    init_error4();
   }
 });
 
@@ -24539,7 +25962,7 @@ function validateInputTools(tools) {
 var init_parser3 = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/lib/parser.mjs"() {
     "use strict";
-    init_error4();
+    init_error5();
   }
 });
 
@@ -24563,7 +25986,7 @@ var init_EventStream = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/lib/EventStream.mjs"() {
     "use strict";
     init_tslib2();
-    init_error4();
+    init_error5();
     EventStream = class {
       constructor() {
         _EventStream_instances.add(this);
@@ -24757,7 +26180,7 @@ var init_AbstractChatCompletionRunner = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/lib/AbstractChatCompletionRunner.mjs"() {
     "use strict";
     init_tslib2();
-    init_error4();
+    init_error5();
     init_parser3();
     init_chatCompletionUtils();
     init_EventStream();
@@ -25378,7 +26801,7 @@ var init_ChatCompletionStream = __esm({
     "use strict";
     init_tslib2();
     init_parser4();
-    init_error4();
+    init_error5();
     init_parser3();
     init_streaming4();
     init_AbstractChatCompletionRunner();
@@ -26579,7 +28002,7 @@ var toFloat32Array;
 var init_base64 = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/internal/utils/base64.mjs"() {
     "use strict";
-    init_error3();
+    init_error4();
     init_bytes2();
     toFloat32Array = (base64Str) => {
       if (typeof Buffer !== "undefined") {
@@ -26603,12 +28026,12 @@ var readEnv2;
 var init_env2 = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/internal/utils/env.mjs"() {
     "use strict";
-    readEnv2 = (env) => {
+    readEnv2 = (env2) => {
       if (typeof globalThis.process !== "undefined") {
-        return globalThis.process.env?.[env]?.trim() ?? void 0;
+        return globalThis.process.env?.[env2]?.trim() ?? void 0;
       }
       if (typeof globalThis.Deno !== "undefined") {
-        return globalThis.Deno.env?.get?.(env)?.trim();
+        return globalThis.Deno.env?.get?.(env2)?.trim();
       }
       return void 0;
     };
@@ -26638,7 +28061,7 @@ var init_AssistantStream = __esm({
     "use strict";
     init_tslib2();
     init_streaming4();
-    init_error4();
+    init_error5();
     init_EventStream();
     init_utils7();
     AssistantStream = class extends EventStream {
@@ -27892,7 +29315,7 @@ var init_files3 = __esm({
     init_pagination2();
     init_headers2();
     init_sleep2();
-    init_error4();
+    init_error5();
     init_uploads3();
     init_path2();
     Files3 = class extends APIResource2 {
@@ -28711,7 +30134,7 @@ function addOutputText(rsp) {
 var init_ResponsesParser = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/lib/ResponsesParser.mjs"() {
     "use strict";
-    init_error4();
+    init_error5();
     init_parser3();
   }
 });
@@ -28725,7 +30148,7 @@ var init_ResponseStream = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/lib/responses/ResponseStream.mjs"() {
     "use strict";
     init_tslib2();
-    init_error4();
+    init_error5();
     init_EventStream();
     init_ResponsesParser();
     ResponseStream = class _ResponseStream extends EventStream {
@@ -29863,7 +31286,7 @@ var init_webhooks = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/resources/webhooks/webhooks.mjs"() {
     "use strict";
     init_tslib2();
-    init_error4();
+    init_error5();
     init_resource2();
     init_headers2();
     Webhooks = class extends APIResource2 {
@@ -30004,7 +31427,7 @@ var init_client2 = __esm({
     init_request_options2();
     init_query2();
     init_version2();
-    init_error3();
+    init_error4();
     init_pagination2();
     init_uploads4();
     init_resources2();
@@ -30524,7 +31947,7 @@ var init_azure = __esm({
   "../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/azure.mjs"() {
     "use strict";
     init_headers2();
-    init_error4();
+    init_error5();
     init_utils7();
     init_client2();
   }
@@ -30539,7 +31962,7 @@ var init_openai = __esm({
     init_api_promise2();
     init_client2();
     init_pagination2();
-    init_error3();
+    init_error4();
     init_azure();
   }
 });
@@ -32030,15 +33453,15 @@ var require_runtime = __commonJS({
         throw new _exception2["default"]("Template was precompiled with a newer version of Handlebars than the current runtime. Please update your runtime to a newer version (" + compilerInfo[1] + ").");
       }
     }
-    function template(templateSpec, env) {
-      if (!env) {
+    function template(templateSpec, env2) {
+      if (!env2) {
         throw new _exception2["default"]("No environment passed to template");
       }
       if (!templateSpec || !templateSpec.main) {
         throw new _exception2["default"]("Unknown template object: " + typeof templateSpec);
       }
       templateSpec.main.decorator = templateSpec.main_d;
-      env.VM.checkRevision(templateSpec.compiler);
+      env2.VM.checkRevision(templateSpec.compiler);
       var templateWasPrecompiledWithCompilerV7 = templateSpec.compiler && templateSpec.compiler[0] === 7;
       function invokePartialWrapper(partial, context, options) {
         if (options.hash) {
@@ -32047,12 +33470,12 @@ var require_runtime = __commonJS({
             options.ids[0] = true;
           }
         }
-        partial = env.VM.resolvePartial.call(this, partial, context, options);
+        partial = env2.VM.resolvePartial.call(this, partial, context, options);
         options.hooks = this.hooks;
         options.protoAccessControl = this.protoAccessControl;
-        var result = env.VM.invokePartial.call(this, partial, context, options);
-        if (result == null && env.compile) {
-          options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env);
+        var result = env2.VM.invokePartial.call(this, partial, context, options);
+        if (result == null && env2.compile) {
+          options.partials[options.name] = env2.compile(partial, templateSpec.compilerOptions, env2);
           result = options.partials[options.name](context, options);
         }
         if (result != null) {
@@ -32137,7 +33560,7 @@ var require_runtime = __commonJS({
         },
         // An empty object to use as replacement for null-contexts
         nullContext: Object.seal({}),
-        noop: env.VM.noop,
+        noop: env2.VM.noop,
         compilerInfo: templateSpec.compiler
       };
       function ret(context) {
@@ -32165,14 +33588,14 @@ var require_runtime = __commonJS({
       ret._setup = function(options) {
         if (!options.partial) {
           var mergedHelpers = {};
-          addHelpers(mergedHelpers, env.helpers, container);
+          addHelpers(mergedHelpers, env2.helpers, container);
           addHelpers(mergedHelpers, options.helpers, container);
           container.helpers = mergedHelpers;
           if (templateSpec.usePartial) {
-            container.partials = container.mergeIfNeeded(options.partials, env.partials);
+            container.partials = container.mergeIfNeeded(options.partials, env2.partials);
           }
           if (templateSpec.usePartial || templateSpec.useDecorators) {
-            container.decorators = Utils.extend({}, env.decorators, options.decorators);
+            container.decorators = Utils.extend({}, env2.decorators, options.decorators);
           }
           container.hooks = {};
           container.protoAccessControl = _internalProtoAccess.createProtoAccessControl(options);
@@ -32671,7 +34094,7 @@ var require_parser = __commonJS({
         parseError: function parseError(str3, hash) {
           throw new Error(str3);
         },
-        parse: function parse4(input) {
+        parse: function parse2(input) {
           var self = this, stack = [0], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
           this.lexer.setInput(input);
           this.lexer.yy = this.yy;
@@ -33584,7 +35007,7 @@ var require_base2 = __commonJS({
     "use strict";
     exports2.__esModule = true;
     exports2.parseWithoutProcessing = parseWithoutProcessing;
-    exports2.parse = parse4;
+    exports2.parse = parse2;
     function _interopRequireWildcard(obj) {
       if (obj && obj.__esModule) {
         return obj;
@@ -33626,7 +35049,7 @@ var require_base2 = __commonJS({
       var ast = _parser2["default"].parse(input);
       return ast;
     }
-    function parse4(input, options) {
+    function parse2(input, options) {
       var ast = parseWithoutProcessing(input, options);
       var strip3 = new _whitespaceControl2["default"](options);
       return strip3.accept(ast);
@@ -34021,7 +35444,7 @@ var require_compiler = __commonJS({
         }
       }
     };
-    function precompile(input, options, env) {
+    function precompile(input, options, env2) {
       if (input == null || typeof input !== "string" && input.type !== "Program") {
         throw new _exception2["default"]("You must pass a string or Handlebars AST to Handlebars.precompile. You passed " + input);
       }
@@ -34032,10 +35455,10 @@ var require_compiler = __commonJS({
       if (options.compat) {
         options.useDepths = true;
       }
-      var ast = env.parse(input, options), environment = new env.Compiler().compile(ast, options);
-      return new env.JavaScriptCompiler().compile(environment, options);
+      var ast = env2.parse(input, options), environment = new env2.Compiler().compile(ast, options);
+      return new env2.JavaScriptCompiler().compile(environment, options);
     }
-    function compile2(input, options, env) {
+    function compile2(input, options, env2) {
       if (options === void 0) options = {};
       if (input == null || typeof input !== "string" && input.type !== "Program") {
         throw new _exception2["default"]("You must pass a string or Handlebars AST to Handlebars.compile. You passed " + input);
@@ -34049,8 +35472,8 @@ var require_compiler = __commonJS({
       }
       var compiled = void 0;
       function compileInput() {
-        var ast = env.parse(input, options), environment = new env.Compiler().compile(ast, options), templateSpec = new env.JavaScriptCompiler().compile(environment, options, void 0, true);
-        return env.template(templateSpec);
+        var ast = env2.parse(input, options), environment = new env2.Compiler().compile(ast, options), templateSpec = new env2.JavaScriptCompiler().compile(environment, options, void 0, true);
+        return env2.template(templateSpec);
       }
       function ret(context, execOptions) {
         if (!compiled) {
@@ -40459,7 +41882,7 @@ var init_liquid_node = __esm({
       TokenKind2[TokenKind2["Delimited"] = 12] = "Delimited";
     })(TokenKind || (TokenKind = {}));
     Context = class _Context {
-      constructor(env = {}, opts = defaultOptions2, renderOptions = {}, { memoryLimit, renderLimit } = {}) {
+      constructor(env2 = {}, opts = defaultOptions2, renderOptions = {}, { memoryLimit, renderLimit } = {}) {
         var _a5, _b, _c, _d, _e;
         this.scopes = [{}];
         this.registers = {};
@@ -40468,7 +41891,7 @@ var init_liquid_node = __esm({
         this.sync = !!renderOptions.sync;
         this.opts = opts;
         this.globals = (_a5 = renderOptions.globals) !== null && _a5 !== void 0 ? _a5 : opts.globals;
-        this.environments = isObject2(env) ? env : Object(env);
+        this.environments = isObject2(env2) ? env2 : Object(env2);
         this.strictVariables = (_b = renderOptions.strictVariables) !== null && _b !== void 0 ? _b : this.opts.strictVariables;
         this.ownPropertyOnly = (_c = renderOptions.ownPropertyOnly) !== null && _c !== void 0 ? _c : opts.ownPropertyOnly;
         this.memoryLimit = memoryLimit !== null && memoryLimit !== void 0 ? memoryLimit : new Limiter("memory alloc", (_d = renderOptions.memoryLimit) !== null && _d !== void 0 ? _d : opts.memoryLimit);
@@ -41919,13 +43342,12 @@ var init_aggregator_IUQUAVJC = __esm({
 });
 
 // ../notes/dist/chunk-Y4S5UWCL.js
-import * as TOML3 from "smol-toml";
 import * as fs33 from "fs";
 import * as path33 from "path";
 import { z as z23 } from "zod";
 import { z as z4 } from "zod";
 import * as fs24 from "fs";
-import * as os3 from "os";
+import * as os4 from "os";
 import * as path24 from "path";
 import * as fs43 from "fs";
 import * as fs93 from "fs";
@@ -41962,7 +43384,7 @@ function substituteVariables3(value) {
     return process.env[varName] ?? "";
   });
   result = result.replace(filePattern, (_, filePath) => {
-    const expandedPath = filePath.startsWith("~") ? path24.join(os3.homedir(), filePath.slice(1)) : filePath;
+    const expandedPath = filePath.startsWith("~") ? path24.join(os4.homedir(), filePath.slice(1)) : filePath;
     try {
       return fs24.readFileSync(expandedPath, "utf-8").trim();
     } catch {
@@ -43254,6 +44676,7 @@ var init_chunk_Y4S5UWCL = __esm({
   "../notes/dist/chunk-Y4S5UWCL.js"() {
     "use strict";
     init_chunk_7TJSPQPW();
+    init_dist();
     init_sdk();
     init_openai();
     init_openai();
@@ -43562,7 +44985,7 @@ var init_chunk_Y4S5UWCL = __esm({
     });
     MAX_INPUT_LENGTH3 = 1e4;
     SOLE_REFERENCE_PATTERN3 = /^\{(?:env|file):[^}]+\}$/;
-    AUTH_DIR3 = path24.join(os3.homedir(), ".config", "releasekit");
+    AUTH_DIR3 = path24.join(os4.homedir(), ".config", "releasekit");
     AUTH_FILE3 = path24.join(AUTH_DIR3, "auth.json");
     CONFIG_FILE3 = "releasekit.config.json";
     NotesError = class extends ReleaseKitError3 {
@@ -43849,8 +45272,8 @@ Summary (only output the summary, nothing else):`;
 });
 
 // ../notes/dist/index.js
-var dist_exports4 = {};
-__export(dist_exports4, {
+var dist_exports5 = {};
+__export(dist_exports5, {
   ConfigError: () => ConfigError22,
   GitHubError: () => GitHubError,
   InputParseError: () => InputParseError,
@@ -43912,7 +45335,7 @@ function writeJson(outputPath, contexts, dryRun) {
   fs14.writeFileSync(outputPath, content, "utf-8");
   success2(`JSON output written to ${outputPath}`);
 }
-var init_dist14 = __esm({
+var init_dist15 = __esm({
   "../notes/dist/index.js"() {
     "use strict";
     init_chunk_Y4S5UWCL();
@@ -43922,19 +45345,16 @@ var init_dist14 = __esm({
 });
 
 // ../publish/dist/chunk-OZHNJUFW.js
-import chalk5 from "chalk";
 import * as fs25 from "fs";
-import * as TOML4 from "smol-toml";
 import * as fs34 from "fs";
 import * as path34 from "path";
 import { z as z24 } from "zod";
 import { z as z5 } from "zod";
 import * as fs222 from "fs";
-import * as os4 from "os";
+import * as os5 from "os";
 import * as path222 from "path";
 import { execFile as execFile2 } from "child_process";
 import * as fs44 from "fs";
-import * as TOML23 from "smol-toml";
 import * as fs54 from "fs";
 import * as path44 from "path";
 import * as fs64 from "fs";
@@ -43972,7 +45392,7 @@ function info3(message) {
 }
 function success3(message) {
   if (!shouldLog4("info")) return;
-  console.error(chalk5.green(`[SUCCESS] ${message}`));
+  console.error(source_default.green(`[SUCCESS] ${message}`));
 }
 function debug2(message) {
   log6(message, "debug");
@@ -43982,7 +45402,7 @@ function sanitizePackageName2(name) {
 }
 function parseCargoToml2(cargoPath) {
   const content = fs25.readFileSync(cargoPath, "utf-8");
-  return TOML4.parse(content);
+  return parse(content);
 }
 function mergeGitConfig(topLevel, packageLevel) {
   if (!topLevel && !packageLevel) return void 0;
@@ -44023,7 +45443,7 @@ function substituteVariables4(value) {
     return process.env[varName] ?? "";
   });
   result = result.replace(filePattern, (_, filePath) => {
-    const expandedPath = filePath.startsWith("~") ? path222.join(os4.homedir(), filePath.slice(1)) : filePath;
+    const expandedPath = filePath.startsWith("~") ? path222.join(os5.homedir(), filePath.slice(1)) : filePath;
     try {
       return fs222.readFileSync(expandedPath, "utf-8").trim();
     } catch {
@@ -44469,7 +45889,7 @@ function updateCargoVersion2(cargoPath, newVersion) {
     const cargo = parseCargoToml2(cargoPath);
     if (cargo.package) {
       cargo.package.version = newVersion;
-      fs44.writeFileSync(cargoPath, TOML23.stringify(cargo));
+      fs44.writeFileSync(cargoPath, stringify(cargo));
     }
   } catch (error3) {
     throw createPublishError(
@@ -45461,6 +46881,9 @@ var import_semver6, LOG_LEVELS4, PREFIXES4, COLORS4, currentLevel4, quietMode4,
 var init_chunk_OZHNJUFW = __esm({
   "../publish/dist/chunk-OZHNJUFW.js"() {
     "use strict";
+    init_source();
+    init_dist();
+    init_dist();
     import_semver6 = __toESM(require_semver2(), 1);
     LOG_LEVELS4 = {
       error: 0,
@@ -45477,11 +46900,11 @@ var init_chunk_OZHNJUFW = __esm({
       trace: "[TRACE]"
     };
     COLORS4 = {
-      error: chalk5.red,
-      warn: chalk5.yellow,
-      info: chalk5.blue,
-      debug: chalk5.gray,
-      trace: chalk5.dim
+      error: source_default.red,
+      warn: source_default.yellow,
+      info: source_default.blue,
+      debug: source_default.gray,
+      trace: source_default.dim
     };
     currentLevel4 = "info";
     quietMode4 = false;
@@ -45817,7 +47240,7 @@ var init_chunk_OZHNJUFW = __esm({
     });
     MAX_INPUT_LENGTH4 = 1e4;
     SOLE_REFERENCE_PATTERN4 = /^\{(?:env|file):[^}]+\}$/;
-    AUTH_DIR4 = path222.join(os4.homedir(), ".config", "releasekit");
+    AUTH_DIR4 = path222.join(os5.homedir(), ".config", "releasekit");
     AUTH_FILE4 = path222.join(AUTH_DIR4, "auth.json");
     CONFIG_FILE4 = "releasekit.config.json";
     BasePublishError = class _BasePublishError extends ReleaseKitError4 {
@@ -45897,8 +47320,8 @@ var init_chunk_OZHNJUFW = __esm({
 });
 
 // ../publish/dist/index.js
-var dist_exports5 = {};
-__export(dist_exports5, {
+var dist_exports6 = {};
+__export(dist_exports6, {
   BasePublishError: () => BasePublishError,
   PipelineError: () => PipelineError,
   PublishError: () => PublishError,
@@ -45918,7 +47341,7 @@ __export(dist_exports5, {
   runPipeline: () => runPipeline2,
   updateCargoVersion: () => updateCargoVersion2
 });
-var init_dist15 = __esm({
+var init_dist16 = __esm({
   "../publish/dist/index.js"() {
     "use strict";
     init_chunk_OZHNJUFW();
@@ -45930,10 +47353,10 @@ import { realpathSync } from "fs";
 import { fileURLToPath as fileURLToPath4 } from "url";
 
 // ../core/dist/index.js
+init_source();
 import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
-import chalk from "chalk";
 function readPackageVersion(importMetaUrl) {
   try {
     const dir = path.dirname(fileURLToPath(importMetaUrl));
@@ -45959,11 +47382,11 @@ var PREFIXES = {
   trace: "[TRACE]"
 };
 var COLORS = {
-  error: chalk.red,
-  warn: chalk.yellow,
-  info: chalk.blue,
-  debug: chalk.gray,
-  trace: chalk.dim
+  error: source_default.red,
+  warn: source_default.yellow,
+  info: source_default.blue,
+  debug: source_default.gray,
+  trace: source_default.dim
 };
 var currentLevel = "info";
 var quietMode = false;
@@ -45995,7 +47418,7 @@ function info(message) {
 }
 function success(message) {
   if (!shouldLog("info")) return;
-  console.error(chalk.green(`[SUCCESS] ${message}`));
+  console.error(source_default.green(`[SUCCESS] ${message}`));
 }
 var ReleaseKitError = class _ReleaseKitError extends Error {
   constructor(message) {
@@ -46035,13 +47458,13 @@ import { Command as Command6 } from "commander";
 import { Command as Command4 } from "commander";
 
 // ../config/dist/index.js
-import * as TOML from "smol-toml";
+init_dist();
 import * as fs3 from "fs";
 import * as path3 from "path";
 import { z as z2 } from "zod";
 import { z } from "zod";
 import * as fs2 from "fs";
-import * as os from "os";
+import * as os2 from "os";
 import * as path2 from "path";
 var ConfigError = class extends ReleaseKitError {
   code = "CONFIG_ERROR";
@@ -46366,7 +47789,7 @@ function substituteVariables(value) {
     return process.env[varName] ?? "";
   });
   result = result.replace(filePattern, (_, filePath) => {
-    const expandedPath = filePath.startsWith("~") ? path2.join(os.homedir(), filePath.slice(1)) : filePath;
+    const expandedPath = filePath.startsWith("~") ? path2.join(os2.homedir(), filePath.slice(1)) : filePath;
     try {
       return fs2.readFileSync(expandedPath, "utf-8").trim();
     } catch {
@@ -46396,7 +47819,7 @@ function substituteInObject(obj) {
   }
   return obj;
 }
-var AUTH_DIR = path2.join(os.homedir(), ".config", "releasekit");
+var AUTH_DIR = path2.join(os2.homedir(), ".config", "releasekit");
 var AUTH_FILE = path2.join(AUTH_DIR, "auth.json");
 var CONFIG_FILE = "releasekit.config.json";
 function loadConfigFile(configPath) {
@@ -46776,7 +48199,7 @@ async function runRelease(inputOptions) {
     return null;
   }
   if (!options.dryRun) {
-    const { flushPendingWrites: flushPendingWrites2 } = await Promise.resolve().then(() => (init_dist13(), dist_exports3));
+    const { flushPendingWrites: flushPendingWrites2 } = await Promise.resolve().then(() => (init_dist14(), dist_exports4));
     flushPendingWrites2();
   }
   info(`Found ${versionOutput.updates.length} package update(s)`);
@@ -46805,7 +48228,7 @@ async function runRelease(inputOptions) {
   return { versionOutput, notesGenerated, packageNotes, releaseNotes, publishOutput };
 }
 async function runVersionStep(options) {
-  const { loadConfig: loadConfig5, VersionEngine: VersionEngine2, enableJsonOutput: enableJsonOutput2, getJsonData: getJsonData2 } = await Promise.resolve().then(() => (init_dist13(), dist_exports3));
+  const { loadConfig: loadConfig5, VersionEngine: VersionEngine2, enableJsonOutput: enableJsonOutput2, getJsonData: getJsonData2 } = await Promise.resolve().then(() => (init_dist14(), dist_exports4));
   enableJsonOutput2(options.dryRun);
   const config = loadConfig5({ cwd: options.projectDir, configPath: options.config });
   if (options.dryRun) config.dryRun = true;
@@ -46838,14 +48261,14 @@ async function runVersionStep(options) {
   return getJsonData2();
 }
 async function runNotesStep(versionOutput, options) {
-  const { parseVersionOutput: parseVersionOutput2, runPipeline: runPipeline3, loadConfig: loadConfig5 } = await Promise.resolve().then(() => (init_dist14(), dist_exports4));
+  const { parseVersionOutput: parseVersionOutput2, runPipeline: runPipeline3, loadConfig: loadConfig5 } = await Promise.resolve().then(() => (init_dist15(), dist_exports5));
   const config = loadConfig5(options.projectDir, options.config);
   const input = parseVersionOutput2(JSON.stringify(versionOutput));
   const result = await runPipeline3(input, config, options.dryRun);
   return { packageNotes: result.packageNotes, releaseNotes: result.releaseNotes, files: result.files };
 }
 async function runPublishStep(versionOutput, options, releaseNotes, additionalFiles) {
-  const { runPipeline: runPipeline3, loadConfig: loadConfig5 } = await Promise.resolve().then(() => (init_dist15(), dist_exports5));
+  const { runPipeline: runPipeline3, loadConfig: loadConfig5 } = await Promise.resolve().then(() => (init_dist16(), dist_exports6));
   const config = loadConfig5({ configPath: options.config });
   if (options.branch) {
     config.git.branch = options.branch;
@@ -47087,6 +48510,43 @@ export {
 };
 /*! Bundled license information:
 
+smol-toml/dist/error.js:
+smol-toml/dist/util.js:
+smol-toml/dist/date.js:
+smol-toml/dist/primitive.js:
+smol-toml/dist/extract.js:
+smol-toml/dist/struct.js:
+smol-toml/dist/parse.js:
+smol-toml/dist/stringify.js:
+smol-toml/dist/index.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+
 js-yaml/dist/js-yaml.mjs:
   (*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT *)