@releasekit/release 0.7.16 → 0.7.18

package/dist/dispatcher.js

@@ -40,8 +40,527 @@ 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;
+  }
+});
+
 // ../notes/dist/chunk-7TJSPQPW.js
-import chalk2 from "chalk";
 import * as fs2 from "fs";
 import * as path2 from "path";
 function setLogLevel2(level) {
@@ -70,7 +589,7 @@ function info2(message) {
 }
 function success2(message) {
   if (!shouldLog2("info")) return;
-  console.error(chalk2.green(`[SUCCESS] ${message}`));
+  console.error(source_default.green(`[SUCCESS] ${message}`));
 }
 function debug(message) {
   log2(message, "debug");
@@ -193,6 +712,7 @@ var LOG_LEVELS2, PREFIXES2, COLORS2, currentLevel2, quietMode2, ReleaseKitError2
 var init_chunk_7TJSPQPW = __esm({
   "../notes/dist/chunk-7TJSPQPW.js"() {
     "use strict";
+    init_source();
     LOG_LEVELS2 = {
       error: 0,
       warn: 1,
@@ -208,11 +728,11 @@ var init_chunk_7TJSPQPW = __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;
@@ -258,6 +778,909 @@ var init_chunk_7TJSPQPW = __esm({
   }
 });
 
+// ../../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();
+  }
+});
+
 // ../../node_modules/.pnpm/@anthropic-ai+sdk@0.82.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/internal/tslib.mjs
 function __classPrivateFieldSet(receiver, state, value, kind, f) {
   if (kind === "m")
@@ -338,7 +1761,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();
@@ -456,7 +1879,7 @@ var startsWithSchemeRegexp, isAbsoluteURL, isArray, isReadonlyArray, validatePos
 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);
@@ -748,7 +2171,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();
   }
 });
 
@@ -1002,7 +2425,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();
@@ -1010,7 +2433,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;
@@ -1259,7 +2682,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();
@@ -1273,7 +2696,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) => {
@@ -1343,8 +2766,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 {
@@ -1515,8 +2938,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`." : ""));
       }
     };
@@ -1783,7 +3206,7 @@ var EMPTY, createPathTagFunction, path3;
 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 path19(statics, ...params) {
       if (statics.length === 1)
@@ -2026,10 +3449,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();
   }
 });
 
@@ -2126,7 +3549,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();
   }
 });
 
@@ -2376,7 +3799,7 @@ var init_BetaMessageStream = __esm({
     "use strict";
     init_tslib();
     init_parser();
-    init_error2();
+    init_error3();
     init_errors();
     init_streaming2();
     init_beta_parser();
@@ -3078,7 +4501,7 @@ var init_BetaToolRunner = __esm({
     "use strict";
     init_tslib();
     init_ToolError();
-    init_error();
+    init_error2();
     init_headers();
     init_CompactionControl();
     init_stainless_helper_header();
@@ -3360,7 +4783,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 {
@@ -3405,7 +4828,7 @@ var init_batches = __esm({
     init_pagination();
     init_headers();
     init_jsonl();
-    init_error2();
+    init_error3();
     init_path();
     Batches = class extends APIResource {
       /**
@@ -3621,7 +5044,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();
@@ -4072,7 +5495,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();
   }
 });
 
@@ -4088,7 +5511,7 @@ var init_MessageStream = __esm({
     "use strict";
     init_tslib();
     init_errors();
-    init_error2();
+    init_error3();
     init_streaming2();
     init_parser();
     init_parser2();
@@ -4663,7 +6086,7 @@ var init_batches2 = __esm({
     init_pagination();
     init_headers();
     init_jsonl();
-    init_error2();
+    init_error3();
     init_path();
     Batches2 = class extends APIResource {
       /**
@@ -4998,12 +6421,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;
     };
@@ -5025,7 +6448,7 @@ var init_client = __esm({
     init_request_options();
     init_query();
     init_version();
-    init_error();
+    init_error2();
     init_pagination();
     init_uploads2();
     init_resources();
@@ -5516,7 +6939,7 @@ var init_sdk = __esm({
     init_api_promise();
     init_client();
     init_pagination();
-    init_error();
+    init_error2();
   }
 });
 
@@ -5600,7 +7023,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();
@@ -5738,7 +7161,7 @@ var startsWithSchemeRegexp2, isAbsoluteURL2, isArray2, isReadonlyArray2, 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);
@@ -6292,7 +7715,7 @@ function normalize_stringify_options(opts = defaults) {
     strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling
   };
 }
-function stringify(object, opts = {}) {
+function stringify2(object, opts = {}) {
   let obj = object;
   const options = normalize_stringify_options(opts);
   let obj_keys;
@@ -6356,7 +7779,7 @@ function stringify(object, opts = {}) {
   return joined.length > 0 ? prefix + joined : "";
 }
 var array_prefix_generators, push_to_array, toISOString, defaults, 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_utils();
@@ -6405,12 +7828,12 @@ var init_stringify = __esm({
 
 // ../../node_modules/.pnpm/openai@6.33.0_zod@4.3.6/node_modules/openai/internal/utils/query.mjs
 function stringifyQuery2(query) {
-  return stringify(query, { arrayFormat: "brackets" });
+  return stringify2(query, { arrayFormat: "brackets" });
 }
 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();
   }
 });
 
@@ -6664,14 +8087,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;
@@ -6927,7 +8350,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();
@@ -6941,7 +8364,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) => {
@@ -7011,8 +8434,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 {
@@ -7181,8 +8604,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`." : ""));
       }
     };
@@ -7333,7 +8756,7 @@ var EMPTY2, createPathTagFunction2, path4;
 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 path19(statics, ...params) {
       if (statics.length === 1)
@@ -7418,10 +8841,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();
   }
 });
 
@@ -7534,7 +8957,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();
   }
 });
 
@@ -7558,7 +8981,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);
@@ -7752,7 +9175,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();
@@ -8373,7 +9796,7 @@ var init_ChatCompletionStream = __esm({
     "use strict";
     init_tslib2();
     init_parser4();
-    init_error4();
+    init_error5();
     init_parser3();
     init_streaming4();
     init_AbstractChatCompletionRunner();
@@ -9574,7 +10997,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") {
@@ -9598,12 +11021,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;
     };
@@ -9633,7 +11056,7 @@ var init_AssistantStream = __esm({
     "use strict";
     init_tslib2();
     init_streaming4();
-    init_error4();
+    init_error5();
     init_EventStream();
     init_utils2();
     AssistantStream = class extends EventStream {
@@ -10887,7 +12310,7 @@ var init_files3 = __esm({
     init_pagination2();
     init_headers2();
     init_sleep2();
-    init_error4();
+    init_error5();
     init_uploads3();
     init_path2();
     Files3 = class extends APIResource2 {
@@ -11706,7 +13129,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();
   }
 });
@@ -11720,7 +13143,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 {
@@ -12858,7 +14281,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 {
@@ -12999,7 +14422,7 @@ var init_client2 = __esm({
     init_request_options2();
     init_query2();
     init_version2();
-    init_error3();
+    init_error4();
     init_pagination2();
     init_uploads4();
     init_resources2();
@@ -13519,7 +14942,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_utils2();
     init_client2();
   }
@@ -13534,7 +14957,7 @@ var init_openai = __esm({
     init_api_promise2();
     init_client2();
     init_pagination2();
-    init_error3();
+    init_error4();
     init_azure();
   }
 });
@@ -15025,15 +16448,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) {
@@ -15042,12 +16465,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) {
@@ -15132,7 +16555,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) {
@@ -15160,14 +16583,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);
@@ -15666,7 +17089,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;
@@ -16579,7 +18002,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;
@@ -16621,7 +18044,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);
@@ -17016,7 +18439,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);
       }
@@ -17027,10 +18450,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);
@@ -17044,8 +18467,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) {
@@ -20148,14 +21571,14 @@ function promisify(fn) {
     });
   };
 }
-function stringify2(value) {
+function stringify3(value) {
   value = toValue(value);
   if (isString(value))
     return value;
   if (isNil(value))
     return "";
   if (isArray3(value))
-    return value.map((x) => stringify2(x)).join("");
+    return value.map((x) => stringify3(x)).join("");
   return String(value);
 }
 function toEnumerable(val) {
@@ -20701,7 +22124,7 @@ function to_integer(value) {
   return Number(value);
 }
 function escape2(str3) {
-  str3 = stringify2(str3);
+  str3 = stringify3(str3);
   this.context.memoryLimit.use(str3.length);
   return str3.replace(/&|<|>|"|'/g, (m) => escapeMap[m]);
 }
@@ -20709,7 +22132,7 @@ function xml_escape(str3) {
   return escape2.call(this, str3);
 }
 function unescape2(str3) {
-  str3 = stringify2(str3);
+  str3 = stringify3(str3);
   this.context.memoryLimit.use(str3.length);
   return str3.replace(/&(amp|lt|gt|#34|#39);/g, (m) => unescapeMap[m]);
 }
@@ -20717,12 +22140,12 @@ function escape_once(str3) {
   return escape2.call(this, unescape2.call(this, str3));
 }
 function newline_to_br(v) {
-  const str3 = stringify2(v);
+  const str3 = stringify3(v);
   this.context.memoryLimit.use(str3.length);
   return str3.replace(/\r?\n/gm, "<br />\n");
 }
 function strip_html(v) {
-  const str3 = stringify2(v);
+  const str3 = stringify3(v);
   this.context.memoryLimit.use(str3.length);
   return str3.replace(/<script[\s\S]*?<\/script>|<style[\s\S]*?<\/style>|<.*?>|<!--[\s\S]*?-->/g, "");
 }
@@ -21081,7 +22504,7 @@ function round(v, arg = 0) {
   return Math.round(v * amp) / amp;
 }
 function slugify(str3, mode = "default", cased = false) {
-  str3 = stringify2(str3);
+  str3 = stringify3(str3);
   const replacer = rSlugifyReplacers[mode];
   if (replacer) {
     if (mode === "latin")
@@ -21100,7 +22523,7 @@ function* sort(arr, property) {
   for (const item of array) {
     values.push([
       item,
-      property ? yield this.context._getFromScope(item, stringify2(property).split("."), false) : item
+      property ? yield this.context._getFromScope(item, stringify3(property).split("."), false) : item
     ]);
   }
   return values.sort((lhs, rhs) => {
@@ -21110,7 +22533,7 @@ function* sort(arr, property) {
   }).map((tuple) => tuple[0]);
 }
 function sort_natural(input, property) {
-  const propertyString = stringify2(property);
+  const propertyString = stringify3(property);
   const compare = property === void 0 ? caseInsensitiveCompare : (lhs, rhs) => caseInsensitiveCompare(lhs[propertyString], rhs[propertyString]);
   const array = toArray(input);
   this.context.memoryLimit.use(array.length);
@@ -21121,7 +22544,7 @@ function* map(arr, property) {
   const array = toArray(arr);
   this.context.memoryLimit.use(array.length);
   for (const item of array) {
-    results.push(yield this.context._getFromScope(item, stringify2(property), false));
+    results.push(yield this.context._getFromScope(item, stringify3(property), false));
   }
   return results;
 }
@@ -21129,7 +22552,7 @@ function* sum(arr, property) {
   let sum2 = 0;
   const array = toArray(arr);
   for (const item of array) {
-    const data = Number(property ? yield this.context._getFromScope(item, stringify2(property), false) : item);
+    const data = Number(property ? yield this.context._getFromScope(item, stringify3(property), false) : item);
     sum2 += Number.isNaN(data) ? 0 : data;
   }
   return sum2;
@@ -21172,7 +22595,7 @@ function slice(v, begin, length = 1) {
   if (isNil(v))
     return [];
   if (!isArray3(v))
-    v = stringify2(v);
+    v = stringify3(v);
   begin = begin < 0 ? v.length + begin : begin;
   this.context.memoryLimit.use(length);
   return v.slice(begin, begin + length);
@@ -21190,7 +22613,7 @@ function* filter(include, arr, property, expected) {
   const values = [];
   arr = toArray(arr);
   this.context.memoryLimit.use(arr.length);
-  const token = new Tokenizer(stringify2(property)).readScopeValue();
+  const token = new Tokenizer(stringify3(property)).readScopeValue();
   for (const item of arr) {
     values.push(yield evalToken(token, this.context.spawn(item)));
   }
@@ -21199,7 +22622,7 @@ function* filter(include, arr, property, expected) {
 }
 function* filter_exp(include, arr, itemName, exp) {
   const filtered = [];
-  const keyTemplate = new Value(stringify2(exp), this.liquid);
+  const keyTemplate = new Value(stringify3(exp), this.liquid);
   const array = toArray(arr);
   this.context.memoryLimit.use(array.length);
   for (const item of array) {
@@ -21226,7 +22649,7 @@ function* reject_exp(arr, itemName, exp) {
 function* group_by(arr, property) {
   const map3 = /* @__PURE__ */ new Map();
   arr = toEnumerable(arr);
-  const token = new Tokenizer(stringify2(property)).readScopeValue();
+  const token = new Tokenizer(stringify3(property)).readScopeValue();
   this.context.memoryLimit.use(arr.length);
   for (const item of arr) {
     const key = yield evalToken(token, this.context.spawn(item));
@@ -21238,7 +22661,7 @@ function* group_by(arr, property) {
 }
 function* group_by_exp(arr, itemName, exp) {
   const map3 = /* @__PURE__ */ new Map();
-  const keyTemplate = new Value(stringify2(exp), this.liquid);
+  const keyTemplate = new Value(stringify3(exp), this.liquid);
   arr = toEnumerable(arr);
   this.context.memoryLimit.use(arr.length);
   for (const item of arr) {
@@ -21252,7 +22675,7 @@ function* group_by_exp(arr, itemName, exp) {
   return [...map3.entries()].map(([name, items]) => ({ name, items }));
 }
 function* search(arr, property, expected) {
-  const token = new Tokenizer(stringify2(property)).readScopeValue();
+  const token = new Tokenizer(stringify3(property)).readScopeValue();
   const array = toArray(arr);
   const matcher = expectedMatcher.call(this, expected);
   for (let index = 0; index < array.length; index++) {
@@ -21262,7 +22685,7 @@ function* search(arr, property, expected) {
   }
 }
 function* search_exp(arr, itemName, exp) {
-  const predicate = new Value(stringify2(exp), this.liquid);
+  const predicate = new Value(stringify3(exp), this.liquid);
   const array = toArray(arr);
   for (let index = 0; index < array.length; index++) {
     this.context.push({ [itemName]: array[index] });
@@ -21306,7 +22729,7 @@ function sample(v, count = 1) {
   if (isNil(v))
     return [];
   if (!isArray3(v))
-    v = stringify2(v);
+    v = stringify3(v);
   this.context.memoryLimit.use(count);
   const shuffled = [...v].sort(() => Math.random() - 0.5);
   if (count === 1)
@@ -21321,7 +22744,7 @@ function date(v, format2, timezoneOffset) {
   if (!date2)
     return v;
   format2 = toValue(format2);
-  format2 = isNil(format2) ? this.context.opts.dateFormat : stringify2(format2);
+  format2 = isNil(format2) ? this.context.opts.dateFormat : stringify3(format2);
   return strftime(date2, format2);
 }
 function date_to_xmlschema(v) {
@@ -21370,23 +22793,23 @@ function parseDate(v, opts, timezoneOffset) {
 }
 function append(v, arg) {
   assert(arguments.length === 2, "append expect 2 arguments");
-  const lhs = stringify2(v);
-  const rhs = stringify2(arg);
+  const lhs = stringify3(v);
+  const rhs = stringify3(arg);
   this.context.memoryLimit.use(lhs.length + rhs.length);
   return lhs + rhs;
 }
 function prepend(v, arg) {
   assert(arguments.length === 2, "prepend expect 2 arguments");
-  const lhs = stringify2(v);
-  const rhs = stringify2(arg);
+  const lhs = stringify3(v);
+  const rhs = stringify3(arg);
   this.context.memoryLimit.use(lhs.length + rhs.length);
   return rhs + lhs;
 }
 function lstrip(v, chars) {
-  const str3 = stringify2(v);
+  const str3 = stringify3(v);
   this.context.memoryLimit.use(str3.length);
   if (chars) {
-    chars = stringify2(chars);
+    chars = stringify3(chars);
     this.context.memoryLimit.use(chars.length);
     for (let i = 0, set2 = new Set(chars); i < str3.length; i++) {
       if (!set2.has(str3[i]))
@@ -21397,30 +22820,30 @@ function lstrip(v, chars) {
   return str3.trimStart();
 }
 function downcase(v) {
-  const str3 = stringify2(v);
+  const str3 = stringify3(v);
   this.context.memoryLimit.use(str3.length);
   return str3.toLowerCase();
 }
 function upcase(v) {
-  const str3 = stringify2(v);
+  const str3 = stringify3(v);
   this.context.memoryLimit.use(str3.length);
-  return stringify2(str3).toUpperCase();
+  return stringify3(str3).toUpperCase();
 }
 function remove(v, arg) {
-  const str3 = stringify2(v);
-  arg = stringify2(arg);
+  const str3 = stringify3(v);
+  arg = stringify3(arg);
   this.context.memoryLimit.use(str3.length + arg.length);
   return str3.split(arg).join("");
 }
 function remove_first(v, l) {
-  const str3 = stringify2(v);
-  l = stringify2(l);
+  const str3 = stringify3(v);
+  l = stringify3(l);
   this.context.memoryLimit.use(str3.length + l.length);
   return str3.replace(l, "");
 }
 function remove_last(v, l) {
-  const str3 = stringify2(v);
-  const pattern = stringify2(l);
+  const str3 = stringify3(v);
+  const pattern = stringify3(l);
   this.context.memoryLimit.use(str3.length + pattern.length);
   const index = str3.lastIndexOf(pattern);
   if (index === -1)
@@ -21428,10 +22851,10 @@ function remove_last(v, l) {
   return str3.substring(0, index) + str3.substring(index + pattern.length);
 }
 function rstrip(str3, chars) {
-  str3 = stringify2(str3);
+  str3 = stringify3(str3);
   this.context.memoryLimit.use(str3.length);
   if (chars) {
-    chars = stringify2(chars);
+    chars = stringify3(chars);
     this.context.memoryLimit.use(chars.length);
     for (let i = str3.length - 1, set2 = new Set(chars); i >= 0; i--) {
       if (!set2.has(str3[i]))
@@ -21442,18 +22865,18 @@ function rstrip(str3, chars) {
   return str3.trimEnd();
 }
 function split(v, arg) {
-  const str3 = stringify2(v);
+  const str3 = stringify3(v);
   this.context.memoryLimit.use(str3.length);
-  const arr = str3.split(stringify2(arg));
+  const arr = str3.split(stringify3(arg));
   while (arr.length && arr[arr.length - 1] === "")
     arr.pop();
   return arr;
 }
 function strip2(v, chars) {
-  const str3 = stringify2(v);
+  const str3 = stringify3(v);
   this.context.memoryLimit.use(str3.length);
   if (chars) {
-    const set2 = new Set(stringify2(chars));
+    const set2 = new Set(stringify3(chars));
     this.context.memoryLimit.use(set2.size);
     let i = 0;
     let j = str3.length - 1;
@@ -21466,33 +22889,33 @@ function strip2(v, chars) {
   return str3.trim();
 }
 function strip_newlines(v) {
-  const str3 = stringify2(v);
+  const str3 = stringify3(v);
   this.context.memoryLimit.use(str3.length);
   return str3.replace(/\r?\n/gm, "");
 }
 function capitalize(str3) {
-  str3 = stringify2(str3);
+  str3 = stringify3(str3);
   this.context.memoryLimit.use(str3.length);
   return str3.charAt(0).toUpperCase() + str3.slice(1).toLowerCase();
 }
 function replace(v, pattern, replacement) {
-  const str3 = stringify2(v);
-  pattern = stringify2(pattern);
-  replacement = stringify2(replacement);
+  const str3 = stringify3(v);
+  pattern = stringify3(pattern);
+  replacement = stringify3(replacement);
   this.context.memoryLimit.use(str3.length + pattern.length + replacement.length);
   return str3.split(pattern).join(replacement);
 }
 function replace_first(v, arg1, arg2) {
-  const str3 = stringify2(v);
-  arg1 = stringify2(arg1);
-  arg2 = stringify2(arg2);
+  const str3 = stringify3(v);
+  arg1 = stringify3(arg1);
+  arg2 = stringify3(arg2);
   this.context.memoryLimit.use(str3.length + arg1.length + arg2.length);
   return str3.replace(arg1, () => arg2);
 }
 function replace_last(v, arg1, arg2) {
-  const str3 = stringify2(v);
-  const pattern = stringify2(arg1);
-  const replacement = stringify2(arg2);
+  const str3 = stringify3(v);
+  const pattern = stringify3(arg1);
+  const replacement = stringify3(arg2);
   this.context.memoryLimit.use(str3.length + pattern.length + replacement.length);
   const index = str3.lastIndexOf(pattern);
   if (index === -1)
@@ -21500,16 +22923,16 @@ function replace_last(v, arg1, arg2) {
   return str3.substring(0, index) + replacement + str3.substring(index + pattern.length);
 }
 function truncate(v, l = 50, o = "...") {
-  const str3 = stringify2(v);
-  o = stringify2(o);
+  const str3 = stringify3(v);
+  o = stringify3(o);
   this.context.memoryLimit.use(str3.length + o.length);
   if (str3.length <= l)
     return v;
   return str3.substring(0, l - o.length) + o;
 }
 function truncatewords(v, words = 15, o = "...") {
-  const str3 = stringify2(v);
-  o = stringify2(o);
+  const str3 = stringify3(v);
+  o = stringify3(o);
   this.context.memoryLimit.use(str3.length + o.length);
   const arr = str3.split(/\s+/);
   if (words <= 0)
@@ -21520,12 +22943,12 @@ function truncatewords(v, words = 15, o = "...") {
   return ret;
 }
 function normalize_whitespace(v) {
-  const str3 = stringify2(v);
+  const str3 = stringify3(v);
   this.context.memoryLimit.use(str3.length);
   return str3.replace(/\s+/g, " ");
 }
 function number_of_words(input, mode) {
-  const str3 = stringify2(input);
+  const str3 = stringify3(input);
   this.context.memoryLimit.use(str3.length);
   input = str3.trim();
   if (!input)
@@ -21540,7 +22963,7 @@ function number_of_words(input, mode) {
   }
 }
 function array_to_sentence_string(array, connector = "and") {
-  connector = stringify2(connector);
+  connector = stringify3(connector);
   this.context.memoryLimit.use(array.length + connector.length);
   switch (array.length) {
     case 0:
@@ -21560,12 +22983,12 @@ function base64Decode(str3) {
   return Buffer.from(str3, "base64").toString("utf8");
 }
 function base64_encode(value) {
-  const str3 = stringify2(value);
+  const str3 = stringify3(value);
   this.context.memoryLimit.use(str3.length);
   return base64Encode(str3);
 }
 function base64_decode(value) {
-  const str3 = stringify2(value);
+  const str3 = stringify3(value);
   this.context.memoryLimit.use(str3.length);
   return base64Decode(str3);
 }
@@ -21837,7 +23260,7 @@ var init_liquid_node = __esm({
         this.buffer = "";
       }
       write(html) {
-        this.buffer += stringify2(html);
+        this.buffer += stringify3(html);
       }
     };
     StreamedEmitter = class {
@@ -21846,7 +23269,7 @@ var init_liquid_node = __esm({
         this.stream = new PassThrough();
       }
       write(html) {
-        this.stream.write(stringify2(html));
+        this.stream.write(stringify3(html));
       }
       error(err) {
         this.stream.emit("error", err);
@@ -21864,7 +23287,7 @@ var init_liquid_node = __esm({
         if (typeof html !== "string" && this.buffer === "") {
           this.buffer = html;
         } else {
-          this.buffer = stringify2(this.buffer) + stringify2(html);
+          this.buffer = stringify3(this.buffer) + stringify3(html);
         }
       }
     };
@@ -23454,7 +24877,7 @@ var init_liquid_node = __esm({
       TokenKind2[TokenKind2["Delimited"] = 12] = "Delimited";
     })(TokenKind || (TokenKind = {}));
     Context = class _Context {
-      constructor(env = {}, opts = defaultOptions, renderOptions = {}, { memoryLimit, renderLimit } = {}) {
+      constructor(env2 = {}, opts = defaultOptions, renderOptions = {}, { memoryLimit, renderLimit } = {}) {
         var _a5, _b, _c, _d, _e;
         this.scopes = [{}];
         this.registers = {};
@@ -23463,7 +24886,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 = isObject(env) ? env : Object(env);
+        this.environments = isObject(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);
@@ -23592,10 +25015,10 @@ var init_liquid_node = __esm({
       times,
       round
     });
-    url_decode = (x) => decodeURIComponent(stringify2(x)).replace(/\+/g, " ");
-    url_encode = (x) => encodeURIComponent(stringify2(x)).replace(/%20/g, "+");
-    cgi_escape = (x) => encodeURIComponent(stringify2(x)).replace(/%20/g, "+").replace(/[!'()*]/g, (c) => "%" + c.charCodeAt(0).toString(16).toUpperCase());
-    uri_escape = (x) => encodeURI(stringify2(x)).replace(/%5B/g, "[").replace(/%5D/g, "]");
+    url_decode = (x) => decodeURIComponent(stringify3(x)).replace(/\+/g, " ");
+    url_encode = (x) => encodeURIComponent(stringify3(x)).replace(/%20/g, "+");
+    cgi_escape = (x) => encodeURIComponent(stringify3(x)).replace(/%20/g, "+").replace(/[!'()*]/g, (c) => "%" + c.charCodeAt(0).toString(16).toUpperCase());
+    uri_escape = (x) => encodeURI(stringify3(x)).replace(/%5B/g, "[").replace(/%5D/g, "]");
     rSlugifyDefault = /[^\p{M}\p{L}\p{Nd}]+/ug;
     rSlugifyReplacers = {
       "raw": /\s+/g,
@@ -23615,7 +25038,7 @@ var init_liquid_node = __esm({
     });
     join = argumentsToValue(function(v, arg) {
       const array = toArray(v);
-      const sep4 = isNil(arg) ? " " : stringify2(arg);
+      const sep4 = isNil(arg) ? " " : stringify3(arg);
       const complexity = array.length * (1 + sep4.length);
       this.context.memoryLimit.use(complexity);
       return array.join(sep4);
@@ -24104,7 +25527,7 @@ var init_liquid_node = __esm({
         if (!isNumber(scope[this.variable])) {
           scope[this.variable] = 0;
         }
-        emitter.write(stringify2(--scope[this.variable]));
+        emitter.write(stringify3(--scope[this.variable]));
       }
       *localScope() {
         yield this.identifier;
@@ -24211,7 +25634,7 @@ var init_liquid_node = __esm({
         }
         const val = scope[this.variable];
         scope[this.variable]++;
-        emitter.write(stringify2(val));
+        emitter.write(stringify3(val));
       }
       *localScope() {
         yield this.identifier;
@@ -24914,13 +26337,12 @@ var init_aggregator_IUQUAVJC = __esm({
 });
 
 // ../notes/dist/chunk-Y4S5UWCL.js
-import * as TOML from "smol-toml";
 import * as fs32 from "fs";
 import * as path32 from "path";
 import { z as z2 } from "zod";
 import { z } from "zod";
 import * as fs22 from "fs";
-import * as os from "os";
+import * as os2 from "os";
 import * as path22 from "path";
 import * as fs42 from "fs";
 import * as fs9 from "fs";
@@ -24957,7 +26379,7 @@ function substituteVariables(value) {
     return process.env[varName] ?? "";
   });
   result = result.replace(filePattern, (_, filePath) => {
-    const expandedPath = filePath.startsWith("~") ? path22.join(os.homedir(), filePath.slice(1)) : filePath;
+    const expandedPath = filePath.startsWith("~") ? path22.join(os2.homedir(), filePath.slice(1)) : filePath;
     try {
       return fs22.readFileSync(expandedPath, "utf-8").trim();
     } catch {
@@ -26249,6 +27671,7 @@ var init_chunk_Y4S5UWCL = __esm({
   "../notes/dist/chunk-Y4S5UWCL.js"() {
     "use strict";
     init_chunk_7TJSPQPW();
+    init_dist();
     init_sdk();
     init_openai();
     init_openai();
@@ -26557,7 +27980,7 @@ var init_chunk_Y4S5UWCL = __esm({
     });
     MAX_INPUT_LENGTH = 1e4;
     SOLE_REFERENCE_PATTERN = /^\{(?:env|file):[^}]+\}$/;
-    AUTH_DIR = path22.join(os.homedir(), ".config", "releasekit");
+    AUTH_DIR = path22.join(os2.homedir(), ".config", "releasekit");
     AUTH_FILE = path22.join(AUTH_DIR, "auth.json");
     CONFIG_FILE = "releasekit.config.json";
     NotesError = class extends ReleaseKitError2 {
@@ -26844,8 +28267,8 @@ Summary (only output the summary, nothing else):`;
 });
 
 // ../notes/dist/index.js
-var dist_exports = {};
-__export(dist_exports, {
+var dist_exports2 = {};
+__export(dist_exports2, {
   ConfigError: () => ConfigError2,
   GitHubError: () => GitHubError,
   InputParseError: () => InputParseError,
@@ -26907,7 +28330,7 @@ function writeJson(outputPath, contexts, dryRun) {
   fs11.writeFileSync(outputPath, content, "utf-8");
   success2(`JSON output written to ${outputPath}`);
 }
-var init_dist = __esm({
+var init_dist2 = __esm({
   "../notes/dist/index.js"() {
     "use strict";
     init_chunk_Y4S5UWCL();
@@ -27374,7 +28797,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;
       }
@@ -27387,7 +28810,7 @@ var require_parse = __commonJS({
         throw er;
       }
     };
-    module2.exports = parse4;
+    module2.exports = parse2;
   }
 });
 
@@ -27395,9 +28818,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;
@@ -27408,9 +28831,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;
@@ -27445,10 +28868,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;
@@ -27519,9 +28942,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;
@@ -27707,7 +29130,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) {
@@ -27742,7 +29165,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;
   }
@@ -28759,7 +30182,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();
@@ -28797,7 +30220,7 @@ var require_semver2 = __commonJS({
     var simplifyRange = require_simplify();
     var subset = require_subset();
     module2.exports = {
-      parse: parse4,
+      parse: parse2,
       valid,
       clean,
       inc,
@@ -28847,19 +30270,16 @@ var require_semver2 = __commonJS({
 });
 
 // ../publish/dist/chunk-OZHNJUFW.js
-import chalk3 from "chalk";
 import * as fs23 from "fs";
-import * as TOML2 from "smol-toml";
 import * as fs33 from "fs";
 import * as path33 from "path";
 import { z as z22 } from "zod";
 import { z as z3 } from "zod";
 import * as fs222 from "fs";
-import * as os2 from "os";
+import * as os3 from "os";
 import * as path222 from "path";
 import { execFile } from "child_process";
 import * as fs43 from "fs";
-import * as TOML22 from "smol-toml";
 import * as fs53 from "fs";
 import * as path43 from "path";
 import * as fs62 from "fs";
@@ -28897,7 +30317,7 @@ function info3(message) {
 }
 function success3(message) {
   if (!shouldLog3("info")) return;
-  console.error(chalk3.green(`[SUCCESS] ${message}`));
+  console.error(source_default.green(`[SUCCESS] ${message}`));
 }
 function debug2(message) {
   log3(message, "debug");
@@ -28907,7 +30327,7 @@ function sanitizePackageName(name) {
 }
 function parseCargoToml(cargoPath) {
   const content = fs23.readFileSync(cargoPath, "utf-8");
-  return TOML2.parse(content);
+  return parse(content);
 }
 function mergeGitConfig(topLevel, packageLevel) {
   if (!topLevel && !packageLevel) return void 0;
@@ -28948,7 +30368,7 @@ function substituteVariables2(value) {
     return process.env[varName] ?? "";
   });
   result = result.replace(filePattern, (_, filePath) => {
-    const expandedPath = filePath.startsWith("~") ? path222.join(os2.homedir(), filePath.slice(1)) : filePath;
+    const expandedPath = filePath.startsWith("~") ? path222.join(os3.homedir(), filePath.slice(1)) : filePath;
     try {
       return fs222.readFileSync(expandedPath, "utf-8").trim();
     } catch {
@@ -29394,7 +30814,7 @@ function updateCargoVersion(cargoPath, newVersion) {
     const cargo = parseCargoToml(cargoPath);
     if (cargo.package) {
       cargo.package.version = newVersion;
-      fs43.writeFileSync(cargoPath, TOML22.stringify(cargo));
+      fs43.writeFileSync(cargoPath, stringify(cargo));
     }
   } catch (error3) {
     throw createPublishError(
@@ -30386,6 +31806,9 @@ var import_semver, LOG_LEVELS3, PREFIXES3, COLORS3, currentLevel3, quietMode3, R
 var init_chunk_OZHNJUFW = __esm({
   "../publish/dist/chunk-OZHNJUFW.js"() {
     "use strict";
+    init_source();
+    init_dist();
+    init_dist();
     import_semver = __toESM(require_semver2(), 1);
     LOG_LEVELS3 = {
       error: 0,
@@ -30402,11 +31825,11 @@ var init_chunk_OZHNJUFW = __esm({
       trace: "[TRACE]"
     };
     COLORS3 = {
-      error: chalk3.red,
-      warn: chalk3.yellow,
-      info: chalk3.blue,
-      debug: chalk3.gray,
-      trace: chalk3.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;
@@ -30742,7 +32165,7 @@ var init_chunk_OZHNJUFW = __esm({
     });
     MAX_INPUT_LENGTH2 = 1e4;
     SOLE_REFERENCE_PATTERN2 = /^\{(?:env|file):[^}]+\}$/;
-    AUTH_DIR2 = path222.join(os2.homedir(), ".config", "releasekit");
+    AUTH_DIR2 = path222.join(os3.homedir(), ".config", "releasekit");
     AUTH_FILE2 = path222.join(AUTH_DIR2, "auth.json");
     CONFIG_FILE2 = "releasekit.config.json";
     BasePublishError = class _BasePublishError extends ReleaseKitError3 {
@@ -30822,8 +32245,8 @@ var init_chunk_OZHNJUFW = __esm({
 });
 
 // ../publish/dist/index.js
-var dist_exports2 = {};
-__export(dist_exports2, {
+var dist_exports3 = {};
+__export(dist_exports3, {
   BasePublishError: () => BasePublishError,
   PipelineError: () => PipelineError,
   PublishError: () => PublishError,
@@ -30843,7 +32266,7 @@ __export(dist_exports2, {
   runPipeline: () => runPipeline2,
   updateCargoVersion: () => updateCargoVersion
 });
-var init_dist2 = __esm({
+var init_dist3 = __esm({
   "../publish/dist/index.js"() {
     "use strict";
     init_chunk_OZHNJUFW();
@@ -30851,7 +32274,6 @@ var init_dist2 = __esm({
 });
 
 // ../version/dist/chunk-Q3FHZORY.js
-import chalk4 from "chalk";
 function shouldLog4(level) {
   if (quietMode4 && level !== "error") return false;
   return LOG_LEVELS4[level] <= LOG_LEVELS4[currentLevel4];
@@ -30868,6 +32290,7 @@ var LOG_LEVELS4, PREFIXES4, COLORS4, currentLevel4, quietMode4, ReleaseKitError4
 var init_chunk_Q3FHZORY = __esm({
   "../version/dist/chunk-Q3FHZORY.js"() {
     "use strict";
+    init_source();
     LOG_LEVELS4 = {
       error: 0,
       warn: 1,
@@ -30883,11 +32306,11 @@ var init_chunk_Q3FHZORY = __esm({
       trace: "[TRACE]"
     };
     COLORS4 = {
-      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
     };
     currentLevel4 = "info";
     quietMode4 = false;
@@ -31004,44 +32427,44 @@ async function* splitStream(stream, separator) {
     yield buffer;
   }
 }
-var init_dist3 = __esm({
+var init_dist4 = __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;
@@ -31051,13 +32474,13 @@ async function* outputStream(process2) {
     throw error3;
   }
 }
-function output(process2) {
-  return concatBufferStream(outputStream(process2));
+function output(process3) {
+  return concatBufferStream(outputStream(process3));
 }
-var init_dist4 = __esm({
+var init_dist5 = __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_dist3();
+    init_dist4();
   }
 });
 
@@ -31067,8 +32490,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_dist3();
     init_dist4();
+    init_dist5();
     init_utils4();
     SCISSOR = "------------------------ >8 ------------------------";
     GitClient = class {
@@ -31749,7 +33172,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) {
@@ -31772,14 +33195,14 @@ var init_stream = __esm({
 });
 
 // ../../node_modules/.pnpm/conventional-commits-parser@6.2.1/node_modules/conventional-commits-parser/dist/index.js
-var dist_exports3 = {};
-__export(dist_exports3, {
+var dist_exports4 = {};
+__export(dist_exports4, {
   CommitParser: () => CommitParser,
   createCommitObject: () => createCommitObject,
   parseCommits: () => parseCommits,
   parseCommitsStream: () => parseCommitsStream
 });
-var init_dist5 = __esm({
+var init_dist6 = __esm({
   "../../node_modules/.pnpm/conventional-commits-parser@6.2.1/node_modules/conventional-commits-parser/dist/index.js"() {
     "use strict";
     init_types2();
@@ -31904,14 +33327,14 @@ var init_filters = __esm({
 });
 
 // ../../node_modules/.pnpm/conventional-commits-filter@5.0.0/node_modules/conventional-commits-filter/dist/index.js
-var dist_exports4 = {};
-__export(dist_exports4, {
+var dist_exports5 = {};
+__export(dist_exports5, {
   RevertedCommitsFilter: () => RevertedCommitsFilter,
   filterRevertedCommits: () => filterRevertedCommits,
   filterRevertedCommitsStream: () => filterRevertedCommitsStream,
   filterRevertedCommitsSync: () => filterRevertedCommitsSync
 });
-var init_dist6 = __esm({
+var init_dist7 = __esm({
   "../../node_modules/.pnpm/conventional-commits-filter@5.0.0/node_modules/conventional-commits-filter/dist/index.js"() {
     "use strict";
     init_RevertedCommitsFilter();
@@ -31925,7 +33348,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_semver2 = __toESM(require_semver2(), 1);
-    init_dist3();
+    init_dist4();
     init_GitClient();
     ConventionalGitClient = class extends GitClient {
       deps = null;
@@ -31934,8 +33357,8 @@ var init_ConventionalGitClient = __esm({
           return this.deps;
         }
         this.deps = Promise.all([
-          Promise.resolve().then(() => (init_dist5(), dist_exports3)).then(({ parseCommits: parseCommits2 }) => parseCommits2),
-          Promise.resolve().then(() => (init_dist6(), dist_exports4)).then(({ filterRevertedCommits: filterRevertedCommits2 }) => filterRevertedCommits2)
+          Promise.resolve().then(() => (init_dist6(), dist_exports4)).then(({ parseCommits: parseCommits2 }) => parseCommits2),
+          Promise.resolve().then(() => (init_dist7(), dist_exports5)).then(({ filterRevertedCommits: filterRevertedCommits2 }) => filterRevertedCommits2)
         ]);
         return this.deps;
       }
@@ -31956,9 +33379,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.
@@ -32030,7 +33453,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_dist7 = __esm({
+var init_dist8 = __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();
@@ -32127,7 +33550,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_dist8 = __esm({
+var init_dist9 = __esm({
   "../../node_modules/.pnpm/conventional-changelog-preset-loader@5.0.0/node_modules/conventional-changelog-preset-loader/dist/index.js"() {
     "use strict";
     init_types3();
@@ -32153,8 +33576,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_dist7();
     init_dist8();
+    init_dist9();
     init_utils7();
     VERSIONS = [
       "major",
@@ -32322,7 +33745,7 @@ var init_bumper = __esm({
 });
 
 // ../../node_modules/.pnpm/conventional-recommended-bump@11.2.0/node_modules/conventional-recommended-bump/dist/index.js
-var init_dist9 = __esm({
+var init_dist10 = __esm({
   "../../node_modules/.pnpm/conventional-recommended-bump@11.2.0/node_modules/conventional-recommended-bump/dist/index.js"() {
     "use strict";
     init_bumper();
@@ -32387,44 +33810,44 @@ async function* splitStream2(stream, separator) {
     yield buffer;
   }
 }
-var init_dist10 = __esm({
+var init_dist11 = __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;
@@ -32434,13 +33857,13 @@ async function* outputStream2(process2) {
     throw error3;
   }
 }
-function output2(process2) {
-  return concatBufferStream2(outputStream2(process2));
+function output2(process3) {
+  return concatBufferStream2(outputStream2(process3));
 }
-var init_dist11 = __esm({
+var init_dist12 = __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_dist10();
+    init_dist11();
   }
 });
 
@@ -32450,8 +33873,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_dist10();
     init_dist11();
+    init_dist12();
     init_utils8();
     SCISSOR3 = "------------------------ >8 ------------------------";
     GitClient2 = class {
@@ -32700,7 +34123,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_semver3 = __toESM(require_semver2(), 1);
-    init_dist10();
+    init_dist11();
     init_GitClient2();
     ConventionalGitClient2 = class extends GitClient2 {
       deps = null;
@@ -32709,8 +34132,8 @@ var init_ConventionalGitClient2 = __esm({
           return this.deps;
         }
         this.deps = Promise.all([
-          Promise.resolve().then(() => (init_dist5(), dist_exports3)).then(({ parseCommits: parseCommits2 }) => parseCommits2),
-          Promise.resolve().then(() => (init_dist6(), dist_exports4)).then(({ filterRevertedCommits: filterRevertedCommits2 }) => filterRevertedCommits2)
+          Promise.resolve().then(() => (init_dist6(), dist_exports4)).then(({ parseCommits: parseCommits2 }) => parseCommits2),
+          Promise.resolve().then(() => (init_dist7(), dist_exports5)).then(({ filterRevertedCommits: filterRevertedCommits2 }) => filterRevertedCommits2)
         ]);
         return this.deps;
       }
@@ -32731,9 +34154,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.
@@ -32805,7 +34228,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_dist12 = __esm({
+var init_dist13 = __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();
@@ -32842,7 +34265,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_dist12();
+    init_dist13();
   }
 });
 
@@ -36274,7 +37697,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_dist13 = __esm({
+var init_dist14 = __esm({
   "../../node_modules/.pnpm/fdir@6.5.0_picomatch@4.0.4/node_modules/fdir/dist/index.mjs"() {
     "use strict";
     __require2 = /* @__PURE__ */ createRequire2(import.meta.url);
@@ -37496,7 +38919,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");
       }
@@ -37666,7 +39089,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") {
@@ -38188,7 +39611,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;
@@ -38253,7 +39676,7 @@ var require_parse2 = __commonJS({
       }
       return source;
     };
-    module2.exports = parse4;
+    module2.exports = parse2;
   }
 });
 
@@ -38262,7 +39685,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_utils2();
     var constants = require_constants2();
     var isObject3 = (val) => val && typeof val === "object" && !Array.isArray(val);
@@ -38350,7 +39773,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) => {
@@ -38376,10 +39799,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);
     };
@@ -38678,10 +40101,10 @@ function globSync(patternsOrOptions, options) {
   return formatPaths(crawler.sync(), relative2);
 }
 var import_picomatch, isReadonlyArray3, 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_dist14 = __esm({
+var init_dist15 = __esm({
   "../../node_modules/.pnpm/tinyglobby@0.2.15/node_modules/tinyglobby/dist/index.mjs"() {
     "use strict";
-    init_dist13();
+    init_dist14();
     import_picomatch = __toESM(require_picomatch2(), 1);
     isReadonlyArray3 = Array.isArray;
     isWin = process.platform === "win32";
@@ -41407,7 +42830,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") {
@@ -41475,13 +42898,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") {
@@ -41499,19 +42922,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") {
@@ -41547,7 +42970,7 @@ var require_parse3 = __commonJS({
             tokenEnd(void 0, "whitespace");
             tokenStart();
             position++;
-            skipComment(input[position++] === "*");
+            skipComment2(input[position++] === "*");
             tokenEnd(void 0, "comment");
             tokenStart();
           } else {
@@ -41557,7 +42980,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)) {
@@ -41593,7 +43016,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++];
@@ -41652,7 +43075,7 @@ var require_parse3 = __commonJS({
         }
         fail();
       }
-      function parseArray() {
+      function parseArray2() {
         var result = [];
         while (position < length) {
           skipWhiteSpace();
@@ -41778,7 +43201,7 @@ var require_parse3 = __commonJS({
         }
         fail();
       }
-      function parseString(endChar) {
+      function parseString2(endChar) {
         var result = "";
         while (position < length) {
           var chr = input[position++];
@@ -41865,7 +43288,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;
@@ -42236,7 +43659,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;
@@ -42251,7 +43674,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 }];
       }
@@ -42719,7 +44142,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_dist14();
+    init_dist15();
     init_js_yaml();
     import_jju = __toESM(require_jju(), 1);
     InvalidMonorepoError = class extends Error {
@@ -43391,22 +44814,19 @@ var init_baseError_DQHIJACF = __esm({
 // ../version/dist/chunk-UBCKZYTO.js
 import * as fs15 from "fs";
 import * as path17 from "path";
-import * as TOML3 from "smol-toml";
 import * as fs34 from "fs";
 import * as path34 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 path23 from "path";
 import fs44 from "fs";
 import { cwd } from "process";
-import chalk5 from "chalk";
 import fs63 from "fs";
 import path54 from "path";
 import fs54 from "fs";
 import path44 from "path";
-import * as TOML23 from "smol-toml";
 import * as fs93 from "fs";
 import path73 from "path";
 import fs83 from "fs";
@@ -43417,7 +44837,7 @@ import path92 from "path";
 import { Command as Command3 } from "commander";
 function parseCargoToml2(cargoPath) {
   const content = fs15.readFileSync(cargoPath, "utf-8");
-  return TOML3.parse(content);
+  return parse(content);
 }
 function isCargoToml(filePath) {
   return path17.basename(filePath) === "Cargo.toml";
@@ -43444,7 +44864,7 @@ function substituteVariables3(value) {
     return process.env[varName] ?? "";
   });
   result = result.replace(filePattern, (_, filePath) => {
-    const expandedPath = filePath.startsWith("~") ? path23.join(os3.homedir(), filePath.slice(1)) : filePath;
+    const expandedPath = filePath.startsWith("~") ? path23.join(os4.homedir(), filePath.slice(1)) : filePath;
     try {
       return fs24.readFileSync(expandedPath, "utf-8").trim();
     } catch {
@@ -43689,19 +45109,19 @@ function log6(message, level = "info") {
   let chalkFn;
   switch (level) {
     case "success":
-      chalkFn = chalk5.green;
+      chalkFn = source_default.green;
       break;
     case "warning":
-      chalkFn = chalk5.yellow;
+      chalkFn = source_default.yellow;
       break;
     case "error":
-      chalkFn = chalk5.red;
+      chalkFn = source_default.red;
       break;
     case "debug":
-      chalkFn = chalk5.gray;
+      chalkFn = source_default.gray;
       break;
     default:
-      chalkFn = chalk5.blue;
+      chalkFn = source_default.blue;
   }
   const formattedMessage = level === "debug" ? `[DEBUG] ${message}` : message;
   if (isJsonOutputMode()) {
@@ -43920,7 +45340,7 @@ function updateCargoVersion2(cargoPath, version, dryRun = false) {
     } else {
       cargo.package.version = version;
     }
-    const updatedContent = TOML23.stringify(cargo);
+    const updatedContent = stringify(cargo);
     if (dryRun) {
       recordPendingWrite(cargoPath, updatedContent);
     } else {
@@ -45182,11 +46602,14 @@ var init_chunk_UBCKZYTO = __esm({
     "use strict";
     init_chunk_Q3FHZORY();
     init_chunk_LMPZV35Z();
-    init_dist9();
+    init_dist();
+    init_dist10();
     import_semver4 = __toESM(require_semver2(), 1);
     init_src();
     import_semver5 = __toESM(require_semver2(), 1);
+    init_source();
     init_node_figlet();
+    init_dist();
     import_semver6 = __toESM(require_semver2(), 1);
     init_esm3();
     init_manypkg_get_packages();
@@ -45493,7 +46916,7 @@ var init_chunk_UBCKZYTO = __esm({
     });
     MAX_INPUT_LENGTH3 = 1e4;
     SOLE_REFERENCE_PATTERN3 = /^\{(?:env|file):[^}]+\}$/;
-    AUTH_DIR3 = path23.join(os3.homedir(), ".config", "releasekit");
+    AUTH_DIR3 = path23.join(os4.homedir(), ".config", "releasekit");
     AUTH_FILE3 = path23.join(AUTH_DIR3, "auth.json");
     CONFIG_FILE3 = "releasekit.config.json";
     VersionError = class extends BaseVersionError {
@@ -45899,8 +47322,8 @@ var init_chunk_UBCKZYTO = __esm({
 });
 
 // ../version/dist/index.js
-var dist_exports5 = {};
-__export(dist_exports5, {
+var dist_exports6 = {};
+__export(dist_exports6, {
   BaseVersionError: () => BaseVersionError,
   PackageProcessor: () => PackageProcessor,
   VersionEngine: () => VersionEngine,
@@ -45916,7 +47339,7 @@ __export(dist_exports5, {
   getJsonData: () => getJsonData,
   loadConfig: () => loadConfig23
 });
-var init_dist15 = __esm({
+var init_dist16 = __esm({
   "../version/dist/index.js"() {
     "use strict";
     init_chunk_UBCKZYTO();
@@ -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) {
@@ -46029,14 +47452,14 @@ var EXIT_CODES = {
 };
 
 // src/dispatcher.ts
-init_dist();
 init_dist2();
-init_dist15();
+init_dist3();
+init_dist16();
 import { Command as Command7 } from "commander";
 
 // src/init-command.ts
 import * as fs16 from "fs";
-init_dist();
+init_dist2();
 import { Command as Command4 } from "commander";
 function createInitCommand() {
   return new Command4("init").description("Create a default releasekit.config.json").option("-f, --force", "Overwrite existing config").action((options) => {
@@ -46087,13 +47510,13 @@ function createInitCommand() {
 import { Command as Command5 } from "commander";
 
 // ../config/dist/index.js
-import * as TOML4 from "smol-toml";
+init_dist();
 import * as fs35 from "fs";
 import * as path35 from "path";
 import { z as z24 } from "zod";
 import { z as z5 } from "zod";
 import * as fs25 from "fs";
-import * as os4 from "os";
+import * as os5 from "os";
 import * as path24 from "path";
 var ConfigError5 = class extends ReleaseKitError {
   code = "CONFIG_ERROR";
@@ -46418,7 +47841,7 @@ function substituteVariables4(value) {
     return process.env[varName] ?? "";
   });
   result = result.replace(filePattern, (_, filePath) => {
-    const expandedPath = filePath.startsWith("~") ? path24.join(os4.homedir(), filePath.slice(1)) : filePath;
+    const expandedPath = filePath.startsWith("~") ? path24.join(os5.homedir(), filePath.slice(1)) : filePath;
     try {
       return fs25.readFileSync(expandedPath, "utf-8").trim();
     } catch {
@@ -46448,7 +47871,7 @@ function substituteInObject4(obj) {
   }
   return obj;
 }
-var AUTH_DIR4 = path24.join(os4.homedir(), ".config", "releasekit");
+var AUTH_DIR4 = path24.join(os5.homedir(), ".config", "releasekit");
 var AUTH_FILE4 = path24.join(AUTH_DIR4, "auth.json");
 var CONFIG_FILE4 = "releasekit.config.json";
 function loadConfigFile4(configPath) {
@@ -46828,7 +48251,7 @@ async function runRelease(inputOptions) {
     return null;
   }
   if (!options.dryRun) {
-    const { flushPendingWrites: flushPendingWrites2 } = await Promise.resolve().then(() => (init_dist15(), dist_exports5));
+    const { flushPendingWrites: flushPendingWrites2 } = await Promise.resolve().then(() => (init_dist16(), dist_exports6));
     flushPendingWrites2();
   }
   info(`Found ${versionOutput.updates.length} package update(s)`);
@@ -46857,7 +48280,7 @@ async function runRelease(inputOptions) {
   return { versionOutput, notesGenerated, packageNotes, releaseNotes, publishOutput };
 }
 async function runVersionStep(options) {
-  const { loadConfig: loadConfig6, VersionEngine: VersionEngine2, enableJsonOutput: enableJsonOutput2, getJsonData: getJsonData2 } = await Promise.resolve().then(() => (init_dist15(), dist_exports5));
+  const { loadConfig: loadConfig6, VersionEngine: VersionEngine2, enableJsonOutput: enableJsonOutput2, getJsonData: getJsonData2 } = await Promise.resolve().then(() => (init_dist16(), dist_exports6));
   enableJsonOutput2(options.dryRun);
   const config = loadConfig6({ cwd: options.projectDir, configPath: options.config });
   if (options.dryRun) config.dryRun = true;
@@ -46890,14 +48313,14 @@ async function runVersionStep(options) {
   return getJsonData2();
 }
 async function runNotesStep(versionOutput, options) {
-  const { parseVersionOutput: parseVersionOutput2, runPipeline: runPipeline3, loadConfig: loadConfig6 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+  const { parseVersionOutput: parseVersionOutput2, runPipeline: runPipeline3, loadConfig: loadConfig6 } = await Promise.resolve().then(() => (init_dist2(), dist_exports2));
   const config = loadConfig6(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: loadConfig6 } = await Promise.resolve().then(() => (init_dist2(), dist_exports2));
+  const { runPipeline: runPipeline3, loadConfig: loadConfig6 } = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
   const config = loadConfig6({ configPath: options.config });
   if (options.branch) {
     config.git.branch = options.branch;
@@ -47146,6 +48569,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.
+   *)
+
 ejs/lib/esm/ejs.js:
   (**
    * @file Embedded JavaScript templating engine. {@link http://ejs.co}