@devkong/cli 0.0.55 → 0.0.57

package/index.js

@@ -33,6 +33,1066 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// node_modules/cronstrue/dist/cronstrue.js
+var require_cronstrue = __commonJS({
+  "node_modules/cronstrue/dist/cronstrue.js"(exports2, module2) {
+    (function webpackUniversalModuleDefinition(root, factory2) {
+      if (typeof exports2 === "object" && typeof module2 === "object")
+        module2.exports = factory2();
+      else if (typeof define === "function" && define.amd)
+        define("cronstrue", [], factory2);
+      else if (typeof exports2 === "object")
+        exports2["cronstrue"] = factory2();
+      else
+        root["cronstrue"] = factory2();
+    })(globalThis, () => {
+      return (
+        /******/
+        (() => {
+          "use strict";
+          var __webpack_modules__ = {
+            /***/
+            949(__unused_webpack_module, exports3, __webpack_require__2) {
+              Object.defineProperty(exports3, "__esModule", { value: true });
+              exports3.CronParser = void 0;
+              var rangeValidator_1 = __webpack_require__2(515);
+              var CronParser2 = (function() {
+                function CronParser3(expression, dayOfWeekStartIndexZero, monthStartIndexZero) {
+                  if (dayOfWeekStartIndexZero === void 0) {
+                    dayOfWeekStartIndexZero = true;
+                  }
+                  if (monthStartIndexZero === void 0) {
+                    monthStartIndexZero = false;
+                  }
+                  this.expression = expression;
+                  this.dayOfWeekStartIndexZero = dayOfWeekStartIndexZero;
+                  this.monthStartIndexZero = monthStartIndexZero;
+                }
+                CronParser3.prototype.parse = function() {
+                  var _a;
+                  var parsed;
+                  var expression = (_a = this.expression) !== null && _a !== void 0 ? _a : "";
+                  if (expression === "@reboot") {
+                    parsed = ["@reboot", "", "", "", "", "", ""];
+                    return parsed;
+                  } else if (expression.startsWith("@")) {
+                    var special = this.parseSpecial(this.expression);
+                    parsed = this.extractParts(special);
+                  } else {
+                    parsed = this.extractParts(this.expression);
+                  }
+                  this.normalize(parsed);
+                  this.validate(parsed);
+                  return parsed;
+                };
+                CronParser3.prototype.parseSpecial = function(expression) {
+                  var specialExpressions = {
+                    "@yearly": "0 0 1 1 *",
+                    "@annually": "0 0 1 1 *",
+                    "@monthly": "0 0 1 * *",
+                    "@weekly": "0 0 * * 0",
+                    "@daily": "0 0 * * *",
+                    "@midnight": "0 0 * * *",
+                    "@hourly": "0 * * * *",
+                    "@reboot": "@reboot"
+                  };
+                  var special = specialExpressions[expression];
+                  if (!special) {
+                    throw new Error("Unknown special expression.");
+                  }
+                  return special;
+                };
+                CronParser3.prototype.extractParts = function(expression) {
+                  if (!this.expression) {
+                    throw new Error("cron expression is empty");
+                  }
+                  var parsed = expression.trim().split(/[ ]+/);
+                  for (var i = 0; i < parsed.length; i++) {
+                    if (parsed[i].includes(",")) {
+                      var arrayElement = parsed[i].split(",").map(function(item) {
+                        return item.trim();
+                      }).filter(function(item) {
+                        return item !== "";
+                      }).map(function(item) {
+                        return !isNaN(Number(item)) ? Number(item) : item;
+                      }).filter(function(item) {
+                        return item !== null && item !== "";
+                      });
+                      if (arrayElement.length === 0) {
+                        arrayElement.push("*");
+                      }
+                      arrayElement.sort(function(a, b) {
+                        return a !== null && b !== null ? a - b : 0;
+                      });
+                      parsed[i] = arrayElement.map(function(item) {
+                        return item !== null ? item.toString() : "";
+                      }).join(",");
+                    }
+                  }
+                  if (parsed.length < 5) {
+                    throw new Error("Expression has only ".concat(parsed.length, " part").concat(parsed.length == 1 ? "" : "s", ". At least 5 parts are required."));
+                  } else if (parsed.length == 5) {
+                    parsed.unshift("");
+                    parsed.push("");
+                  } else if (parsed.length == 6) {
+                    var isYearWithNoSecondsPart = /\d{4}$/.test(parsed[5]) || parsed[4] == "?" || parsed[2] == "?";
+                    if (isYearWithNoSecondsPart) {
+                      parsed.unshift("");
+                    } else {
+                      parsed.push("");
+                    }
+                  } else if (parsed.length > 7) {
+                    throw new Error("Expression has ".concat(parsed.length, " parts; too many!"));
+                  }
+                  return parsed;
+                };
+                CronParser3.prototype.normalize = function(expressionParts) {
+                  var _this = this;
+                  expressionParts[3] = expressionParts[3].replace("?", "*");
+                  expressionParts[5] = expressionParts[5].replace("?", "*");
+                  expressionParts[2] = expressionParts[2].replace("?", "*");
+                  if (expressionParts[0].indexOf("0/") == 0) {
+                    expressionParts[0] = expressionParts[0].replace("0/", "*/");
+                  }
+                  if (expressionParts[1].indexOf("0/") == 0) {
+                    expressionParts[1] = expressionParts[1].replace("0/", "*/");
+                  }
+                  if (expressionParts[2].indexOf("0/") == 0) {
+                    expressionParts[2] = expressionParts[2].replace("0/", "*/");
+                  }
+                  if (expressionParts[3].indexOf("1/") == 0) {
+                    expressionParts[3] = expressionParts[3].replace("1/", "*/");
+                  }
+                  if (expressionParts[4].indexOf("1/") == 0) {
+                    expressionParts[4] = expressionParts[4].replace("1/", "*/");
+                  }
+                  if (expressionParts[6].indexOf("1/") == 0) {
+                    expressionParts[6] = expressionParts[6].replace("1/", "*/");
+                  }
+                  expressionParts[5] = expressionParts[5].replace(/(^\d)|([^#/\s]\d)/g, function(t) {
+                    var dowDigits = t.replace(/\D/, "");
+                    var dowDigitsAdjusted = dowDigits;
+                    if (_this.dayOfWeekStartIndexZero) {
+                      if (dowDigits == "7") {
+                        dowDigitsAdjusted = "0";
+                      }
+                    } else {
+                      dowDigitsAdjusted = (parseInt(dowDigits) - 1).toString();
+                    }
+                    return t.replace(dowDigits, dowDigitsAdjusted);
+                  });
+                  if (expressionParts[5] == "L") {
+                    expressionParts[5] = "6";
+                  }
+                  if (expressionParts[3] == "?") {
+                    expressionParts[3] = "*";
+                  }
+                  if (expressionParts[3].indexOf("W") > -1 && (expressionParts[3].indexOf(",") > -1 || expressionParts[3].indexOf("-") > -1)) {
+                    throw new Error("The 'W' character can be specified only when the day-of-month is a single day, not a range or list of days.");
+                  }
+                  var days = {
+                    SUN: 0,
+                    MON: 1,
+                    TUE: 2,
+                    WED: 3,
+                    THU: 4,
+                    FRI: 5,
+                    SAT: 6
+                  };
+                  for (var day in days) {
+                    expressionParts[5] = expressionParts[5].replace(new RegExp(day, "gi"), days[day].toString());
+                  }
+                  expressionParts[4] = expressionParts[4].replace(/(^\d{1,2})|([^#/\s]\d{1,2})/g, function(t) {
+                    var dowDigits = t.replace(/\D/, "");
+                    var dowDigitsAdjusted = dowDigits;
+                    if (_this.monthStartIndexZero) {
+                      dowDigitsAdjusted = (parseInt(dowDigits) + 1).toString();
+                    }
+                    return t.replace(dowDigits, dowDigitsAdjusted);
+                  });
+                  var months = {
+                    JAN: 1,
+                    FEB: 2,
+                    MAR: 3,
+                    APR: 4,
+                    MAY: 5,
+                    JUN: 6,
+                    JUL: 7,
+                    AUG: 8,
+                    SEP: 9,
+                    OCT: 10,
+                    NOV: 11,
+                    DEC: 12
+                  };
+                  for (var month in months) {
+                    expressionParts[4] = expressionParts[4].replace(new RegExp(month, "gi"), months[month].toString());
+                  }
+                  if (expressionParts[0] == "0") {
+                    expressionParts[0] = "";
+                  }
+                  if (!/\*|\-|\,|\//.test(expressionParts[2]) && (/\*|\//.test(expressionParts[1]) || /\*|\//.test(expressionParts[0]))) {
+                    expressionParts[2] += "-".concat(expressionParts[2]);
+                  }
+                  for (var i = 0; i < expressionParts.length; i++) {
+                    if (expressionParts[i].indexOf(",") != -1) {
+                      expressionParts[i] = expressionParts[i].split(",").filter(function(str) {
+                        return str !== "";
+                      }).join(",") || "*";
+                    }
+                    if (expressionParts[i] == "*/1") {
+                      expressionParts[i] = "*";
+                    }
+                    if (expressionParts[i].indexOf("/") > -1 && !/^\*|\-|\,/.test(expressionParts[i])) {
+                      var stepRangeThrough = null;
+                      switch (i) {
+                        case 4:
+                          stepRangeThrough = "12";
+                          break;
+                        case 5:
+                          stepRangeThrough = "6";
+                          break;
+                        case 6:
+                          stepRangeThrough = "9999";
+                          break;
+                        default:
+                          stepRangeThrough = null;
+                          break;
+                      }
+                      if (stepRangeThrough !== null) {
+                        var parts = expressionParts[i].split("/");
+                        expressionParts[i] = "".concat(parts[0], "-").concat(stepRangeThrough, "/").concat(parts[1]);
+                      }
+                    }
+                  }
+                };
+                CronParser3.prototype.validate = function(parsed) {
+                  var standardCronPartCharacters = "0-9,\\-*/";
+                  this.validateOnlyExpectedCharactersFound(parsed[0], standardCronPartCharacters);
+                  this.validateOnlyExpectedCharactersFound(parsed[1], standardCronPartCharacters);
+                  this.validateOnlyExpectedCharactersFound(parsed[2], standardCronPartCharacters);
+                  this.validateOnlyExpectedCharactersFound(parsed[3], "0-9,\\-*/LW");
+                  this.validateOnlyExpectedCharactersFound(parsed[4], standardCronPartCharacters);
+                  this.validateOnlyExpectedCharactersFound(parsed[5], "0-9,\\-*/L#");
+                  this.validateOnlyExpectedCharactersFound(parsed[6], standardCronPartCharacters);
+                  this.validateAnyRanges(parsed);
+                };
+                CronParser3.prototype.validateAnyRanges = function(parsed) {
+                  rangeValidator_1.default.secondRange(parsed[0]);
+                  rangeValidator_1.default.minuteRange(parsed[1]);
+                  rangeValidator_1.default.hourRange(parsed[2]);
+                  rangeValidator_1.default.dayOfMonthRange(parsed[3]);
+                  rangeValidator_1.default.monthRange(parsed[4], this.monthStartIndexZero);
+                  rangeValidator_1.default.dayOfWeekRange(parsed[5], this.dayOfWeekStartIndexZero);
+                };
+                CronParser3.prototype.validateOnlyExpectedCharactersFound = function(cronPart, allowedCharsExpression) {
+                  var invalidChars = cronPart.match(new RegExp("[^".concat(allowedCharsExpression, "]+"), "gi"));
+                  if (invalidChars && invalidChars.length) {
+                    throw new Error("Expression contains invalid values: '".concat(invalidChars.toString(), "'"));
+                  }
+                };
+                return CronParser3;
+              })();
+              exports3.CronParser = CronParser2;
+            },
+            /***/
+            333(__unused_webpack_module, exports3, __webpack_require__2) {
+              Object.defineProperty(exports3, "__esModule", { value: true });
+              exports3.ExpressionDescriptor = void 0;
+              var stringUtilities_1 = __webpack_require__2(823);
+              var cronParser_1 = __webpack_require__2(949);
+              var ExpressionDescriptor = (function() {
+                function ExpressionDescriptor2(expression, options) {
+                  this.expression = expression;
+                  this.options = options;
+                  this.expressionParts = new Array(5);
+                  if (!this.options.locale && ExpressionDescriptor2.defaultLocale) {
+                    this.options.locale = ExpressionDescriptor2.defaultLocale;
+                  }
+                  if (!ExpressionDescriptor2.locales[this.options.locale]) {
+                    var fallBackLocale = Object.keys(ExpressionDescriptor2.locales)[0];
+                    console.warn("Locale '".concat(this.options.locale, "' could not be found; falling back to '").concat(fallBackLocale, "'."));
+                    this.options.locale = fallBackLocale;
+                  }
+                  this.i18n = ExpressionDescriptor2.locales[this.options.locale];
+                  if (options.use24HourTimeFormat === void 0) {
+                    options.use24HourTimeFormat = this.i18n.use24HourTimeFormatByDefault();
+                  }
+                }
+                ExpressionDescriptor2.toString = function(expression, _a) {
+                  var _b = _a === void 0 ? {} : _a, _c = _b.throwExceptionOnParseError, throwExceptionOnParseError = _c === void 0 ? true : _c, _d = _b.verbose, verbose = _d === void 0 ? false : _d, _e = _b.dayOfWeekStartIndexZero, dayOfWeekStartIndexZero = _e === void 0 ? true : _e, _f = _b.monthStartIndexZero, monthStartIndexZero = _f === void 0 ? false : _f, use24HourTimeFormat = _b.use24HourTimeFormat, _g = _b.locale, locale = _g === void 0 ? null : _g, _h = _b.logicalAndDayFields, logicalAndDayFields = _h === void 0 ? false : _h;
+                  var options = {
+                    throwExceptionOnParseError,
+                    verbose,
+                    dayOfWeekStartIndexZero,
+                    monthStartIndexZero,
+                    use24HourTimeFormat,
+                    locale,
+                    logicalAndDayFields
+                  };
+                  if (options.tzOffset) {
+                    console.warn("'tzOffset' option has been deprecated and is no longer supported.");
+                  }
+                  var descripter = new ExpressionDescriptor2(expression, options);
+                  return descripter.getFullDescription();
+                };
+                ExpressionDescriptor2.initialize = function(localesLoader, defaultLocale) {
+                  if (defaultLocale === void 0) {
+                    defaultLocale = "en";
+                  }
+                  ExpressionDescriptor2.specialCharacters = ["/", "-", ",", "*"];
+                  ExpressionDescriptor2.defaultLocale = defaultLocale;
+                  localesLoader.load(ExpressionDescriptor2.locales);
+                };
+                ExpressionDescriptor2.prototype.getFullDescription = function() {
+                  var _a, _b;
+                  var description = "";
+                  try {
+                    var parser = new cronParser_1.CronParser(this.expression, this.options.dayOfWeekStartIndexZero, this.options.monthStartIndexZero);
+                    this.expressionParts = parser.parse();
+                    if (this.expressionParts[0] === "@reboot") {
+                      return ((_b = (_a = this.i18n).atReboot) === null || _b === void 0 ? void 0 : _b.call(_a)) || "Run once, at startup";
+                    }
+                    var timeSegment = this.getTimeOfDayDescription();
+                    var dayOfMonthDesc = this.getDayOfMonthDescription();
+                    var monthDesc = this.getMonthDescription();
+                    var dayOfWeekDesc = this.getDayOfWeekDescription();
+                    var yearDesc = this.getYearDescription();
+                    description += timeSegment + dayOfMonthDesc + dayOfWeekDesc + monthDesc + yearDesc;
+                    description = this.transformVerbosity(description, !!this.options.verbose);
+                    description = description.charAt(0).toLocaleUpperCase() + description.substr(1);
+                  } catch (ex) {
+                    if (!this.options.throwExceptionOnParseError) {
+                      description = this.i18n.anErrorOccuredWhenGeneratingTheExpressionD();
+                    } else {
+                      throw "".concat(ex);
+                    }
+                  }
+                  return description;
+                };
+                ExpressionDescriptor2.prototype.getTimeOfDayDescription = function() {
+                  var secondsExpression = this.expressionParts[0];
+                  var minuteExpression = this.expressionParts[1];
+                  var hourExpression = this.expressionParts[2];
+                  var description = "";
+                  if (!stringUtilities_1.StringUtilities.containsAny(minuteExpression, ExpressionDescriptor2.specialCharacters) && !stringUtilities_1.StringUtilities.containsAny(hourExpression, ExpressionDescriptor2.specialCharacters) && !stringUtilities_1.StringUtilities.containsAny(secondsExpression, ExpressionDescriptor2.specialCharacters)) {
+                    description += this.i18n.atSpace() + this.formatTime(hourExpression, minuteExpression, secondsExpression);
+                  } else if (!secondsExpression && minuteExpression.indexOf("-") > -1 && !(minuteExpression.indexOf(",") > -1) && !(minuteExpression.indexOf("/") > -1) && !stringUtilities_1.StringUtilities.containsAny(hourExpression, ExpressionDescriptor2.specialCharacters)) {
+                    var minuteParts = minuteExpression.split("-");
+                    description += stringUtilities_1.StringUtilities.format(this.i18n.everyMinuteBetweenX0AndX1(), this.formatTime(hourExpression, minuteParts[0], ""), this.formatTime(hourExpression, minuteParts[1], ""));
+                  } else if (!secondsExpression && hourExpression.indexOf(",") > -1 && hourExpression.indexOf("-") == -1 && hourExpression.indexOf("/") == -1 && !stringUtilities_1.StringUtilities.containsAny(minuteExpression, ExpressionDescriptor2.specialCharacters)) {
+                    var hourParts = hourExpression.split(",");
+                    description += this.i18n.at();
+                    for (var i = 0; i < hourParts.length; i++) {
+                      description += " ";
+                      description += this.formatTime(hourParts[i], minuteExpression, "");
+                      if (i < hourParts.length - 2) {
+                        description += ",";
+                      }
+                      if (i == hourParts.length - 2) {
+                        description += this.i18n.spaceAnd();
+                      }
+                    }
+                  } else {
+                    var secondsDescription = this.getSecondsDescription();
+                    var minutesDescription = this.getMinutesDescription();
+                    var hoursDescription = this.getHoursDescription();
+                    description += secondsDescription;
+                    if (description && minutesDescription) {
+                      description += ", ";
+                    }
+                    description += minutesDescription;
+                    if (minutesDescription === hoursDescription) {
+                      return description;
+                    }
+                    if (description && hoursDescription) {
+                      description += ", ";
+                    }
+                    description += hoursDescription;
+                  }
+                  return description;
+                };
+                ExpressionDescriptor2.prototype.getSecondsDescription = function() {
+                  var _this = this;
+                  var description = this.getSegmentDescription(this.expressionParts[0], this.i18n.everySecond(), function(s) {
+                    return s;
+                  }, function(s) {
+                    return stringUtilities_1.StringUtilities.format(_this.i18n.everyX0Seconds(s), s);
+                  }, function(s) {
+                    return _this.i18n.secondsX0ThroughX1PastTheMinute();
+                  }, function(s) {
+                    return s == "0" ? "" : parseInt(s) < 20 ? _this.i18n.atX0SecondsPastTheMinute(s) : _this.i18n.atX0SecondsPastTheMinuteGt20() || _this.i18n.atX0SecondsPastTheMinute(s);
+                  });
+                  return description;
+                };
+                ExpressionDescriptor2.prototype.getMinutesDescription = function() {
+                  var _this = this;
+                  var secondsExpression = this.expressionParts[0];
+                  var hourExpression = this.expressionParts[2];
+                  var description = this.getSegmentDescription(this.expressionParts[1], this.i18n.everyMinute(), function(s) {
+                    return s;
+                  }, function(s) {
+                    return stringUtilities_1.StringUtilities.format(_this.i18n.everyX0Minutes(s), s);
+                  }, function(s) {
+                    return _this.i18n.minutesX0ThroughX1PastTheHour();
+                  }, function(s) {
+                    var _a, _b;
+                    try {
+                      return s == "0" && hourExpression.indexOf("/") == -1 && secondsExpression == "" ? _this.i18n.everyHour() : s == "0" ? ((_b = (_a = _this.i18n).onTheHour) === null || _b === void 0 ? void 0 : _b.call(_a)) || _this.i18n.atX0MinutesPastTheHour(s) : parseInt(s) < 20 ? _this.i18n.atX0MinutesPastTheHour(s) : _this.i18n.atX0MinutesPastTheHourGt20() || _this.i18n.atX0MinutesPastTheHour(s);
+                    } catch (e) {
+                      return _this.i18n.atX0MinutesPastTheHour(s);
+                    }
+                  });
+                  return description;
+                };
+                ExpressionDescriptor2.prototype.getHoursDescription = function() {
+                  var _this = this;
+                  var expression = this.expressionParts[2];
+                  var hourIndex = 0;
+                  var rangeEndValues = [];
+                  expression.split("/")[0].split(",").forEach(function(range) {
+                    var rangeParts = range.split("-");
+                    if (rangeParts.length === 2) {
+                      rangeEndValues.push({ value: rangeParts[1], index: hourIndex + 1 });
+                    }
+                    hourIndex += rangeParts.length;
+                  });
+                  var evaluationIndex = 0;
+                  var description = this.getSegmentDescription(expression, this.i18n.everyHour(), function(s) {
+                    var match2 = rangeEndValues.find(function(r) {
+                      return r.value === s && r.index === evaluationIndex;
+                    });
+                    var isRangeEndWithNonZeroMinute = match2 && _this.expressionParts[1] !== "0";
+                    evaluationIndex++;
+                    return isRangeEndWithNonZeroMinute ? _this.formatTime(s, "59", "") : _this.formatTime(s, "0", "");
+                  }, function(s) {
+                    return stringUtilities_1.StringUtilities.format(_this.i18n.everyX0Hours(s), s);
+                  }, function(s) {
+                    return _this.i18n.betweenX0AndX1();
+                  }, function(s) {
+                    return _this.i18n.atX0();
+                  });
+                  return description;
+                };
+                ExpressionDescriptor2.prototype.getDayOfWeekDescription = function() {
+                  var _this = this;
+                  var daysOfWeekNames = this.i18n.daysOfTheWeek();
+                  var description = null;
+                  if (this.expressionParts[5] == "*") {
+                    description = "";
+                  } else {
+                    description = this.getSegmentDescription(this.expressionParts[5], this.i18n.commaEveryDay(), function(s, form) {
+                      var exp = s;
+                      if (s.indexOf("#") > -1) {
+                        exp = s.substring(0, s.indexOf("#"));
+                      } else if (s.indexOf("L") > -1) {
+                        exp = exp.replace("L", "");
+                      }
+                      var parsedExp = parseInt(exp);
+                      var description2 = _this.i18n.daysOfTheWeekInCase ? _this.i18n.daysOfTheWeekInCase(form)[parsedExp] : daysOfWeekNames[parsedExp];
+                      if (s.indexOf("#") > -1) {
+                        var dayOfWeekOfMonthDescription = null;
+                        var dayOfWeekOfMonthNumber = s.substring(s.indexOf("#") + 1);
+                        var dayOfWeekNumber = s.substring(0, s.indexOf("#"));
+                        switch (dayOfWeekOfMonthNumber) {
+                          case "1":
+                            dayOfWeekOfMonthDescription = _this.i18n.first(dayOfWeekNumber);
+                            break;
+                          case "2":
+                            dayOfWeekOfMonthDescription = _this.i18n.second(dayOfWeekNumber);
+                            break;
+                          case "3":
+                            dayOfWeekOfMonthDescription = _this.i18n.third(dayOfWeekNumber);
+                            break;
+                          case "4":
+                            dayOfWeekOfMonthDescription = _this.i18n.fourth(dayOfWeekNumber);
+                            break;
+                          case "5":
+                            dayOfWeekOfMonthDescription = _this.i18n.fifth(dayOfWeekNumber);
+                            break;
+                        }
+                        description2 = dayOfWeekOfMonthDescription + " " + description2;
+                      }
+                      return description2;
+                    }, function(s) {
+                      if (parseInt(s) == 1) {
+                        return "";
+                      } else {
+                        return stringUtilities_1.StringUtilities.format(_this.i18n.commaEveryX0DaysOfTheWeek(s), s);
+                      }
+                    }, function(s) {
+                      var beginFrom = s.substring(0, s.indexOf("-"));
+                      var domSpecified = _this.expressionParts[3] != "*";
+                      return domSpecified ? _this.i18n.commaAndX0ThroughX1(beginFrom) : _this.i18n.commaX0ThroughX1(beginFrom);
+                    }, function(s) {
+                      var format4 = null;
+                      if (s.indexOf("#") > -1) {
+                        var dayOfWeekOfMonthNumber = s.substring(s.indexOf("#") + 1);
+                        var dayOfWeek = s.substring(0, s.indexOf("#"));
+                        format4 = _this.i18n.commaOnThe(dayOfWeekOfMonthNumber, dayOfWeek).trim() + _this.i18n.spaceX0OfTheMonth();
+                      } else if (s.indexOf("L") > -1) {
+                        format4 = _this.i18n.commaOnTheLastX0OfTheMonth(s.replace("L", ""));
+                      } else {
+                        var domSpecified = _this.expressionParts[3] != "*";
+                        if (!domSpecified) {
+                          format4 = _this.i18n.commaOnlyOnX0(s);
+                        } else if (_this.options.logicalAndDayFields) {
+                          format4 = _this.i18n.commaOnlyOnX0(s);
+                        } else {
+                          format4 = _this.i18n.commaAndOnX0();
+                        }
+                      }
+                      return format4;
+                    });
+                  }
+                  return description;
+                };
+                ExpressionDescriptor2.prototype.getMonthDescription = function() {
+                  var _this = this;
+                  var monthNames = this.i18n.monthsOfTheYear();
+                  var description = this.getSegmentDescription(this.expressionParts[4], "", function(s, form) {
+                    return form && _this.i18n.monthsOfTheYearInCase ? _this.i18n.monthsOfTheYearInCase(form)[parseInt(s) - 1] : monthNames[parseInt(s) - 1];
+                  }, function(s) {
+                    if (parseInt(s) == 1) {
+                      return "";
+                    } else {
+                      return stringUtilities_1.StringUtilities.format(_this.i18n.commaEveryX0Months(s), s);
+                    }
+                  }, function(s) {
+                    return _this.i18n.commaMonthX0ThroughMonthX1() || _this.i18n.commaX0ThroughX1();
+                  }, function(s) {
+                    return _this.i18n.commaOnlyInMonthX0 ? _this.i18n.commaOnlyInMonthX0() : _this.i18n.commaOnlyInX0();
+                  });
+                  return description;
+                };
+                ExpressionDescriptor2.prototype.getDayOfMonthDescription = function() {
+                  var _this = this;
+                  var description = null;
+                  var expression = this.expressionParts[3];
+                  switch (expression) {
+                    case "L":
+                      description = this.i18n.commaOnTheLastDayOfTheMonth();
+                      break;
+                    case "WL":
+                    case "LW":
+                      description = this.i18n.commaOnTheLastWeekdayOfTheMonth();
+                      break;
+                    default:
+                      var weekDayNumberMatches = expression.match(/(\d{1,2}W)|(W\d{1,2})/);
+                      if (weekDayNumberMatches) {
+                        var dayNumber = parseInt(weekDayNumberMatches[0].replace("W", ""));
+                        var dayString = dayNumber == 1 ? this.i18n.firstWeekday() : stringUtilities_1.StringUtilities.format(this.i18n.weekdayNearestDayX0(), dayNumber.toString());
+                        description = stringUtilities_1.StringUtilities.format(this.i18n.commaOnTheX0OfTheMonth(), dayString);
+                        break;
+                      } else {
+                        var lastDayOffSetMatches = expression.match(/L-(\d{1,2})/);
+                        if (lastDayOffSetMatches) {
+                          var offSetDays = lastDayOffSetMatches[1];
+                          description = stringUtilities_1.StringUtilities.format(this.i18n.commaDaysBeforeTheLastDayOfTheMonth(offSetDays), offSetDays);
+                          break;
+                        } else if (expression == "*" && this.expressionParts[5] != "*") {
+                          return "";
+                        } else {
+                          description = this.getSegmentDescription(expression, this.i18n.commaEveryDay(), function(s) {
+                            return s == "L" ? _this.i18n.lastDay() : _this.i18n.dayX0 ? stringUtilities_1.StringUtilities.format(_this.i18n.dayX0(), s) : s;
+                          }, function(s) {
+                            return s == "1" ? _this.i18n.commaEveryDay() : _this.i18n.commaEveryX0Days(s);
+                          }, function(s) {
+                            return _this.i18n.commaBetweenDayX0AndX1OfTheMonth(s);
+                          }, function(s) {
+                            return _this.i18n.commaOnDayX0OfTheMonth(s);
+                          });
+                        }
+                        break;
+                      }
+                  }
+                  return description;
+                };
+                ExpressionDescriptor2.prototype.getYearDescription = function() {
+                  var _this = this;
+                  var description = this.getSegmentDescription(this.expressionParts[6], "", function(s) {
+                    return /^\d+$/.test(s) ? new Date(parseInt(s), 1).getFullYear().toString() : s;
+                  }, function(s) {
+                    return stringUtilities_1.StringUtilities.format(_this.i18n.commaEveryX0Years(s), s);
+                  }, function(s) {
+                    return _this.i18n.commaYearX0ThroughYearX1() || _this.i18n.commaX0ThroughX1();
+                  }, function(s) {
+                    return _this.i18n.commaOnlyInYearX0 ? _this.i18n.commaOnlyInYearX0() : _this.i18n.commaOnlyInX0();
+                  });
+                  return description;
+                };
+                ExpressionDescriptor2.prototype.getSegmentDescription = function(expression, allDescription, getSingleItemDescription, getIncrementDescriptionFormat, getRangeDescriptionFormat, getDescriptionFormat) {
+                  var description = null;
+                  var doesExpressionContainIncrement = expression.indexOf("/") > -1;
+                  var doesExpressionContainRange = expression.indexOf("-") > -1;
+                  var doesExpressionContainMultipleValues = expression.indexOf(",") > -1;
+                  if (!expression) {
+                    description = "";
+                  } else if (expression === "*") {
+                    description = allDescription;
+                  } else if (!doesExpressionContainIncrement && !doesExpressionContainRange && !doesExpressionContainMultipleValues) {
+                    description = stringUtilities_1.StringUtilities.format(getDescriptionFormat(expression), getSingleItemDescription(expression));
+                  } else if (doesExpressionContainMultipleValues) {
+                    var segments = expression.split(",");
+                    var descriptionContent = "";
+                    for (var i = 0; i < segments.length; i++) {
+                      if (i > 0 && segments.length > 2) {
+                        descriptionContent += ",";
+                        if (i < segments.length - 1) {
+                          descriptionContent += " ";
+                        }
+                      }
+                      if (i > 0 && segments.length > 1 && (i == segments.length - 1 || segments.length == 2)) {
+                        descriptionContent += "".concat(this.i18n.spaceAnd(), " ");
+                      }
+                      if (segments[i].indexOf("/") > -1 || segments[i].indexOf("-") > -1) {
+                        var isSegmentRangeWithoutIncrement = segments[i].indexOf("-") > -1 && segments[i].indexOf("/") == -1;
+                        var currentDescriptionContent = this.getSegmentDescription(segments[i], allDescription, getSingleItemDescription, getIncrementDescriptionFormat, isSegmentRangeWithoutIncrement ? this.i18n.commaX0ThroughX1 : getRangeDescriptionFormat, getDescriptionFormat);
+                        if (isSegmentRangeWithoutIncrement) {
+                          currentDescriptionContent = currentDescriptionContent.replace(", ", "");
+                        }
+                        descriptionContent += currentDescriptionContent;
+                      } else if (!doesExpressionContainIncrement) {
+                        descriptionContent += getSingleItemDescription(segments[i]);
+                      } else {
+                        var segmentDescription = this.getSegmentDescription(segments[i], allDescription, getSingleItemDescription, getIncrementDescriptionFormat, getRangeDescriptionFormat, getDescriptionFormat);
+                        if (segmentDescription && segmentDescription.startsWith(", ")) {
+                          segmentDescription = segmentDescription.substring(2);
+                        }
+                        descriptionContent += segmentDescription;
+                      }
+                    }
+                    if (!doesExpressionContainIncrement) {
+                      description = stringUtilities_1.StringUtilities.format(getDescriptionFormat(expression), descriptionContent);
+                    } else {
+                      description = descriptionContent;
+                    }
+                  } else if (doesExpressionContainIncrement) {
+                    var segments = expression.split("/");
+                    description = stringUtilities_1.StringUtilities.format(getIncrementDescriptionFormat(segments[1]), segments[1]);
+                    if (segments[0].indexOf("-") > -1) {
+                      var rangeSegmentDescription = this.generateRangeSegmentDescription(segments[0], getRangeDescriptionFormat, getSingleItemDescription);
+                      if (rangeSegmentDescription.indexOf(", ") != 0) {
+                        description += ", ";
+                      }
+                      description += rangeSegmentDescription;
+                    } else if (segments[0].indexOf("*") == -1) {
+                      var rangeItemDescription = stringUtilities_1.StringUtilities.format(getDescriptionFormat(segments[0]), getSingleItemDescription(segments[0]));
+                      rangeItemDescription = rangeItemDescription.replace(", ", "");
+                      description += stringUtilities_1.StringUtilities.format(this.i18n.commaStartingX0(), rangeItemDescription);
+                    }
+                  } else if (doesExpressionContainRange) {
+                    description = this.generateRangeSegmentDescription(expression, getRangeDescriptionFormat, getSingleItemDescription);
+                  }
+                  return description;
+                };
+                ExpressionDescriptor2.prototype.generateRangeSegmentDescription = function(rangeExpression, getRangeDescriptionFormat, getSingleItemDescription) {
+                  var description = "";
+                  var rangeSegments = rangeExpression.split("-");
+                  var rangeSegment1Description = getSingleItemDescription(rangeSegments[0], 1);
+                  var rangeSegment2Description = getSingleItemDescription(rangeSegments[1], 2);
+                  var rangeDescriptionFormat = getRangeDescriptionFormat(rangeExpression);
+                  description += stringUtilities_1.StringUtilities.format(rangeDescriptionFormat, rangeSegment1Description, rangeSegment2Description);
+                  return description;
+                };
+                ExpressionDescriptor2.prototype.formatTime = function(hourExpression, minuteExpression, secondExpression) {
+                  var hourOffset = 0;
+                  var minuteOffset = 0;
+                  var hour = parseInt(hourExpression) + hourOffset;
+                  var minute = parseInt(minuteExpression) + minuteOffset;
+                  if (minute >= 60) {
+                    minute -= 60;
+                    hour += 1;
+                  } else if (minute < 0) {
+                    minute += 60;
+                    hour -= 1;
+                  }
+                  if (hour >= 24) {
+                    hour = hour - 24;
+                  } else if (hour < 0) {
+                    hour = 24 + hour;
+                  }
+                  var period = "";
+                  var setPeriodBeforeTime = false;
+                  if (!this.options.use24HourTimeFormat) {
+                    setPeriodBeforeTime = !!(this.i18n.setPeriodBeforeTime && this.i18n.setPeriodBeforeTime());
+                    period = setPeriodBeforeTime ? "".concat(this.getPeriod(hour), " ") : " ".concat(this.getPeriod(hour));
+                    if (hour > 12) {
+                      hour -= 12;
+                    }
+                    if (hour === 0) {
+                      hour = 12;
+                    }
+                  }
+                  var second = "";
+                  if (secondExpression) {
+                    second = ":".concat(("00" + secondExpression).substring(secondExpression.length));
+                  }
+                  return "".concat(setPeriodBeforeTime ? period : "").concat(("00" + hour.toString()).substring(hour.toString().length), ":").concat(("00" + minute.toString()).substring(minute.toString().length)).concat(second).concat(!setPeriodBeforeTime ? period : "");
+                };
+                ExpressionDescriptor2.prototype.transformVerbosity = function(description, useVerboseFormat) {
+                  if (!useVerboseFormat) {
+                    description = description.replace(new RegExp(", ".concat(this.i18n.everyMinute()), "g"), "");
+                    description = description.replace(new RegExp(", ".concat(this.i18n.everyHour()), "g"), "");
+                    description = description.replace(new RegExp(this.i18n.commaEveryDay(), "g"), "");
+                    description = description.replace(/\, ?$/, "");
+                    if (this.i18n.conciseVerbosityReplacements) {
+                      for (var _i = 0, _a = Object.entries(this.i18n.conciseVerbosityReplacements()); _i < _a.length; _i++) {
+                        var _b = _a[_i], key = _b[0], value = _b[1];
+                        description = description.replace(new RegExp(key, "g"), value);
+                      }
+                    }
+                  }
+                  return description;
+                };
+                ExpressionDescriptor2.prototype.getPeriod = function(hour) {
+                  return hour >= 12 ? this.i18n.pm && this.i18n.pm() || "PM" : this.i18n.am && this.i18n.am() || "AM";
+                };
+                ExpressionDescriptor2.locales = {};
+                return ExpressionDescriptor2;
+              })();
+              exports3.ExpressionDescriptor = ExpressionDescriptor;
+            },
+            /***/
+            747(__unused_webpack_module, exports3, __webpack_require__2) {
+              Object.defineProperty(exports3, "__esModule", { value: true });
+              exports3.enLocaleLoader = void 0;
+              var en_1 = __webpack_require__2(486);
+              var enLocaleLoader = (function() {
+                function enLocaleLoader2() {
+                }
+                enLocaleLoader2.prototype.load = function(availableLocales) {
+                  availableLocales["en"] = new en_1.en();
+                };
+                return enLocaleLoader2;
+              })();
+              exports3.enLocaleLoader = enLocaleLoader;
+            },
+            /***/
+            486(__unused_webpack_module, exports3) {
+              Object.defineProperty(exports3, "__esModule", { value: true });
+              exports3.en = void 0;
+              var en = (function() {
+                function en2() {
+                }
+                en2.prototype.atX0SecondsPastTheMinuteGt20 = function() {
+                  return null;
+                };
+                en2.prototype.atX0MinutesPastTheHourGt20 = function() {
+                  return null;
+                };
+                en2.prototype.commaMonthX0ThroughMonthX1 = function() {
+                  return null;
+                };
+                en2.prototype.commaYearX0ThroughYearX1 = function() {
+                  return null;
+                };
+                en2.prototype.use24HourTimeFormatByDefault = function() {
+                  return false;
+                };
+                en2.prototype.anErrorOccuredWhenGeneratingTheExpressionD = function() {
+                  return "An error occurred when generating the expression description. Check the cron expression syntax.";
+                };
+                en2.prototype.everyMinute = function() {
+                  return "every minute";
+                };
+                en2.prototype.everyHour = function() {
+                  return "every hour";
+                };
+                en2.prototype.atSpace = function() {
+                  return "At ";
+                };
+                en2.prototype.everyMinuteBetweenX0AndX1 = function() {
+                  return "Every minute between %s and %s";
+                };
+                en2.prototype.at = function() {
+                  return "At";
+                };
+                en2.prototype.spaceAnd = function() {
+                  return " and";
+                };
+                en2.prototype.everySecond = function() {
+                  return "every second";
+                };
+                en2.prototype.everyX0Seconds = function() {
+                  return "every %s seconds";
+                };
+                en2.prototype.secondsX0ThroughX1PastTheMinute = function() {
+                  return "seconds %s through %s past the minute";
+                };
+                en2.prototype.atX0SecondsPastTheMinute = function() {
+                  return "at %s seconds past the minute";
+                };
+                en2.prototype.everyX0Minutes = function() {
+                  return "every %s minutes";
+                };
+                en2.prototype.minutesX0ThroughX1PastTheHour = function() {
+                  return "minutes %s through %s past the hour";
+                };
+                en2.prototype.atX0MinutesPastTheHour = function() {
+                  return "at %s minutes past the hour";
+                };
+                en2.prototype.everyX0Hours = function() {
+                  return "every %s hours";
+                };
+                en2.prototype.betweenX0AndX1 = function() {
+                  return "between %s and %s";
+                };
+                en2.prototype.atX0 = function() {
+                  return "at %s";
+                };
+                en2.prototype.commaEveryDay = function() {
+                  return ", every day";
+                };
+                en2.prototype.commaEveryX0DaysOfTheWeek = function() {
+                  return ", every %s days of the week";
+                };
+                en2.prototype.commaX0ThroughX1 = function() {
+                  return ", %s through %s";
+                };
+                en2.prototype.commaAndX0ThroughX1 = function() {
+                  return ", %s through %s";
+                };
+                en2.prototype.first = function() {
+                  return "first";
+                };
+                en2.prototype.second = function() {
+                  return "second";
+                };
+                en2.prototype.third = function() {
+                  return "third";
+                };
+                en2.prototype.fourth = function() {
+                  return "fourth";
+                };
+                en2.prototype.fifth = function() {
+                  return "fifth";
+                };
+                en2.prototype.commaOnThe = function() {
+                  return ", on the ";
+                };
+                en2.prototype.spaceX0OfTheMonth = function() {
+                  return " %s of the month";
+                };
+                en2.prototype.lastDay = function() {
+                  return "the last day";
+                };
+                en2.prototype.commaOnTheLastX0OfTheMonth = function() {
+                  return ", on the last %s of the month";
+                };
+                en2.prototype.commaOnlyOnX0 = function() {
+                  return ", only on %s";
+                };
+                en2.prototype.commaAndOnX0 = function() {
+                  return ", and on %s";
+                };
+                en2.prototype.commaEveryX0Months = function() {
+                  return ", every %s months";
+                };
+                en2.prototype.commaOnlyInX0 = function() {
+                  return ", only in %s";
+                };
+                en2.prototype.commaOnTheLastDayOfTheMonth = function() {
+                  return ", on the last day of the month";
+                };
+                en2.prototype.commaOnTheLastWeekdayOfTheMonth = function() {
+                  return ", on the last weekday of the month";
+                };
+                en2.prototype.commaDaysBeforeTheLastDayOfTheMonth = function() {
+                  return ", %s days before the last day of the month";
+                };
+                en2.prototype.firstWeekday = function() {
+                  return "first weekday";
+                };
+                en2.prototype.weekdayNearestDayX0 = function() {
+                  return "weekday nearest day %s";
+                };
+                en2.prototype.commaOnTheX0OfTheMonth = function() {
+                  return ", on the %s of the month";
+                };
+                en2.prototype.commaEveryX0Days = function() {
+                  return ", every %s days in a month";
+                };
+                en2.prototype.commaBetweenDayX0AndX1OfTheMonth = function() {
+                  return ", between day %s and %s of the month";
+                };
+                en2.prototype.commaOnDayX0OfTheMonth = function() {
+                  return ", on day %s of the month";
+                };
+                en2.prototype.commaEveryHour = function() {
+                  return ", every hour";
+                };
+                en2.prototype.commaEveryX0Years = function() {
+                  return ", every %s years";
+                };
+                en2.prototype.commaStartingX0 = function() {
+                  return ", starting %s";
+                };
+                en2.prototype.daysOfTheWeek = function() {
+                  return ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+                };
+                en2.prototype.monthsOfTheYear = function() {
+                  return [
+                    "January",
+                    "February",
+                    "March",
+                    "April",
+                    "May",
+                    "June",
+                    "July",
+                    "August",
+                    "September",
+                    "October",
+                    "November",
+                    "December"
+                  ];
+                };
+                en2.prototype.atReboot = function() {
+                  return "Run once, at startup";
+                };
+                en2.prototype.onTheHour = function() {
+                  return "on the hour";
+                };
+                return en2;
+              })();
+              exports3.en = en;
+            },
+            /***/
+            515(__unused_webpack_module, exports3) {
+              Object.defineProperty(exports3, "__esModule", { value: true });
+              function assert(value, message2) {
+                if (!value) {
+                  throw new Error(message2);
+                }
+              }
+              var RangeValidator = (function() {
+                function RangeValidator2() {
+                }
+                RangeValidator2.secondRange = function(parse) {
+                  var parsed = parse.split(",");
+                  for (var i = 0; i < parsed.length; i++) {
+                    if (!isNaN(parseInt(parsed[i], 10))) {
+                      var second = parseInt(parsed[i], 10);
+                      assert(second >= 0 && second <= 59, "seconds part must be >= 0 and <= 59");
+                    }
+                  }
+                };
+                RangeValidator2.minuteRange = function(parse) {
+                  var parsed = parse.split(",");
+                  for (var i = 0; i < parsed.length; i++) {
+                    if (!isNaN(parseInt(parsed[i], 10))) {
+                      var minute = parseInt(parsed[i], 10);
+                      assert(minute >= 0 && minute <= 59, "minutes part must be >= 0 and <= 59");
+                    }
+                  }
+                };
+                RangeValidator2.hourRange = function(parse) {
+                  var parsed = parse.split(",");
+                  for (var i = 0; i < parsed.length; i++) {
+                    if (!isNaN(parseInt(parsed[i], 10))) {
+                      var hour = parseInt(parsed[i], 10);
+                      assert(hour >= 0 && hour <= 23, "hours part must be >= 0 and <= 23");
+                    }
+                  }
+                };
+                RangeValidator2.dayOfMonthRange = function(parse) {
+                  var parsed = parse.split(",");
+                  for (var i = 0; i < parsed.length; i++) {
+                    if (!isNaN(parseInt(parsed[i], 10))) {
+                      var dayOfMonth = parseInt(parsed[i], 10);
+                      assert(dayOfMonth >= 1 && dayOfMonth <= 31, "DOM part must be >= 1 and <= 31");
+                    }
+                  }
+                };
+                RangeValidator2.monthRange = function(parse, monthStartIndexZero) {
+                  var parsed = parse.split(",");
+                  for (var i = 0; i < parsed.length; i++) {
+                    if (!isNaN(parseInt(parsed[i], 10))) {
+                      var month = parseInt(parsed[i], 10);
+                      assert(month >= 1 && month <= 12, monthStartIndexZero ? "month part must be >= 0 and <= 11" : "month part must be >= 1 and <= 12");
+                    }
+                  }
+                };
+                RangeValidator2.dayOfWeekRange = function(parse, dayOfWeekStartIndexZero) {
+                  var parsed = parse.split(",");
+                  for (var i = 0; i < parsed.length; i++) {
+                    if (!isNaN(parseInt(parsed[i], 10))) {
+                      var dayOfWeek = parseInt(parsed[i], 10);
+                      assert(dayOfWeek >= 0 && dayOfWeek <= 6, dayOfWeekStartIndexZero ? "DOW part must be >= 0 and <= 6" : "DOW part must be >= 1 and <= 7");
+                    }
+                  }
+                };
+                return RangeValidator2;
+              })();
+              exports3["default"] = RangeValidator;
+            },
+            /***/
+            823(__unused_webpack_module, exports3) {
+              Object.defineProperty(exports3, "__esModule", { value: true });
+              exports3.StringUtilities = void 0;
+              var StringUtilities = (function() {
+                function StringUtilities2() {
+                }
+                StringUtilities2.format = function(template2) {
+                  var values = [];
+                  for (var _i = 1; _i < arguments.length; _i++) {
+                    values[_i - 1] = arguments[_i];
+                  }
+                  return template2.replace(/%s/g, function(substring) {
+                    var args = [];
+                    for (var _i2 = 1; _i2 < arguments.length; _i2++) {
+                      args[_i2 - 1] = arguments[_i2];
+                    }
+                    return values.shift();
+                  });
+                };
+                StringUtilities2.containsAny = function(text, searchStrings) {
+                  return searchStrings.some(function(c) {
+                    return text.indexOf(c) > -1;
+                  });
+                };
+                return StringUtilities2;
+              })();
+              exports3.StringUtilities = StringUtilities;
+            }
+            /******/
+          };
+          var __webpack_module_cache__ = {};
+          function __webpack_require__(moduleId) {
+            var cachedModule = __webpack_module_cache__[moduleId];
+            if (cachedModule !== void 0) {
+              return cachedModule.exports;
+            }
+            var module3 = __webpack_module_cache__[moduleId] = {
+              /******/
+              // no module.id needed
+              /******/
+              // no module.loaded needed
+              /******/
+              exports: {}
+              /******/
+            };
+            __webpack_modules__[moduleId](module3, module3.exports, __webpack_require__);
+            return module3.exports;
+          }
+          var __webpack_exports__ = {};
+          (() => {
+            var exports3 = __webpack_exports__;
+            Object.defineProperty(exports3, "__esModule", { value: true });
+            exports3.toString = void 0;
+            var expressionDescriptor_1 = __webpack_require__(333);
+            var enLocaleLoader_1 = __webpack_require__(747);
+            expressionDescriptor_1.ExpressionDescriptor.initialize(new enLocaleLoader_1.enLocaleLoader());
+            exports3["default"] = expressionDescriptor_1.ExpressionDescriptor;
+            var cronstrue_toString = expressionDescriptor_1.ExpressionDescriptor.toString;
+            exports3.toString = cronstrue_toString;
+          })();
+          return __webpack_exports__;
+        })()
+      );
+    });
+  }
+});
+
 // node_modules/commander/lib/error.js
 var require_error = __commonJS({
   "node_modules/commander/lib/error.js"(exports2) {
@@ -3532,7 +4592,7 @@ var require_main = __commonJS({
   "node_modules/dotenv/lib/main.js"(exports2, module2) {
     var fs5 = require("fs");
     var path7 = require("path");
-    var os2 = require("os");
+    var os3 = require("os");
     var crypto2 = require("crypto");
     var packageJson = require_package();
     var version = packageJson.version;
@@ -3688,7 +4748,7 @@ var require_main = __commonJS({
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path7.join(os2.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path7.join(os3.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
@@ -13681,55 +14741,54 @@ var require_lib5 = __commonJS({
     var Buffer2 = require_safer().Buffer;
     var bomHandling = require_bom_handling();
     var mergeModules = require_merge_exports();
-    var iconv2 = module2.exports;
-    iconv2.encodings = null;
-    iconv2.defaultCharUnicode = "\uFFFD";
-    iconv2.defaultCharSingleByte = "?";
-    iconv2.encode = function encode3(str, encoding, options) {
+    module2.exports.encodings = null;
+    module2.exports.defaultCharUnicode = "\uFFFD";
+    module2.exports.defaultCharSingleByte = "?";
+    module2.exports.encode = function encode3(str, encoding, options) {
       str = "" + (str || "");
-      var encoder = iconv2.getEncoder(encoding, options);
+      var encoder = module2.exports.getEncoder(encoding, options);
       var res = encoder.write(str);
       var trail = encoder.end();
       return trail && trail.length > 0 ? Buffer2.concat([res, trail]) : res;
     };
-    iconv2.decode = function decode(buf, encoding, options) {
+    module2.exports.decode = function decode(buf, encoding, options) {
       if (typeof buf === "string") {
-        if (!iconv2.skipDecodeWarning) {
+        if (!module2.exports.skipDecodeWarning) {
           console.error("Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding");
-          iconv2.skipDecodeWarning = true;
+          module2.exports.skipDecodeWarning = true;
         }
         buf = Buffer2.from("" + (buf || ""), "binary");
       }
-      var decoder = iconv2.getDecoder(encoding, options);
+      var decoder = module2.exports.getDecoder(encoding, options);
       var res = decoder.write(buf);
       var trail = decoder.end();
       return trail ? res + trail : res;
     };
-    iconv2.encodingExists = function encodingExists(enc) {
+    module2.exports.encodingExists = function encodingExists(enc) {
       try {
-        iconv2.getCodec(enc);
+        module2.exports.getCodec(enc);
         return true;
       } catch (e) {
         return false;
       }
     };
-    iconv2.toEncoding = iconv2.encode;
-    iconv2.fromEncoding = iconv2.decode;
-    iconv2._codecDataCache = { __proto__: null };
-    iconv2.getCodec = function getCodec(encoding) {
-      if (!iconv2.encodings) {
+    module2.exports.toEncoding = module2.exports.encode;
+    module2.exports.fromEncoding = module2.exports.decode;
+    module2.exports._codecDataCache = { __proto__: null };
+    module2.exports.getCodec = function getCodec(encoding) {
+      if (!module2.exports.encodings) {
         var raw = require_encodings();
-        iconv2.encodings = { __proto__: null };
-        mergeModules(iconv2.encodings, raw);
+        module2.exports.encodings = { __proto__: null };
+        mergeModules(module2.exports.encodings, raw);
       }
-      var enc = iconv2._canonicalizeEncoding(encoding);
+      var enc = module2.exports._canonicalizeEncoding(encoding);
       var codecOptions = {};
       while (true) {
-        var codec = iconv2._codecDataCache[enc];
+        var codec = module2.exports._codecDataCache[enc];
         if (codec) {
           return codec;
         }
-        var codecDef = iconv2.encodings[enc];
+        var codecDef = module2.exports.encodings[enc];
         switch (typeof codecDef) {
           case "string":
             enc = codecDef;
@@ -13747,47 +14806,47 @@ var require_lib5 = __commonJS({
             if (!codecOptions.encodingName) {
               codecOptions.encodingName = enc;
             }
-            codec = new codecDef(codecOptions, iconv2);
-            iconv2._codecDataCache[codecOptions.encodingName] = codec;
+            codec = new codecDef(codecOptions, module2.exports);
+            module2.exports._codecDataCache[codecOptions.encodingName] = codec;
             return codec;
           default:
             throw new Error("Encoding not recognized: '" + encoding + "' (searched as: '" + enc + "')");
         }
       }
     };
-    iconv2._canonicalizeEncoding = function(encoding) {
+    module2.exports._canonicalizeEncoding = function(encoding) {
       return ("" + encoding).toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, "");
     };
-    iconv2.getEncoder = function getEncoder(encoding, options) {
-      var codec = iconv2.getCodec(encoding);
+    module2.exports.getEncoder = function getEncoder(encoding, options) {
+      var codec = module2.exports.getCodec(encoding);
       var encoder = new codec.encoder(options, codec);
       if (codec.bomAware && options && options.addBOM) {
         encoder = new bomHandling.PrependBOM(encoder, options);
       }
       return encoder;
     };
-    iconv2.getDecoder = function getDecoder(encoding, options) {
-      var codec = iconv2.getCodec(encoding);
+    module2.exports.getDecoder = function getDecoder(encoding, options) {
+      var codec = module2.exports.getCodec(encoding);
       var decoder = new codec.decoder(options, codec);
       if (codec.bomAware && !(options && options.stripBOM === false)) {
         decoder = new bomHandling.StripBOM(decoder, options);
       }
       return decoder;
     };
-    iconv2.enableStreamingAPI = function enableStreamingAPI(streamModule2) {
-      if (iconv2.supportsStreams) {
+    module2.exports.enableStreamingAPI = function enableStreamingAPI(streamModule2) {
+      if (module2.exports.supportsStreams) {
         return;
       }
       var streams = require_streams()(streamModule2);
-      iconv2.IconvLiteEncoderStream = streams.IconvLiteEncoderStream;
-      iconv2.IconvLiteDecoderStream = streams.IconvLiteDecoderStream;
-      iconv2.encodeStream = function encodeStream(encoding, options) {
-        return new iconv2.IconvLiteEncoderStream(iconv2.getEncoder(encoding, options), options);
+      module2.exports.IconvLiteEncoderStream = streams.IconvLiteEncoderStream;
+      module2.exports.IconvLiteDecoderStream = streams.IconvLiteDecoderStream;
+      module2.exports.encodeStream = function encodeStream(encoding, options) {
+        return new module2.exports.IconvLiteEncoderStream(module2.exports.getEncoder(encoding, options), options);
       };
-      iconv2.decodeStream = function decodeStream(encoding, options) {
-        return new iconv2.IconvLiteDecoderStream(iconv2.getDecoder(encoding, options), options);
+      module2.exports.decodeStream = function decodeStream(encoding, options) {
+        return new module2.exports.IconvLiteDecoderStream(module2.exports.getDecoder(encoding, options), options);
       };
-      iconv2.supportsStreams = true;
+      module2.exports.supportsStreams = true;
     };
     var streamModule;
     try {
@@ -13795,9 +14854,9 @@ var require_lib5 = __commonJS({
     } catch (e) {
     }
     if (streamModule && streamModule.Transform) {
-      iconv2.enableStreamingAPI(streamModule);
+      module2.exports.enableStreamingAPI(streamModule);
     } else {
-      iconv2.encodeStream = iconv2.decodeStream = function() {
+      module2.exports.encodeStream = module2.exports.decodeStream = function() {
         throw new Error("iconv-lite Streaming API is not enabled. Use iconv.enableStreamingAPI(require('stream')); to enable it.");
       };
     }
@@ -33577,7 +34636,7 @@ var require_form_data = __commonJS({
     FormData3.prototype.toString = function() {
       return "[object FormData]";
     };
-    setToStringTag(FormData3, "FormData");
+    setToStringTag(FormData3.prototype, "FormData");
     module2.exports = FormData3;
   }
 });
@@ -34132,7 +35191,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
-    var os2 = require("os");
+    var os3 = require("os");
     var tty2 = require("tty");
     var hasFlag = require_has_flag();
     var { env: env2 } = process;
@@ -34180,7 +35239,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os2.release().split(".");
+        const osRelease = os3.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -38687,11 +39746,11 @@ var require_clone = __commonJS({
   "node_modules/clone/clone.js"(exports2, module2) {
     var clone4 = (function() {
       "use strict";
-      function clone5(parent, circular, depth, prototype3) {
+      function clone5(parent, circular, depth, prototype2) {
         var filter3;
         if (typeof circular === "object") {
           depth = circular.depth;
-          prototype3 = circular.prototype;
+          prototype2 = circular.prototype;
           filter3 = circular.filter;
           circular = circular.circular;
         }
@@ -38728,12 +39787,12 @@ var require_clone = __commonJS({
             parent2.copy(child);
             return child;
           } else {
-            if (typeof prototype3 == "undefined") {
+            if (typeof prototype2 == "undefined") {
               proto = Object.getPrototypeOf(parent2);
               child = Object.create(proto);
             } else {
-              child = Object.create(prototype3);
-              proto = prototype3;
+              child = Object.create(prototype2);
+              proto = prototype2;
             }
           }
           if (circular) {
@@ -42469,8 +43528,18 @@ var require_error_utils = __commonJS({
   "node_modules/create-nx-workspace/src/utils/error-utils.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.CreateNxWorkspaceError = void 0;
+    exports2.CreateNxWorkspaceError = exports2.CnwError = void 0;
     exports2.mapErrorToBodyLines = mapErrorToBodyLines;
+    var CnwError = class extends Error {
+      constructor(code, message2, logFile, exitCode) {
+        super(message2);
+        this.code = code;
+        this.logFile = logFile;
+        this.exitCode = exitCode;
+        this.name = "CnwError";
+      }
+    };
+    exports2.CnwError = CnwError;
     var CreateNxWorkspaceError = class extends Error {
       constructor(logMessage, code, logFile) {
         super(logMessage);
@@ -42490,7 +43559,7 @@ var require_error_utils = __commonJS({
         }
         return lines2;
       }
-      const lines = error instanceof CreateNxWorkspaceError ? [`Exit code: ${error.code}`, `Log file: ${error.logFile}`] : [];
+      const lines = error instanceof CreateNxWorkspaceError ? [`Exit code: ${error.code}`, `Log file: ${error.logFile}`] : error instanceof CnwError && error.logFile ? [`Log file: ${error.logFile}`] : [];
       if (process.env.NX_VERBOSE_LOGGING === "true") {
         lines.push(`Error: ${error.message}`);
         lines.push(`Stack: ${error.stack}`);
@@ -42572,165 +43641,6 @@ ${stderr}`);
   }
 });
 
-// node_modules/create-nx-workspace/src/utils/ci/is-ci.js
-var require_is_ci = __commonJS({
-  "node_modules/create-nx-workspace/src/utils/ci/is-ci.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.isCI = isCI2;
-    function isCI2() {
-      return process.env.CI && process.env.CI !== "false" || process.env.TF_BUILD === "true" || process.env.GITHUB_ACTIONS === "true" || process.env.BUILDKITE === "true" || process.env.CIRCLECI === "true" || process.env.CIRRUS_CI === "true" || process.env.TRAVIS === "true" || !!process.env["bamboo.buildKey"] || !!process.env.CODEBUILD_BUILD_ID || !!process.env.GITLAB_CI || !!process.env.HEROKU_TEST_RUN_ID || !!process.env.BUILD_ID || !!process.env.BUILD_BUILDID || !!process.env.TEAMCITY_VERSION;
-    }
-  }
-});
-
-// node_modules/create-nx-workspace/src/utils/output.js
-var require_output = __commonJS({
-  "node_modules/create-nx-workspace/src/utils/output.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.output = exports2.CLIOutput = void 0;
-    var chalk = require_source();
-    var os_1 = require("os");
-    var is_ci_1 = require_is_ci();
-    if ((0, is_ci_1.isCI)()) {
-      chalk.level = 0;
-    }
-    var CLIOutput = class {
-      constructor(real = true) {
-        this.real = real;
-        this.outstream = this.real ? process.stdout : new FakeStdout();
-        this.colors = {
-          gray: chalk.gray,
-          green: chalk.green,
-          red: chalk.red,
-          cyan: chalk.cyan,
-          white: chalk.white
-        };
-        this.bold = chalk.bold;
-        this.underline = chalk.underline;
-        this.dim = chalk.dim;
-        this.cliName = "NX";
-      }
-      /**
-       * Longer dash character which forms more of a continuous line when place side to side
-       * with itself, unlike the standard dash character
-       */
-      get VERTICAL_SEPARATOR() {
-        let divider = "";
-        for (let i = 0; i < process.stdout.columns - 1; i++) {
-          divider += "\u2014";
-        }
-        return divider;
-      }
-      writeToStdOut(str) {
-        this.outstream.write(str);
-      }
-      writeOutputTitle({ color: color2, title }) {
-        this.writeToStdOut(`${this.applyCLIPrefix(color2, title)}${os_1.EOL}`);
-      }
-      writeOptionalOutputBody(bodyLines) {
-        if (!bodyLines) {
-          return;
-        }
-        this.addNewline();
-        bodyLines.forEach((bodyLine) => this.writeToStdOut(`${bodyLine}${os_1.EOL}`));
-      }
-      setCliName(name) {
-        this.cliName = name;
-      }
-      applyCLIPrefix(color2 = "cyan", text) {
-        let cliPrefix = "";
-        if (chalk[color2]) {
-          cliPrefix = chalk.reset.inverse.bold[color2](` ${this.cliName} `);
-        } else {
-          cliPrefix = chalk.reset.inverse.bold.keyword(color2)(` ${this.cliName} `);
-        }
-        return `${cliPrefix}  ${text}`;
-      }
-      addNewline() {
-        this.writeToStdOut(os_1.EOL);
-      }
-      addVerticalSeparator(color2 = "gray") {
-        this.addNewline();
-        this.addVerticalSeparatorWithoutNewLines(color2);
-        this.addNewline();
-      }
-      addVerticalSeparatorWithoutNewLines(color2 = "gray") {
-        this.writeToStdOut(`${chalk.dim[color2](this.VERTICAL_SEPARATOR)}${os_1.EOL}`);
-      }
-      error({ title, bodyLines }) {
-        this.addNewline();
-        this.writeOutputTitle({
-          color: "red",
-          title: chalk.red(title)
-        });
-        this.writeOptionalOutputBody(bodyLines);
-        this.addNewline();
-      }
-      warn({ title, bodyLines }) {
-        this.addNewline();
-        this.writeOutputTitle({
-          color: "yellow",
-          title: chalk.yellow(title)
-        });
-        this.writeOptionalOutputBody(bodyLines);
-        this.addNewline();
-      }
-      note({ title, bodyLines }) {
-        this.addNewline();
-        this.writeOutputTitle({
-          color: "orange",
-          title: chalk.keyword("orange")(title)
-        });
-        this.writeOptionalOutputBody(bodyLines);
-        this.addNewline();
-      }
-      success({ title, bodyLines }) {
-        this.addNewline();
-        this.writeOutputTitle({
-          color: "green",
-          title: chalk.green(title)
-        });
-        this.writeOptionalOutputBody(bodyLines);
-      }
-      logSingleLine(message2) {
-        this.addNewline();
-        this.writeOutputTitle({
-          color: "gray",
-          title: message2
-        });
-        this.addNewline();
-      }
-      log({ title, bodyLines, color: color2 }) {
-        this.addNewline();
-        this.writeOutputTitle({
-          color: "cyan",
-          title: color2 ? chalk[color2](title) : title
-        });
-        this.writeOptionalOutputBody(bodyLines);
-        this.addNewline();
-      }
-      getOutput() {
-        return this.outstream.toString();
-      }
-    };
-    exports2.CLIOutput = CLIOutput;
-    exports2.output = new CLIOutput();
-    var FakeStdout = class {
-      constructor() {
-        this.content = "";
-      }
-      write(str) {
-        this.content += str;
-      }
-      toString() {
-        return this.content;
-      }
-    };
-  }
-});
-
 // node_modules/create-nx-workspace/src/utils/package-manager.js
 var require_package_manager = __commonJS({
   "node_modules/create-nx-workspace/src/utils/package-manager.js"(exports2) {
@@ -42740,6 +43650,10 @@ var require_package_manager = __commonJS({
     exports2.detectPackageManager = detectPackageManager;
     exports2.getPackageManagerCommand = getPackageManagerCommand;
     exports2.generatePackageManagerFiles = generatePackageManagerFiles;
+    exports2.workspacesToPnpmYaml = workspacesToPnpmYaml;
+    exports2.convertStarToWorkspaceProtocol = convertStarToWorkspaceProtocol;
+    exports2.findAllWorkspacePackageJsons = findAllWorkspacePackageJsons;
+    exports2.findWorkspacePackages = findWorkspacePackages;
     exports2.getPackageManagerVersion = getPackageManagerVersion;
     exports2.detectInvokedPackageManager = detectInvokedPackageManager;
     var node_child_process_1 = require("node:child_process");
@@ -42793,14 +43707,108 @@ var require_package_manager = __commonJS({
     function generatePackageManagerFiles(root, packageManager = detectPackageManager()) {
       const [pmMajor] = getPackageManagerVersion(packageManager).split(".");
       switch (packageManager) {
+        case "pnpm":
+          convertToWorkspaceYaml(root);
+          convertStarToWorkspaceProtocol(root);
+          break;
         case "yarn":
           if (+pmMajor >= 2) {
             (0, node_fs_1.writeFileSync)((0, node_path_1.join)(root, ".yarnrc.yml"), "nodeLinker: node-modules\nenableScripts: false");
             (0, node_fs_1.writeFileSync)((0, node_path_1.join)(root, "yarn.lock"), "");
           }
+          convertStarToWorkspaceProtocol(root);
+          break;
+        case "bun":
+          convertStarToWorkspaceProtocol(root);
           break;
       }
     }
+    function workspacesToPnpmYaml(workspaces) {
+      return `packages:
+${workspaces.map((p) => `  - '${p}'`).join("\n")}
+`;
+    }
+    function convertToWorkspaceYaml(root) {
+      const packageJsonPath = (0, node_path_1.join)(root, "package.json");
+      if (!(0, node_fs_1.existsSync)(packageJsonPath)) {
+        return;
+      }
+      const packageJson = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf-8"));
+      const workspaces = packageJson.workspaces;
+      if (!workspaces || workspaces.length === 0) {
+        return;
+      }
+      (0, node_fs_1.writeFileSync)((0, node_path_1.join)(root, "pnpm-workspace.yaml"), workspacesToPnpmYaml(workspaces));
+      delete packageJson.workspaces;
+      (0, node_fs_1.writeFileSync)(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+    }
+    function convertStarToWorkspaceProtocol(root) {
+      for (const pkgJsonPath of findAllWorkspacePackageJsons(root)) {
+        try {
+          const pkgJson = JSON.parse((0, node_fs_1.readFileSync)(pkgJsonPath, "utf-8"));
+          let updated = false;
+          for (const deps of [pkgJson.dependencies, pkgJson.devDependencies]) {
+            if (!deps)
+              continue;
+            for (const [dep, version] of Object.entries(deps)) {
+              if (version === "*") {
+                deps[dep] = "workspace:*";
+                updated = true;
+              }
+            }
+          }
+          if (updated) {
+            (0, node_fs_1.writeFileSync)(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n");
+          }
+        } catch {
+        }
+      }
+    }
+    function findAllWorkspacePackageJsons(root, maxDepth = 2) {
+      const results = [];
+      for (const dir of ["packages", "libs", "apps"]) {
+        const fullPath = (0, node_path_1.join)(root, dir);
+        if ((0, node_fs_1.existsSync)(fullPath)) {
+          findPackageJsonsRecursive(fullPath, 1, maxDepth, results);
+        }
+      }
+      return results;
+    }
+    function findPackageJsonsRecursive(dir, currentDepth, maxDepth, results) {
+      if (currentDepth > maxDepth) {
+        return;
+      }
+      try {
+        const entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory())
+            continue;
+          const entryPath = (0, node_path_1.join)(dir, entry.name);
+          const pkgJsonPath = (0, node_path_1.join)(entryPath, "package.json");
+          if ((0, node_fs_1.existsSync)(pkgJsonPath)) {
+            results.push(pkgJsonPath);
+          }
+          if (currentDepth < maxDepth) {
+            findPackageJsonsRecursive(entryPath, currentDepth + 1, maxDepth, results);
+          }
+        }
+      } catch {
+      }
+    }
+    function findWorkspacePackages(root) {
+      const packages = [];
+      const packageJsonPaths = findAllWorkspacePackageJsons(root);
+      for (const pkgJsonPath of packageJsonPaths) {
+        try {
+          const pkgJson = JSON.parse((0, node_fs_1.readFileSync)(pkgJsonPath, "utf-8"));
+          if (pkgJson.name) {
+            packages.push(pkgJson.name);
+          }
+        } catch {
+        }
+      }
+      return packages.sort();
+    }
     var pmVersionCache = /* @__PURE__ */ new Map();
     function getPackageManagerVersion(packageManager, cwd = process.cwd()) {
       if (pmVersionCache.has(packageManager)) {
@@ -42992,7 +44000,6 @@ var require_create_empty_workspace = __commonJS({
     var path_1 = require("path");
     var child_process_utils_1 = require_child_process_utils();
     var error_utils_1 = require_error_utils();
-    var output_1 = require_output();
     var package_manager_1 = require_package_manager();
     var unparse_1 = require_unparse();
     async function createEmptyWorkspace(tmpDir, name, packageManager, options) {
@@ -43021,15 +44028,8 @@ var require_create_empty_workspace = __commonJS({
         workspaceSetupSpinner.succeed(`Successfully created the workspace: ${directory}`);
       } catch (e) {
         workspaceSetupSpinner.fail();
-        if (e instanceof Error) {
-          output_1.output.error({
-            title: `Failed to create a workspace.`,
-            bodyLines: (0, error_utils_1.mapErrorToBodyLines)(e)
-          });
-        } else {
-          console.error(e);
-        }
-        process.exit(1);
+        const message2 = e instanceof Error ? e.message : String(e);
+        throw new error_utils_1.CnwError("WORKSPACE_CREATION_FAILED", `Failed to create a workspace: ${message2}`);
       } finally {
         workspaceSetupSpinner.stop();
       }
@@ -43044,7 +44044,7 @@ var require_create_preset = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.createPreset = createPreset;
-    var output_1 = require_output();
+    var error_utils_1 = require_error_utils();
     var package_manager_1 = require_package_manager();
     var child_process_utils_1 = require_child_process_utils();
     var unparse_1 = require_unparse();
@@ -43075,11 +44075,7 @@ var require_create_preset = __commonJS({
         args2.push("nx", `--nxWorkspaceRoot=${nxWorkspaceRoot}`, ...command.split(" "));
         await (0, child_process_utils_1.spawnAndWait)(exec4, args2, directory);
       } catch (e) {
-        output_1.output.error({
-          title: `Failed to apply preset: ${preset}`,
-          bodyLines: ["See above"]
-        });
-        process.exit(1);
+        throw new error_utils_1.CnwError("PRESET_FAILED", `Failed to apply preset: ${preset}`);
       }
     }
   }
@@ -43089,15 +44085,15 @@ var require_create_preset = __commonJS({
 var require_tmp = __commonJS({
   "node_modules/tmp/lib/tmp.js"(exports2, module2) {
     var fs5 = require("fs");
-    var os2 = require("os");
+    var os3 = require("os");
     var path7 = require("path");
     var crypto2 = require("crypto");
-    var _c = { fs: fs5.constants, os: os2.constants };
+    var _c = { fs: fs5.constants, os: os3.constants };
     var RANDOM_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     var TEMPLATE_PATTERN = /XXXXXX/;
     var DEFAULT_TRIES = 3;
     var CREATE_FLAGS = (_c.O_CREAT || _c.fs.O_CREAT) | (_c.O_EXCL || _c.fs.O_EXCL) | (_c.O_RDWR || _c.fs.O_RDWR);
-    var IS_WIN32 = os2.platform() === "win32";
+    var IS_WIN32 = os3.platform() === "win32";
     var EBADF = _c.EBADF || _c.os.errno.EBADF;
     var ENOENT = _c.ENOENT || _c.os.errno.ENOENT;
     var DIR_MODE = 448;
@@ -43420,10 +44416,10 @@ var require_tmp = __commonJS({
       _gracefulCleanup = true;
     }
     function _getTmpDir(options, cb) {
-      return fs5.realpath(options && options.tmpdir || os2.tmpdir(), cb);
+      return fs5.realpath(options && options.tmpdir || os3.tmpdir(), cb);
     }
     function _getTmpDirSync(options) {
-      return fs5.realpathSync(options && options.tmpdir || os2.tmpdir());
+      return fs5.realpathSync(options && options.tmpdir || os3.tmpdir());
     }
     process.addListener(EXIT, _garbageCollector);
     Object.defineProperty(module2.exports, "tmpdir", {
@@ -43448,9 +44444,9 @@ var require_package2 = __commonJS({
   "node_modules/create-nx-workspace/package.json"(exports2, module2) {
     module2.exports = {
       name: "create-nx-workspace",
-      version: "22.2.0",
+      version: "22.5.2",
       private: false,
-      description: "Smart Repos \xB7 Fast Builds",
+      description: "Smart Monorepos \xB7 Fast Builds",
       repository: {
         type: "git",
         url: "https://github.com/nrwl/nx.git",
@@ -43519,7 +44515,6 @@ var require_create_sandbox = __commonJS({
     var path_1 = require("path");
     var package_manager_1 = require_package_manager();
     var child_process_utils_1 = require_child_process_utils();
-    var output_1 = require_output();
     var nx_version_1 = require_nx_version();
     var error_utils_1 = require_error_utils();
     async function createSandbox(packageManager) {
@@ -43542,15 +44537,8 @@ var require_create_sandbox = __commonJS({
         installSpinner.succeed();
       } catch (e) {
         installSpinner.fail();
-        if (e instanceof Error) {
-          output_1.output.error({
-            title: `Failed to install dependencies`,
-            bodyLines: (0, error_utils_1.mapErrorToBodyLines)(e)
-          });
-        } else {
-          console.error(e);
-        }
-        process.exit(1);
+        const message2 = e instanceof Error ? e.message : String(e);
+        throw new error_utils_1.CnwError("SANDBOX_FAILED", `Failed to install dependencies: ${message2}`);
       } finally {
         installSpinner.stop();
       }
@@ -43568,7 +44556,6 @@ var require_setup_ci = __commonJS({
     var ora = require_ora();
     var child_process_utils_1 = require_child_process_utils();
     var error_utils_1 = require_error_utils();
-    var output_1 = require_output();
     var package_manager_1 = require_package_manager();
     async function setupCI(directory, ci, packageManager) {
       const ciSpinner = ora(`Generating CI workflow`).start();
@@ -43579,15 +44566,8 @@ var require_setup_ci = __commonJS({
         return res;
       } catch (e) {
         ciSpinner.fail();
-        if (e instanceof Error) {
-          output_1.output.error({
-            title: `Failed to generate CI workflow`,
-            bodyLines: (0, error_utils_1.mapErrorToBodyLines)(e)
-          });
-        } else {
-          console.error(e);
-        }
-        process.exit(1);
+        const message2 = e instanceof Error ? e.message : String(e);
+        throw new error_utils_1.CnwError("CI_WORKFLOW_FAILED", `Failed to generate CI workflow: ${message2}`);
       } finally {
         ciSpinner.stop();
       }
@@ -43613,6 +44593,172 @@ var require_default_base = __commonJS({
   }
 });
 
+// node_modules/create-nx-workspace/src/utils/ci/is-ci.js
+var require_is_ci = __commonJS({
+  "node_modules/create-nx-workspace/src/utils/ci/is-ci.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isCI = isCI2;
+    function isCI2() {
+      return process.env.CI && process.env.CI !== "false" || process.env.TF_BUILD === "true" || process.env.GITHUB_ACTIONS === "true" || process.env.BUILDKITE === "true" || process.env.CIRCLECI === "true" || process.env.CIRRUS_CI === "true" || process.env.TRAVIS === "true" || !!process.env["bamboo.buildKey"] || !!process.env.CODEBUILD_BUILD_ID || !!process.env.GITLAB_CI || !!process.env.HEROKU_TEST_RUN_ID || !!process.env.BUILD_ID || !!process.env.BUILD_BUILDID || !!process.env.TEAMCITY_VERSION;
+    }
+  }
+});
+
+// node_modules/create-nx-workspace/src/utils/output.js
+var require_output = __commonJS({
+  "node_modules/create-nx-workspace/src/utils/output.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.output = exports2.CLIOutput = void 0;
+    var chalk = require_source();
+    var os_1 = require("os");
+    var is_ci_1 = require_is_ci();
+    if ((0, is_ci_1.isCI)()) {
+      chalk.level = 0;
+    }
+    var CLIOutput = class {
+      constructor(real = true) {
+        this.real = real;
+        this.outstream = this.real ? process.stdout : new FakeStdout();
+        this.colors = {
+          gray: chalk.gray,
+          green: chalk.green,
+          red: chalk.red,
+          cyan: chalk.cyan,
+          white: chalk.white
+        };
+        this.bold = chalk.bold;
+        this.underline = chalk.underline;
+        this.dim = chalk.dim;
+        this.cliName = "NX";
+      }
+      /**
+       * Longer dash character which forms more of a continuous line when place side to side
+       * with itself, unlike the standard dash character
+       */
+      get VERTICAL_SEPARATOR() {
+        let divider = "";
+        for (let i = 0; i < process.stdout.columns - 1; i++) {
+          divider += "\u2014";
+        }
+        return divider;
+      }
+      writeToStdOut(str) {
+        this.outstream.write(str);
+      }
+      writeOutputTitle({ color: color2, title }) {
+        this.writeToStdOut(`${this.applyCLIPrefix(color2, title)}${os_1.EOL}`);
+      }
+      writeOptionalOutputBody(bodyLines) {
+        if (!bodyLines) {
+          return;
+        }
+        this.addNewline();
+        bodyLines.forEach((bodyLine) => this.writeToStdOut(`${bodyLine}${os_1.EOL}`));
+      }
+      setCliName(name) {
+        this.cliName = name;
+      }
+      applyCLIPrefix(color2 = "cyan", text) {
+        let cliPrefix = "";
+        if (chalk[color2]) {
+          cliPrefix = chalk.reset.inverse.bold[color2](` ${this.cliName} `);
+        } else {
+          cliPrefix = chalk.reset.inverse.bold.keyword(color2)(` ${this.cliName} `);
+        }
+        return `${cliPrefix}  ${text}`;
+      }
+      addNewline() {
+        this.writeToStdOut(os_1.EOL);
+      }
+      /**
+       * Write lines directly without CLI prefix/badge.
+       * Used for banner output when no title is needed.
+       */
+      writeLines(lines) {
+        lines.forEach((line) => this.writeToStdOut(`${line}${os_1.EOL}`));
+      }
+      addVerticalSeparator(color2 = "gray") {
+        this.addNewline();
+        this.addVerticalSeparatorWithoutNewLines(color2);
+        this.addNewline();
+      }
+      addVerticalSeparatorWithoutNewLines(color2 = "gray") {
+        this.writeToStdOut(`${chalk.dim[color2](this.VERTICAL_SEPARATOR)}${os_1.EOL}`);
+      }
+      error({ title, bodyLines }) {
+        this.addNewline();
+        this.writeOutputTitle({
+          color: "red",
+          title: chalk.red(title)
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        this.addNewline();
+      }
+      warn({ title, bodyLines }) {
+        this.addNewline();
+        this.writeOutputTitle({
+          color: "yellow",
+          title: chalk.yellow(title)
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        this.addNewline();
+      }
+      note({ title, bodyLines }) {
+        this.addNewline();
+        this.writeOutputTitle({
+          color: "orange",
+          title: chalk.keyword("orange")(title)
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        this.addNewline();
+      }
+      success({ title, bodyLines }) {
+        this.addNewline();
+        this.writeOutputTitle({
+          color: "green",
+          title: chalk.green(title)
+        });
+        this.writeOptionalOutputBody(bodyLines);
+      }
+      logSingleLine(message2) {
+        this.addNewline();
+        this.writeOutputTitle({
+          color: "gray",
+          title: message2
+        });
+        this.addNewline();
+      }
+      log({ title, bodyLines, color: color2 }) {
+        this.addNewline();
+        this.writeOutputTitle({
+          color: "cyan",
+          title: color2 ? chalk[color2](title) : title
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        this.addNewline();
+      }
+      getOutput() {
+        return this.outstream.toString();
+      }
+    };
+    exports2.CLIOutput = CLIOutput;
+    exports2.output = new CLIOutput();
+    var FakeStdout = class {
+      constructor() {
+        this.content = "";
+      }
+      write(str) {
+        this.content += str;
+      }
+      toString() {
+        return this.content;
+      }
+    };
+  }
+});
+
 // node_modules/ansi-colors/symbols.js
 var require_symbols = __commonJS({
   "node_modules/ansi-colors/symbols.js"(exports2, module2) {
@@ -44232,7 +45378,7 @@ var require_keypress = __commonJS({
       /* misc. */
       "[Z": "tab"
     };
-    function isShiftKey(code) {
+    function isShiftKey2(code) {
       return ["[a", "[b", "[c", "[d", "[e", "[2$", "[3$", "[5$", "[6$", "[7$", "[8$", "[Z"].includes(code);
     }
     function isCtrlKey(code) {
@@ -44304,7 +45450,7 @@ var require_keypress = __commonJS({
         key.shift = !!(modifier & 1);
         key.code = code;
         key.name = keyName[code];
-        key.shift = isShiftKey(code) || key.shift;
+        key.shift = isShiftKey2(code) || key.shift;
         key.ctrl = isCtrlKey(code) || key.ctrl;
       }
       return key;
@@ -48064,8 +49210,11 @@ var require_git = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.GitHubPushSkippedError = exports2.VcsPushStatus = void 0;
     exports2.checkGitVersion = checkGitVersion;
+    exports2.isGitAvailable = isGitAvailable;
+    exports2.isGhCliAvailable = isGhCliAvailable;
     exports2.initializeGitRepo = initializeGitRepo;
     exports2.pushToGitHub = pushToGitHub;
+    var child_process_1 = require("child_process");
     var default_base_1 = require_default_base();
     var output_1 = require_output();
     var child_process_utils_1 = require_child_process_utils();
@@ -48094,6 +49243,22 @@ var require_git = __commonJS({
         return null;
       }
     }
+    function isGitAvailable() {
+      try {
+        (0, child_process_1.execSync)("git --version", { stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    function isGhCliAvailable() {
+      try {
+        (0, child_process_1.execSync)("gh --version", { stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    }
     async function getGitHubUsername(directory) {
       const result = await (0, child_process_utils_1.execAndWait)("gh api user --jq .login", directory);
       const username = result.stdout.trim();
@@ -48231,18 +49396,8 @@ ${options.connectUrl}
         });
         return VcsPushStatus.PushedToVcs;
       } catch (e) {
-        const isVerbose = options.verbose || process.env.NX_VERBOSE_LOGGING === "true";
-        const errorMessage = e instanceof Error ? e.message : String(e);
-        const title = e instanceof GitHubPushSkippedError || e?.code === 127 ? "Push your workspace to GitHub." : "Could not push. Push repo to complete setup.";
-        const createRepoUrl = `https://github.com/new?name=${encodeURIComponent(options.name)}`;
-        output_1.output.log({
-          title,
-          bodyLines: isVerbose ? [
-            `Go to ${createRepoUrl} and push this workspace.`,
-            "Error details:",
-            errorMessage
-          ] : [`Go to ${createRepoUrl} and push this workspace.`]
-        });
+        const title = e instanceof GitHubPushSkippedError || e?.code === 127 ? "Push your workspace to GitHub." : "Could not push.";
+        output_1.output.log({ title });
         return VcsPushStatus.FailedToPushToVcs;
       }
     }
@@ -48257,13 +49412,34 @@ var require_messages = __commonJS({
     exports2.getCompletionMessage = getCompletionMessage;
     exports2.getSkippedCloudMessage = getSkippedCloudMessage;
     var git_1 = require_git();
-    function getSetupMessage(url2, pushedToVcs) {
+    function generateSimpleBanner(url2) {
+      const content = `Finish your set up here: ${url2}`;
+      const innerWidth = content.length + 6;
+      const horizontalBorder = "+" + "-".repeat(innerWidth) + "+";
+      const emptyLine = "|" + " ".repeat(innerWidth) + "|";
+      const contentLine = "|   " + content + "   |";
+      return [
+        horizontalBorder,
+        emptyLine,
+        contentLine,
+        emptyLine,
+        horizontalBorder
+      ];
+    }
+    function getBannerLines(variant, url2) {
+      if (variant === "2") {
+        return generateSimpleBanner(url2);
+      }
+      return [];
+    }
+    function getSetupMessage(url2, pushedToVcs, workspaceName) {
+      const githubUrl = workspaceName ? `https://github.com/new?name=${encodeURIComponent(workspaceName)}` : "https://github.com/new";
       if (pushedToVcs === git_1.VcsPushStatus.PushedToVcs) {
         return url2 ? `Go to Nx Cloud and finish the setup: ${url2}` : "Return to Nx Cloud and finish the setup.";
       }
       const action = url2 ? "go" : "return";
       const urlSuffix = url2 ? `: ${url2}` : ".";
-      return `Push your repo, then ${action} to Nx Cloud and finish the setup${urlSuffix}`;
+      return `Push your repo (${githubUrl}), then ${action} to Nx Cloud and finish the setup${urlSuffix}`;
     }
     var completionMessages = {
       "ci-setup": {
@@ -48276,11 +49452,24 @@ var require_messages = __commonJS({
         title: "Your platform setup is almost complete."
       }
     };
-    function getCompletionMessage(completionMessageKey, url2, pushedToVcs) {
+    function getCompletionMessage(completionMessageKey, url2, pushedToVcs, workspaceName, bannerVariant) {
       const key = completionMessageKey ?? "ci-setup";
+      const messageConfig = completionMessages[key];
+      const variant = bannerVariant ?? "0";
+      const title = variant === "2" ? "" : messageConfig.title;
+      if (variant !== "0" && url2) {
+        const bannerLines = getBannerLines(variant, url2);
+        if (bannerLines.length > 0) {
+          return {
+            title,
+            bodyLines: [...bannerLines, ""]
+          };
+        }
+      }
+      const bodyLines = [getSetupMessage(url2, pushedToVcs, workspaceName)];
       return {
-        title: completionMessages[key].title,
-        bodyLines: [getSetupMessage(url2, pushedToVcs)]
+        title,
+        bodyLines
       };
     }
     function getSkippedCloudMessage() {
@@ -48368,8 +49557,8 @@ var require_axios = __commonJS({
       if (kindOf2(val) !== "object") {
         return false;
       }
-      const prototype4 = getPrototypeOf2(val);
-      return (prototype4 === null || prototype4 === Object.prototype || Object.getPrototypeOf(prototype4) === null) && !(toStringTag2 in val) && !(iterator2 in val);
+      const prototype3 = getPrototypeOf2(val);
+      return (prototype3 === null || prototype3 === Object.prototype || Object.getPrototypeOf(prototype3) === null) && !(toStringTag2 in val) && !(iterator2 in val);
     };
     var isEmptyObject2 = (val) => {
       if (!isObject2(val) || isBuffer2(val)) {
@@ -48392,7 +49581,12 @@ var require_axios = __commonJS({
       kind === "object" && isFunction$1(thing.toString) && thing.toString() === "[object FormData]"));
     };
     var isURLSearchParams2 = kindOfTest2("URLSearchParams");
-    var [isReadableStream2, isRequest2, isResponse2, isHeaders2] = ["ReadableStream", "Request", "Response", "Headers"].map(kindOfTest2);
+    var [isReadableStream2, isRequest2, isResponse2, isHeaders2] = [
+      "ReadableStream",
+      "Request",
+      "Response",
+      "Headers"
+    ].map(kindOfTest2);
     var trim3 = (str) => str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
     function forEach2(obj, fn, { allOwnKeys = false } = {}) {
       if (obj === null || typeof obj === "undefined") {
@@ -48445,6 +49639,9 @@ var require_axios = __commonJS({
       const { caseless, skipUndefined } = isContextDefined2(this) && this || {};
       const result = {};
       const assignValue = (val, key) => {
+        if (key === "__proto__" || key === "constructor" || key === "prototype") {
+          return;
+        }
         const targetKey = caseless && findKey3(result, key) || key;
         if (isPlainObject3(result[targetKey]) && isPlainObject3(val)) {
           result[targetKey] = merge3(result[targetKey], val);
@@ -48462,13 +49659,27 @@ var require_axios = __commonJS({
       return result;
     }
     var extend2 = (a, b, thisArg, { allOwnKeys } = {}) => {
-      forEach2(b, (val, key) => {
-        if (thisArg && isFunction$1(val)) {
-          a[key] = bind2(val, thisArg);
-        } else {
-          a[key] = val;
-        }
-      }, { allOwnKeys });
+      forEach2(
+        b,
+        (val, key) => {
+          if (thisArg && isFunction$1(val)) {
+            Object.defineProperty(a, key, {
+              value: bind2(val, thisArg),
+              writable: true,
+              enumerable: true,
+              configurable: true
+            });
+          } else {
+            Object.defineProperty(a, key, {
+              value: val,
+              writable: true,
+              enumerable: true,
+              configurable: true
+            });
+          }
+        },
+        { allOwnKeys }
+      );
       return a;
     };
     var stripBOM2 = (content) => {
@@ -48477,9 +49688,17 @@ var require_axios = __commonJS({
       }
       return content;
     };
-    var inherits2 = (constructor, superConstructor, props, descriptors3) => {
-      constructor.prototype = Object.create(superConstructor.prototype, descriptors3);
-      constructor.prototype.constructor = constructor;
+    var inherits2 = (constructor, superConstructor, props, descriptors) => {
+      constructor.prototype = Object.create(
+        superConstructor.prototype,
+        descriptors
+      );
+      Object.defineProperty(constructor.prototype, "constructor", {
+        value: constructor,
+        writable: true,
+        enumerable: false,
+        configurable: true
+      });
       Object.defineProperty(constructor, "super", {
         value: superConstructor.prototype
       });
@@ -48550,19 +49769,16 @@ var require_axios = __commonJS({
     };
     var isHTMLForm2 = kindOfTest2("HTMLFormElement");
     var toCamelCase2 = (str) => {
-      return str.toLowerCase().replace(
-        /[-_\s]([a-z\d])(\w*)/g,
-        function replacer(m, p1, p2) {
-          return p1.toUpperCase() + p2;
-        }
-      );
+      return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g, function replacer(m, p1, p2) {
+        return p1.toUpperCase() + p2;
+      });
     };
     var hasOwnProperty2 = (({ hasOwnProperty: hasOwnProperty3 }) => (obj, prop) => hasOwnProperty3.call(obj, prop))(Object.prototype);
     var isRegExp2 = kindOfTest2("RegExp");
     var reduceDescriptors2 = (obj, reducer) => {
-      const descriptors3 = Object.getOwnPropertyDescriptors(obj);
+      const descriptors = Object.getOwnPropertyDescriptors(obj);
       const reducedDescriptors = {};
-      forEach2(descriptors3, (descriptor, name) => {
+      forEach2(descriptors, (descriptor, name) => {
         let ret;
         if ((ret = reducer(descriptor, name, obj)) !== false) {
           reducedDescriptors[name] = ret || descriptor;
@@ -48639,20 +49855,21 @@ var require_axios = __commonJS({
         return setImmediate;
       }
       return postMessageSupported ? ((token, callbacks) => {
-        _global2.addEventListener("message", ({ source, data }) => {
-          if (source === _global2 && data === token) {
-            callbacks.length && callbacks.shift()();
-          }
-        }, false);
+        _global2.addEventListener(
+          "message",
+          ({ source, data }) => {
+            if (source === _global2 && data === token) {
+              callbacks.length && callbacks.shift()();
+            }
+          },
+          false
+        );
         return (cb) => {
           callbacks.push(cb);
           _global2.postMessage(token, "*");
         };
       })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
-    })(
-      typeof setImmediate === "function",
-      isFunction$1(_global2.postMessage)
-    );
+    })(typeof setImmediate === "function", isFunction$1(_global2.postMessage));
     var asap2 = typeof queueMicrotask !== "undefined" ? queueMicrotask.bind(_global2) : typeof process !== "undefined" && process.nextTick || _setImmediate2;
     var isIterable2 = (thing) => thing != null && isFunction$1(thing[iterator2]);
     var utils$1 = {
@@ -48715,25 +49932,38 @@ var require_axios = __commonJS({
       asap: asap2,
       isIterable: isIterable2
     };
-    function AxiosError3(message2, code, config, request, response) {
-      Error.call(this);
-      if (Error.captureStackTrace) {
-        Error.captureStackTrace(this, this.constructor);
-      } else {
-        this.stack = new Error().stack;
+    var AxiosError3 = class _AxiosError extends Error {
+      static from(error, code, config, request, response, customProps) {
+        const axiosError = new _AxiosError(error.message, code || error.code, config, request, response);
+        axiosError.cause = error;
+        axiosError.name = error.name;
+        customProps && Object.assign(axiosError, customProps);
+        return axiosError;
       }
-      this.message = message2;
-      this.name = "AxiosError";
-      code && (this.code = code);
-      config && (this.config = config);
-      request && (this.request = request);
-      if (response) {
-        this.response = response;
-        this.status = response.status ? response.status : null;
+      /**
+       * Create an Error with the specified message, config, error code, request and response.
+       *
+       * @param {string} message The error message.
+       * @param {string} [code] The error code (for example, 'ECONNABORTED').
+       * @param {Object} [config] The config.
+       * @param {Object} [request] The request.
+       * @param {Object} [response] The response.
+       *
+       * @returns {Error} The created error.
+       */
+      constructor(message2, code, config, request, response) {
+        super(message2);
+        this.name = "AxiosError";
+        this.isAxiosError = true;
+        code && (this.code = code);
+        config && (this.config = config);
+        request && (this.request = request);
+        if (response) {
+          this.response = response;
+          this.status = response.status;
+        }
       }
-    }
-    utils$1.inherits(AxiosError3, Error, {
-      toJSON: function toJSON2() {
+      toJSON() {
         return {
           // Standard
           message: this.message,
@@ -48752,45 +49982,20 @@ var require_axios = __commonJS({
           status: this.status
         };
       }
-    });
-    var prototype$1 = AxiosError3.prototype;
-    var descriptors2 = {};
-    [
-      "ERR_BAD_OPTION_VALUE",
-      "ERR_BAD_OPTION",
-      "ECONNABORTED",
-      "ETIMEDOUT",
-      "ERR_NETWORK",
-      "ERR_FR_TOO_MANY_REDIRECTS",
-      "ERR_DEPRECATED",
-      "ERR_BAD_RESPONSE",
-      "ERR_BAD_REQUEST",
-      "ERR_CANCELED",
-      "ERR_NOT_SUPPORT",
-      "ERR_INVALID_URL"
-      // eslint-disable-next-line func-names
-    ].forEach((code) => {
-      descriptors2[code] = { value: code };
-    });
-    Object.defineProperties(AxiosError3, descriptors2);
-    Object.defineProperty(prototype$1, "isAxiosError", { value: true });
-    AxiosError3.from = (error, code, config, request, response, customProps) => {
-      const axiosError = Object.create(prototype$1);
-      utils$1.toFlatObject(error, axiosError, function filter3(obj) {
-        return obj !== Error.prototype;
-      }, (prop) => {
-        return prop !== "isAxiosError";
-      });
-      const msg = error && error.message ? error.message : "Error";
-      const errCode = code == null && error ? error.code : code;
-      AxiosError3.call(axiosError, msg, errCode, config, request, response);
-      if (error && axiosError.cause == null) {
-        Object.defineProperty(axiosError, "cause", { value: error, configurable: true });
-      }
-      axiosError.name = error && error.name || "Error";
-      customProps && Object.assign(axiosError, customProps);
-      return axiosError;
     };
+    AxiosError3.ERR_BAD_OPTION_VALUE = "ERR_BAD_OPTION_VALUE";
+    AxiosError3.ERR_BAD_OPTION = "ERR_BAD_OPTION";
+    AxiosError3.ECONNABORTED = "ECONNABORTED";
+    AxiosError3.ETIMEDOUT = "ETIMEDOUT";
+    AxiosError3.ERR_NETWORK = "ERR_NETWORK";
+    AxiosError3.ERR_FR_TOO_MANY_REDIRECTS = "ERR_FR_TOO_MANY_REDIRECTS";
+    AxiosError3.ERR_DEPRECATED = "ERR_DEPRECATED";
+    AxiosError3.ERR_BAD_RESPONSE = "ERR_BAD_RESPONSE";
+    AxiosError3.ERR_BAD_REQUEST = "ERR_BAD_REQUEST";
+    AxiosError3.ERR_CANCELED = "ERR_CANCELED";
+    AxiosError3.ERR_NOT_SUPPORT = "ERR_NOT_SUPPORT";
+    AxiosError3.ERR_INVALID_URL = "ERR_INVALID_URL";
+    var AxiosError$1 = AxiosError3;
     function isVisitable2(thing) {
       return utils$1.isPlainObject(thing) || utils$1.isArray(thing);
     }
@@ -48840,7 +50045,7 @@ var require_axios = __commonJS({
           return value.toString();
         }
         if (!useBlob && utils$1.isBlob(value)) {
-          throw new AxiosError3("Blob is not supported. Use a Buffer instead.");
+          throw new AxiosError$1("Blob is not supported. Use a Buffer instead.");
         }
         if (utils$1.isArrayBuffer(value) || utils$1.isTypedArray(value)) {
           return useBlob && typeof Blob === "function" ? new Blob([value]) : Buffer.from(value);
@@ -48921,11 +50126,11 @@ var require_axios = __commonJS({
       this._pairs = [];
       params && toFormData3(params, this, options);
     }
-    var prototype3 = AxiosURLSearchParams2.prototype;
-    prototype3.append = function append2(name, value) {
+    var prototype2 = AxiosURLSearchParams2.prototype;
+    prototype2.append = function append2(name, value) {
       this._pairs.push([name, value]);
     };
-    prototype3.toString = function toString4(encoder) {
+    prototype2.toString = function toString4(encoder) {
       const _encode = encoder ? function(value) {
         return encoder.call(this, value, encode$1);
       } : encode$1;
@@ -48941,17 +50146,15 @@ var require_axios = __commonJS({
         return url3;
       }
       const _encode = options && options.encode || encode3;
-      if (utils$1.isFunction(options)) {
-        options = {
-          serialize: options
-        };
-      }
-      const serializeFn = options && options.serialize;
+      const _options = utils$1.isFunction(options) ? {
+        serialize: options
+      } : options;
+      const serializeFn = _options && _options.serialize;
       let serializedParams;
       if (serializeFn) {
-        serializedParams = serializeFn(params, options);
+        serializedParams = serializeFn(params, _options);
       } else {
-        serializedParams = utils$1.isURLSearchParams(params) ? params.toString() : new AxiosURLSearchParams2(params, options).toString(_encode);
+        serializedParams = utils$1.isURLSearchParams(params) ? params.toString() : new AxiosURLSearchParams2(params, _options).toString(_encode);
       }
       if (serializedParams) {
         const hashmarkIndex = url3.indexOf("#");
@@ -48971,6 +50174,7 @@ var require_axios = __commonJS({
        *
        * @param {Function} fulfilled The function to handle `then` for a `Promise`
        * @param {Function} rejected The function to handle `reject` for a `Promise`
+       * @param {Object} options The options for the interceptor, synchronous and runWhen
        *
        * @return {Number} An ID used to remove interceptor later
        */
@@ -49027,7 +50231,8 @@ var require_axios = __commonJS({
     var transitionalDefaults = {
       silentJSONParsing: true,
       forcedJSONParsing: true,
-      clarifyTimeoutError: false
+      clarifyTimeoutError: false,
+      legacyInterceptorReqResOrdering: true
     };
     var URLSearchParams = url__default["default"].URLSearchParams;
     var ALPHA2 = "abcdefghijklmnopqrstuvwxyz";
@@ -49212,7 +50417,7 @@ var require_axios = __commonJS({
           } catch (e) {
             if (strictJSONParsing) {
               if (e.name === "SyntaxError") {
-                throw AxiosError3.from(e, AxiosError3.ERR_BAD_RESPONSE, this, null, this.response);
+                throw AxiosError$1.from(e, AxiosError$1.ERR_BAD_RESPONSE, this, null, this.response);
               }
               throw e;
             }
@@ -49493,11 +50698,11 @@ var require_axios = __commonJS({
           accessors: {}
         };
         const accessors = internals.accessors;
-        const prototype4 = this.prototype;
+        const prototype3 = this.prototype;
         function defineAccessor(_header) {
           const lHeader = normalizeHeader2(_header);
           if (!accessors[lHeader]) {
-            buildAccessors2(prototype4, _header);
+            buildAccessors2(prototype3, _header);
             accessors[lHeader] = true;
           }
         }
@@ -49531,21 +50736,31 @@ var require_axios = __commonJS({
     function isCancel3(value) {
       return !!(value && value.__CANCEL__);
     }
-    function CanceledError3(message2, config, request) {
-      AxiosError3.call(this, message2 == null ? "canceled" : message2, AxiosError3.ERR_CANCELED, config, request);
-      this.name = "CanceledError";
-    }
-    utils$1.inherits(CanceledError3, AxiosError3, {
-      __CANCEL__: true
-    });
+    var CanceledError3 = class extends AxiosError$1 {
+      /**
+       * A `CanceledError` is an object that is thrown when an operation is canceled.
+       *
+       * @param {string=} message The message.
+       * @param {Object=} config The config.
+       * @param {Object=} request The request.
+       *
+       * @returns {CanceledError} The created error.
+       */
+      constructor(message2, config, request) {
+        super(message2 == null ? "canceled" : message2, AxiosError$1.ERR_CANCELED, config, request);
+        this.name = "CanceledError";
+        this.__CANCEL__ = true;
+      }
+    };
+    var CanceledError$1 = CanceledError3;
     function settle2(resolve2, reject, response) {
       const validateStatus2 = response.config.validateStatus;
       if (!response.status || !validateStatus2 || validateStatus2(response.status)) {
         resolve2(response);
       } else {
-        reject(new AxiosError3(
+        reject(new AxiosError$1(
           "Request failed with status code " + response.status,
-          [AxiosError3.ERR_BAD_REQUEST, AxiosError3.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
+          [AxiosError$1.ERR_BAD_REQUEST, AxiosError$1.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
           response.config,
           response.request,
           response
@@ -49553,6 +50768,9 @@ var require_axios = __commonJS({
       }
     }
     function isAbsoluteURL2(url3) {
+      if (typeof url3 !== "string") {
+        return false;
+      }
       return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url3);
     }
     function combineURLs2(baseURL, relativeURL) {
@@ -49565,7 +50783,7 @@ var require_axios = __commonJS({
       }
       return requestedURL;
     }
-    var VERSION3 = "1.13.2";
+    var VERSION3 = "1.13.5";
     function parseProtocol2(url3) {
       const match2 = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url3);
       return match2 && match2[1] || "";
@@ -49581,7 +50799,7 @@ var require_axios = __commonJS({
         uri = protocol.length ? uri.slice(protocol.length + 1) : uri;
         const match2 = DATA_URL_PATTERN2.exec(uri);
         if (!match2) {
-          throw new AxiosError3("Invalid URL", AxiosError3.ERR_INVALID_URL);
+          throw new AxiosError$1("Invalid URL", AxiosError$1.ERR_INVALID_URL);
         }
         const mime = match2[1];
         const isBase64 = match2[2];
@@ -49589,13 +50807,13 @@ var require_axios = __commonJS({
         const buffer = Buffer.from(decodeURIComponent(body), isBase64 ? "base64" : "utf8");
         if (asBlob) {
           if (!_Blob) {
-            throw new AxiosError3("Blob is not supported", AxiosError3.ERR_NOT_SUPPORT);
+            throw new AxiosError$1("Blob is not supported", AxiosError$1.ERR_NOT_SUPPORT);
           }
           return new _Blob([buffer], { type: mime });
         }
         return buffer;
       }
-      throw new AxiosError3("Unsupported protocol " + protocol, AxiosError3.ERR_NOT_SUPPORT);
+      throw new AxiosError$1("Unsupported protocol " + protocol, AxiosError$1.ERR_NOT_SUPPORT);
     }
     var kInternals2 = Symbol("internals");
     var AxiosTransformStream2 = class extends stream__default["default"].Transform {
@@ -50087,8 +51305,11 @@ var require_axios = __commonJS({
           proxy2.auth = (proxy2.username || "") + ":" + (proxy2.password || "");
         }
         if (proxy2.auth) {
-          if (proxy2.auth.username || proxy2.auth.password) {
+          const validProxyAuth = Boolean(proxy2.auth.username || proxy2.auth.password);
+          if (validProxyAuth) {
             proxy2.auth = (proxy2.auth.username || "") + ":" + (proxy2.auth.password || "");
+          } else if (typeof proxy2.auth === "object") {
+            throw new AxiosError$1("Invalid proxy authorization", AxiosError$1.ERR_BAD_OPTION, { proxy: proxy2 });
           }
           const base64 = Buffer.from(proxy2.auth, "utf8").toString("base64");
           options.headers["Proxy-Authorization"] = "Basic " + base64;
@@ -50140,7 +51361,7 @@ var require_axios = __commonJS({
     var buildAddressEntry2 = (address, family) => resolveFamily2(utils$1.isObject(address) ? address : { address, family });
     var http2Transport2 = {
       request(options, cb) {
-        const authority = options.protocol + "//" + options.hostname + ":" + (options.port || 80);
+        const authority = options.protocol + "//" + options.hostname + ":" + (options.port || (options.protocol === "https:" ? 443 : 80));
         const { http2Options, headers } = options;
         const session = http2Sessions2.getSession(authority, http2Options);
         const {
@@ -50201,7 +51422,7 @@ var require_axios = __commonJS({
         const abortEmitter = new events.EventEmitter();
         function abort(reason) {
           try {
-            abortEmitter.emit("abort", !reason || reason.type ? new CanceledError3(null, config, req) : reason);
+            abortEmitter.emit("abort", !reason || reason.type ? new CanceledError$1(null, config, req) : reason);
           } catch (err) {
             console.warn("emit error", err);
           }
@@ -50247,9 +51468,9 @@ var require_axios = __commonJS({
             const dataUrl = String(config.url || fullPath || "");
             const estimated = estimateDataURLDecodedBytes2(dataUrl);
             if (estimated > config.maxContentLength) {
-              return reject(new AxiosError3(
+              return reject(new AxiosError$1(
                 "maxContentLength size of " + config.maxContentLength + " exceeded",
-                AxiosError3.ERR_BAD_RESPONSE,
+                AxiosError$1.ERR_BAD_RESPONSE,
                 config
               ));
             }
@@ -50268,7 +51489,7 @@ var require_axios = __commonJS({
               Blob: config.env && config.env.Blob
             });
           } catch (err) {
-            throw AxiosError3.from(err, AxiosError3.ERR_BAD_REQUEST, config);
+            throw AxiosError$1.from(err, AxiosError$1.ERR_BAD_REQUEST, config);
           }
           if (responseType === "text") {
             convertedData = convertedData.toString(responseEncoding);
@@ -50287,9 +51508,9 @@ var require_axios = __commonJS({
           });
         }
         if (supportedProtocols2.indexOf(protocol) === -1) {
-          return reject(new AxiosError3(
+          return reject(new AxiosError$1(
             "Unsupported protocol " + protocol,
-            AxiosError3.ERR_BAD_REQUEST,
+            AxiosError$1.ERR_BAD_REQUEST,
             config
           ));
         }
@@ -50327,17 +51548,17 @@ var require_axios = __commonJS({
           } else if (utils$1.isString(data)) {
             data = Buffer.from(data, "utf-8");
           } else {
-            return reject(new AxiosError3(
+            return reject(new AxiosError$1(
               "Data after transformation must be a string, an ArrayBuffer, a Buffer, or a Stream",
-              AxiosError3.ERR_BAD_REQUEST,
+              AxiosError$1.ERR_BAD_REQUEST,
               config
             ));
           }
           headers.setContentLength(data.length, false);
           if (config.maxBodyLength > -1 && data.length > config.maxBodyLength) {
-            return reject(new AxiosError3(
+            return reject(new AxiosError$1(
               "Request body larger than maxBodyLength limit",
-              AxiosError3.ERR_BAD_REQUEST,
+              AxiosError$1.ERR_BAD_REQUEST,
               config
             ));
           }
@@ -50507,9 +51728,9 @@ var require_axios = __commonJS({
               if (config.maxContentLength > -1 && totalResponseBytes > config.maxContentLength) {
                 rejected = true;
                 responseStream.destroy();
-                abort(new AxiosError3(
+                abort(new AxiosError$1(
                   "maxContentLength size of " + config.maxContentLength + " exceeded",
-                  AxiosError3.ERR_BAD_RESPONSE,
+                  AxiosError$1.ERR_BAD_RESPONSE,
                   config,
                   lastRequest
                 ));
@@ -50519,9 +51740,9 @@ var require_axios = __commonJS({
               if (rejected) {
                 return;
               }
-              const err = new AxiosError3(
+              const err = new AxiosError$1(
                 "stream has been aborted",
-                AxiosError3.ERR_BAD_RESPONSE,
+                AxiosError$1.ERR_BAD_RESPONSE,
                 config,
                 lastRequest
               );
@@ -50530,7 +51751,7 @@ var require_axios = __commonJS({
             });
             responseStream.on("error", function handleStreamError(err) {
               if (req.destroyed) return;
-              reject(AxiosError3.from(err, null, config, lastRequest));
+              reject(AxiosError$1.from(err, null, config, lastRequest));
             });
             responseStream.on("end", function handleStreamEnd() {
               try {
@@ -50543,7 +51764,7 @@ var require_axios = __commonJS({
                 }
                 response.data = responseData;
               } catch (err) {
-                return reject(AxiosError3.from(err, null, config, response.request, response));
+                return reject(AxiosError$1.from(err, null, config, response.request, response));
               }
               settle2(resolve2, reject, response);
             });
@@ -50563,7 +51784,7 @@ var require_axios = __commonJS({
           }
         });
         req.on("error", function handleRequestError(err) {
-          reject(AxiosError3.from(err, null, config, req));
+          reject(AxiosError$1.from(err, null, config, req));
         });
         req.on("socket", function handleRequestSocket(socket) {
           socket.setKeepAlive(true, 1e3 * 60);
@@ -50571,9 +51792,9 @@ var require_axios = __commonJS({
         if (config.timeout) {
           const timeout = parseInt(config.timeout, 10);
           if (Number.isNaN(timeout)) {
-            abort(new AxiosError3(
+            abort(new AxiosError$1(
               "error trying to parse `config.timeout` to int",
-              AxiosError3.ERR_BAD_OPTION_VALUE,
+              AxiosError$1.ERR_BAD_OPTION_VALUE,
               config,
               req
             ));
@@ -50586,9 +51807,9 @@ var require_axios = __commonJS({
             if (config.timeoutErrorMessage) {
               timeoutErrorMessage = config.timeoutErrorMessage;
             }
-            abort(new AxiosError3(
+            abort(new AxiosError$1(
               timeoutErrorMessage,
-              transitional2.clarifyTimeoutError ? AxiosError3.ETIMEDOUT : AxiosError3.ECONNABORTED,
+              transitional2.clarifyTimeoutError ? AxiosError$1.ETIMEDOUT : AxiosError$1.ECONNABORTED,
               config,
               req
             ));
@@ -50608,7 +51829,7 @@ var require_axios = __commonJS({
           });
           data.on("close", () => {
             if (!ended && !errored) {
-              abort(new CanceledError3("Request stream has been aborted", config, req));
+              abort(new CanceledError$1("Request stream has been aborted", config, req));
             }
           });
           data.pipe(req);
@@ -50740,11 +51961,16 @@ var require_axios = __commonJS({
         validateStatus: mergeDirectKeys,
         headers: (a, b, prop) => mergeDeepProperties(headersToObject2(a), headersToObject2(b), prop, true)
       };
-      utils$1.forEach(Object.keys({ ...config1, ...config2 }), function computeConfigValue(prop) {
-        const merge4 = mergeMap[prop] || mergeDeepProperties;
-        const configValue = merge4(config1[prop], config2[prop], prop);
-        utils$1.isUndefined(configValue) && merge4 !== mergeDirectKeys || (config[prop] = configValue);
-      });
+      utils$1.forEach(
+        Object.keys({ ...config1, ...config2 }),
+        function computeConfigValue(prop) {
+          if (prop === "__proto__" || prop === "constructor" || prop === "prototype")
+            return;
+          const merge4 = utils$1.hasOwnProp(mergeMap, prop) ? mergeMap[prop] : mergeDeepProperties;
+          const configValue = merge4(config1[prop], config2[prop], prop);
+          utils$1.isUndefined(configValue) && merge4 !== mergeDirectKeys || (config[prop] = configValue);
+        }
+      );
       return config;
     }
     var resolveConfig = (config) => {
@@ -50843,12 +52069,12 @@ var require_axios = __commonJS({
           if (!request) {
             return;
           }
-          reject(new AxiosError3("Request aborted", AxiosError3.ECONNABORTED, config, request));
+          reject(new AxiosError$1("Request aborted", AxiosError$1.ECONNABORTED, config, request));
           request = null;
         };
         request.onerror = function handleError(event) {
           const msg = event && event.message ? event.message : "Network Error";
-          const err = new AxiosError3(msg, AxiosError3.ERR_NETWORK, config, request);
+          const err = new AxiosError$1(msg, AxiosError$1.ERR_NETWORK, config, request);
           err.event = event || null;
           reject(err);
           request = null;
@@ -50859,9 +52085,9 @@ var require_axios = __commonJS({
           if (_config.timeoutErrorMessage) {
             timeoutErrorMessage = _config.timeoutErrorMessage;
           }
-          reject(new AxiosError3(
+          reject(new AxiosError$1(
             timeoutErrorMessage,
-            transitional2.clarifyTimeoutError ? AxiosError3.ETIMEDOUT : AxiosError3.ECONNABORTED,
+            transitional2.clarifyTimeoutError ? AxiosError$1.ETIMEDOUT : AxiosError$1.ECONNABORTED,
             config,
             request
           ));
@@ -50893,7 +52119,7 @@ var require_axios = __commonJS({
             if (!request) {
               return;
             }
-            reject(!cancel || cancel.type ? new CanceledError3(null, config, request) : cancel);
+            reject(!cancel || cancel.type ? new CanceledError$1(null, config, request) : cancel);
             request.abort();
             request = null;
           };
@@ -50904,7 +52130,7 @@ var require_axios = __commonJS({
         }
         const protocol = parseProtocol2(_config.url);
         if (protocol && platform3.protocols.indexOf(protocol) === -1) {
-          reject(new AxiosError3("Unsupported protocol " + protocol + ":", AxiosError3.ERR_BAD_REQUEST, config));
+          reject(new AxiosError$1("Unsupported protocol " + protocol + ":", AxiosError$1.ERR_BAD_REQUEST, config));
           return;
         }
         request.send(requestData || null);
@@ -50920,12 +52146,12 @@ var require_axios = __commonJS({
             aborted = true;
             unsubscribe();
             const err = reason instanceof Error ? reason : this.reason;
-            controller.abort(err instanceof AxiosError3 ? err : new CanceledError3(err instanceof Error ? err.message : err));
+            controller.abort(err instanceof AxiosError$1 ? err : new CanceledError$1(err instanceof Error ? err.message : err));
           }
         };
         let timer = timeout && setTimeout(() => {
           timer = null;
-          onabort(new AxiosError3(`timeout ${timeout} of ms exceeded`, AxiosError3.ETIMEDOUT));
+          onabort(new AxiosError$1(`timeout of ${timeout}ms exceeded`, AxiosError$1.ETIMEDOUT));
         }, timeout);
         const unsubscribe = () => {
           if (signals3) {
@@ -51072,7 +52298,7 @@ var require_axios = __commonJS({
             if (method) {
               return method.call(res);
             }
-            throw new AxiosError3(`Response type '${type}' is not supported`, AxiosError3.ERR_NOT_SUPPORT, config);
+            throw new AxiosError$1(`Response type '${type}' is not supported`, AxiosError$1.ERR_NOT_SUPPORT, config);
           });
         });
       })();
@@ -51197,13 +52423,13 @@ var require_axios = __commonJS({
           unsubscribe && unsubscribe();
           if (err && err.name === "TypeError" && /Load failed|fetch/i.test(err.message)) {
             throw Object.assign(
-              new AxiosError3("Network Error", AxiosError3.ERR_NETWORK, config, request),
+              new AxiosError$1("Network Error", AxiosError$1.ERR_NETWORK, config, request, err && err.response),
               {
                 cause: err.cause || err
               }
             );
           }
-          throw AxiosError3.from(err, err && err.code, config, request);
+          throw AxiosError$1.from(err, err && err.code, config, request, err && err.response);
         }
       };
     };
@@ -51257,7 +52483,7 @@ var require_axios = __commonJS({
         if (!isResolvedHandle2(nameOrAdapter)) {
           adapter2 = knownAdapters2[(id = String(nameOrAdapter)).toLowerCase()];
           if (adapter2 === void 0) {
-            throw new AxiosError3(`Unknown adapter '${id}'`);
+            throw new AxiosError$1(`Unknown adapter '${id}'`);
           }
         }
         if (adapter2 && (utils$1.isFunction(adapter2) || (adapter2 = adapter2.get(config)))) {
@@ -51270,7 +52496,7 @@ var require_axios = __commonJS({
           ([id, state]) => `adapter ${id} ` + (state === false ? "is not supported by the environment" : "is not available in the build")
         );
         let s = length ? reasons.length > 1 ? "since :\n" + reasons.map(renderReason2).join("\n") : " " + renderReason2(reasons[0]) : "as no adapter specified";
-        throw new AxiosError3(
+        throw new AxiosError$1(
           `There is no suitable adapter to dispatch the request ` + s,
           "ERR_NOT_SUPPORT"
         );
@@ -51294,7 +52520,7 @@ var require_axios = __commonJS({
         config.cancelToken.throwIfRequested();
       }
       if (config.signal && config.signal.aborted) {
-        throw new CanceledError3(null, config);
+        throw new CanceledError$1(null, config);
       }
     }
     function dispatchRequest2(config) {
@@ -51345,9 +52571,9 @@ var require_axios = __commonJS({
       }
       return (value, opt, opts) => {
         if (validator2 === false) {
-          throw new AxiosError3(
+          throw new AxiosError$1(
             formatMessage(opt, " has been removed" + (version ? " in " + version : "")),
-            AxiosError3.ERR_DEPRECATED
+            AxiosError$1.ERR_DEPRECATED
           );
         }
         if (version && !deprecatedWarnings2[opt]) {
@@ -51370,7 +52596,7 @@ var require_axios = __commonJS({
     };
     function assertOptions2(options, schema, allowUnknown) {
       if (typeof options !== "object") {
-        throw new AxiosError3("options must be an object", AxiosError3.ERR_BAD_OPTION_VALUE);
+        throw new AxiosError$1("options must be an object", AxiosError$1.ERR_BAD_OPTION_VALUE);
       }
       const keys = Object.keys(options);
       let i = keys.length;
@@ -51381,12 +52607,12 @@ var require_axios = __commonJS({
           const value = options[opt];
           const result = value === void 0 || validator2(value, opt, options);
           if (result !== true) {
-            throw new AxiosError3("option " + opt + " must be " + result, AxiosError3.ERR_BAD_OPTION_VALUE);
+            throw new AxiosError$1("option " + opt + " must be " + result, AxiosError$1.ERR_BAD_OPTION_VALUE);
           }
           continue;
         }
         if (allowUnknown !== true) {
-          throw new AxiosError3("Unknown option " + opt, AxiosError3.ERR_BAD_OPTION);
+          throw new AxiosError$1("Unknown option " + opt, AxiosError$1.ERR_BAD_OPTION);
         }
       }
     }
@@ -51444,7 +52670,8 @@ var require_axios = __commonJS({
           validator.assertOptions(transitional2, {
             silentJSONParsing: validators3.transitional(validators3.boolean),
             forcedJSONParsing: validators3.transitional(validators3.boolean),
-            clarifyTimeoutError: validators3.transitional(validators3.boolean)
+            clarifyTimeoutError: validators3.transitional(validators3.boolean),
+            legacyInterceptorReqResOrdering: validators3.transitional(validators3.boolean)
           }, false);
         }
         if (paramsSerializer != null) {
@@ -51488,7 +52715,13 @@ var require_axios = __commonJS({
             return;
           }
           synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
-          requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+          const transitional3 = config.transitional || transitionalDefaults;
+          const legacyInterceptorReqResOrdering = transitional3 && transitional3.legacyInterceptorReqResOrdering;
+          if (legacyInterceptorReqResOrdering) {
+            requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+          } else {
+            requestInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
+          }
         });
         const responseInterceptorChain = [];
         this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
@@ -51597,7 +52830,7 @@ var require_axios = __commonJS({
           if (token.reason) {
             return;
           }
-          token.reason = new CanceledError3(message2, config, request);
+          token.reason = new CanceledError$1(message2, config, request);
           resolvePromise(token.reason);
         });
       }
@@ -51755,12 +52988,12 @@ var require_axios = __commonJS({
     }
     var axios2 = createInstance2(defaults$1);
     axios2.Axios = Axios$1;
-    axios2.CanceledError = CanceledError3;
+    axios2.CanceledError = CanceledError$1;
     axios2.CancelToken = CancelToken$1;
     axios2.isCancel = isCancel3;
     axios2.VERSION = VERSION3;
     axios2.toFormData = toFormData3;
-    axios2.AxiosError = AxiosError3;
+    axios2.AxiosError = AxiosError$1;
     axios2.Cancel = axios2.CanceledError;
     axios2.all = function all3(promises) {
       return Promise.all(promises);
@@ -51783,8 +53016,11 @@ var require_ab_testing = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.messages = exports2.PromptMessages = exports2.NxCloudChoices = void 0;
-    exports2.shouldUseTemplateFlow = shouldUseTemplateFlow;
     exports2.getFlowVariant = getFlowVariant;
+    exports2.getCompletionMessageKeyForVariant = getCompletionMessageKeyForVariant;
+    exports2.shouldShowCloudPrompt = shouldShowCloudPrompt;
+    exports2.isEnterpriseCloudUrl = isEnterpriseCloudUrl;
+    exports2.getBannerVariant = getBannerVariant;
     exports2.recordStat = recordStat;
     var node_child_process_1 = require("node:child_process");
     var node_fs_1 = require("node:fs");
@@ -51799,10 +53035,15 @@ var require_ab_testing = __commonJS({
         if (!(0, node_fs_1.existsSync)(FLOW_VARIANT_CACHE_FILE))
           return null;
         const stats = (0, node_fs_1.statSync)(FLOW_VARIANT_CACHE_FILE);
-        if (Date.now() - stats.mtimeMs > FLOW_VARIANT_EXPIRY_MS)
+        if (Date.now() - stats.mtimeMs > FLOW_VARIANT_EXPIRY_MS) {
+          try {
+            (0, node_fs_1.unlinkSync)(FLOW_VARIANT_CACHE_FILE);
+          } catch {
+          }
           return null;
+        }
         const value = (0, node_fs_1.readFileSync)(FLOW_VARIANT_CACHE_FILE, "utf-8").trim();
-        return value === "0" || value === "1" ? value : null;
+        return ["0", "1", "2"].includes(value) ? value : null;
       } catch {
         return null;
       }
@@ -51813,28 +53054,60 @@ var require_ab_testing = __commonJS({
       } catch {
       }
     }
+    function selectRandomVariant() {
+      const rand = Math.random();
+      if (rand < 1 / 3)
+        return "0";
+      if (rand < 2 / 3)
+        return "1";
+      return "2";
+    }
     function getFlowVariantInternal() {
       if (flowVariantCache)
         return flowVariantCache;
-      const variant = process.env.NX_CNW_FLOW_VARIANT ?? readCachedFlowVariant() ?? (Math.random() < 0.5 ? "0" : "1");
+      const variant = process.env.NX_CNW_FLOW_VARIANT ?? readCachedFlowVariant() ?? selectRandomVariant();
       flowVariantCache = variant;
       if (!process.env.NX_CNW_FLOW_VARIANT && !(0, node_fs_1.existsSync)(FLOW_VARIANT_CACHE_FILE)) {
         writeCachedFlowVariant(variant);
       }
       return variant;
     }
-    function shouldUseTemplateFlow() {
+    function getFlowVariant() {
       if (process.env.NX_GENERATE_DOCS_PROCESS === "true") {
-        flowVariantCache = "0";
+        return "0";
+      }
+      return flowVariantCache ?? getFlowVariantInternal();
+    }
+    function getCompletionMessageKeyForVariant() {
+      return "platform-setup";
+    }
+    function shouldShowCloudPrompt() {
+      return false;
+    }
+    var STANDARD_NX_CLOUD_HOSTS = [
+      "cloud.nx.app",
+      "eu.nx.app",
+      "staging.nx.app",
+      "snapshot.nx.app"
+    ];
+    function isEnterpriseCloudUrl(cloudUrl) {
+      if (!cloudUrl)
+        return false;
+      try {
+        const url2 = new URL(cloudUrl);
+        return !STANDARD_NX_CLOUD_HOSTS.includes(url2.hostname);
+      } catch {
         return false;
       }
-      return getFlowVariantInternal() === "1";
     }
-    function getFlowVariant() {
+    function getBannerVariant(cloudUrl) {
+      if (isEnterpriseCloudUrl(cloudUrl)) {
+        return "0";
+      }
       if (process.env.NX_GENERATE_DOCS_PROCESS === "true") {
         return "0";
       }
-      return flowVariantCache ?? getFlowVariantInternal();
+      return "2";
     }
     exports2.NxCloudChoices = [
       "github",
@@ -51870,66 +53143,65 @@ var require_ab_testing = __commonJS({
       ],
       /**
        * These messages are a fallback for setting up CI as well as when migrating major versions
+       * Locked to "full platform" messaging (CLOUD-4235)
        */
       setupNxCloud: [
         {
-          code: "enable-caching2",
-          message: `Would you like remote caching to make your build faster?`,
+          code: "cloud-v2-full-platform-visit",
+          message: "Try the full Nx platform?",
           initial: 0,
           choices: [
             { value: "yes", name: "Yes" },
-            {
-              value: "skip",
-              name: "No - I would not like remote caching"
-            }
+            { value: "skip", name: "Skip" }
           ],
-          footer: "\nRead more about remote caching at https://nx.dev/ci/features/remote-cache",
-          hint: `
-(can be disabled any time).`,
+          footer: "\nAutomatically fix broken PRs, 70% faster CI: https://nx.dev/nx-cloud",
           fallback: void 0,
-          completionMessage: "cache-setup"
+          completionMessage: "platform-setup"
         }
       ],
       /**
        * Simplified Cloud prompt for template flow
        */
       setupNxCloudV2: [
-        {
-          code: "cloud-v2-remote-cache-visit",
-          message: "Enable remote caching with Nx Cloud?",
-          initial: 0,
-          choices: [
-            { value: "yes", name: "Yes" },
-            { value: "skip", name: "Skip" }
-          ],
-          footer: "\nRemote caching makes your builds faster for development and in CI: https://nx.dev/ci/features/remote-cache",
-          fallback: void 0,
-          completionMessage: "cache-setup"
-        },
-        {
-          code: "cloud-v2-fast-ci-visit",
-          message: "Speed up CI and reduce compute costs with Nx Cloud?",
-          initial: 0,
-          choices: [
-            { value: "yes", name: "Yes" },
-            { value: "skip", name: "Skip" }
-          ],
-          footer: "\n70% faster CI, 60% less compute, Automatically fix broken PRs: https://nx.dev/nx-cloud",
-          fallback: void 0,
-          completionMessage: "ci-setup"
-        },
-        {
-          code: "cloud-v2-green-prs-visit",
-          message: "Get to green PRs faster with Nx Cloud?",
-          initial: 0,
-          choices: [
-            { value: "yes", name: "Yes" },
-            { value: "skip", name: "Skip" }
-          ],
-          footer: "\nAutomatically fix broken PRs, 70% faster CI: https://nx.dev/nx-cloud",
-          fallback: void 0,
-          completionMessage: "ci-setup"
-        },
+        //{
+        //  code: 'cloud-v2-remote-cache-visit',
+        //  message: 'Enable remote caching with Nx Cloud?',
+        //  initial: 0,
+        //  choices: [
+        //    { value: 'yes', name: 'Yes' },
+        //    { value: 'skip', name: 'Skip' },
+        //  ],
+        //  footer:
+        //    '\nRemote caching makes your builds faster for development and in CI: https://nx.dev/ci/features/remote-cache',
+        //  fallback: undefined,
+        //  completionMessage: 'cache-setup',
+        //},
+        //{
+        //  code: 'cloud-v2-fast-ci-visit',
+        //  message: 'Speed up CI and reduce compute costs with Nx Cloud?',
+        //  initial: 0,
+        //  choices: [
+        //    { value: 'yes', name: 'Yes' },
+        //    { value: 'skip', name: 'Skip' },
+        //  ],
+        //  footer:
+        //    '\n70% faster CI, 60% less compute, Automatically fix broken PRs: https://nx.dev/nx-cloud',
+        //  fallback: undefined,
+        //  completionMessage: 'ci-setup',
+        //},
+        //{
+        //  code: 'cloud-v2-green-prs-visit',
+        //  message: 'Get to green PRs faster with Nx Cloud?',
+        //  initial: 0,
+        //  choices: [
+        //    { value: 'yes', name: 'Yes' },
+        //    { value: 'skip', name: 'Skip' },
+        //  ],
+        //  footer:
+        //    '\nAutomatically fix broken PRs, 70% faster CI: https://nx.dev/nx-cloud',
+        //  fallback: undefined,
+        //  completionMessage: 'ci-setup',
+        //},
         {
           code: "cloud-v2-full-platform-visit",
           message: "Try the full Nx platform?",
@@ -51976,27 +53248,24 @@ var require_ab_testing = __commonJS({
     };
     exports2.PromptMessages = PromptMessages;
     exports2.messages = new PromptMessages();
+    function getCloudUrl() {
+      const url2 = process.env.NX_CLOUD_API || process.env.NRWL_API || "https://cloud.nx.app";
+      return url2[url2.length - 1] === "/" ? url2.slice(0, -1) : url2;
+    }
     async function recordStat(opts) {
       try {
         if (!shouldRecordStats()) {
           return;
         }
-        const { getCloudUrl: getCloudUrl2 } = require(require.resolve(
-          "nx/src/nx-cloud/utilities/get-cloud-options",
-          {
-            paths: [opts.directory]
-          }
-          // nx-ignore-next-line
-        ));
         const axios2 = require_axios();
         await (axios2["default"] ?? axios2).create({
-          baseURL: getCloudUrl2(),
+          baseURL: getCloudUrl(),
           timeout: 400
         }).post("/nx-cloud/stats", {
           command: opts.command,
           isCI: (0, is_ci_1.isCI)(),
           useCloud: opts.useCloud,
-          meta: [opts.nxVersion, ...opts.meta].filter((v) => !!v).join(",")
+          meta: JSON.stringify({ nxVersion: opts.nxVersion, ...opts.meta })
         });
       } catch (e) {
         if (process.env.NX_VERBOSE_LOGGING === "true") {
@@ -52032,6 +53301,7 @@ var require_nx_cloud = __commonJS({
     var output_1 = require_output();
     var messages_1 = require_messages();
     var ab_testing_1 = require_ab_testing();
+    var nx_version_1 = require_nx_version();
     var ora = require_ora();
     async function connectToNxCloudForTemplate(directory, installationSource, useGitHub) {
       const { connectToNxCloud } = require(require.resolve(
@@ -52064,7 +53334,7 @@ var require_nx_cloud = __commonJS({
         // nx-ignore-next-line
       ));
       const { accessToken, nxCloudId } = getCloudOptions(directory);
-      nxCloudSpinner.succeed("Nx Cloud has been set up successfully");
+      nxCloudSpinner.succeed("Nx Cloud configuration was successfully added");
       return accessToken || nxCloudId;
     }
     async function createNxCloudOnboardingUrl(nxCloud, token, directory, useGitHub) {
@@ -52076,17 +53346,22 @@ var require_nx_cloud = __commonJS({
         // nx-ignore-next-line
       ));
       const source = nxCloud === "yes" ? "create-nx-workspace-success-cache-setup" : "create-nx-workspace-success-ci-setup";
-      const flowVariant = (0, ab_testing_1.getFlowVariant)();
-      const prefix = flowVariant === "1" ? "start-v2" : "start";
-      const promptCode = flowVariant === "1" ? ab_testing_1.messages.codeOfSelectedPromptMessage("setupNxCloudV2") : "";
-      const code = promptCode || (nxCloud === "yes" ? "remote-cache-visit" : "ci-setup-visit");
-      const meta = `${prefix}-${code}`;
+      const meta = JSON.stringify({
+        variant: (0, ab_testing_1.getFlowVariant)(),
+        nxVersion: nx_version_1.nxVersion
+      });
       return createNxCloudOnboardingURL(source, token, meta, false, useGitHub ?? (nxCloud === "yes" || nxCloud === "github" || nxCloud === "circleci"), directory);
     }
-    async function getNxCloudInfo(connectCloudUrl, pushedToVcs, completionMessageKey) {
+    async function getNxCloudInfo(connectCloudUrl, pushedToVcs, completionMessageKey, workspaceName) {
       const out = new output_1.CLIOutput(false);
-      const message2 = (0, messages_1.getCompletionMessage)(completionMessageKey, connectCloudUrl, pushedToVcs);
-      out.success(message2);
+      const bannerVariant = (0, ab_testing_1.getBannerVariant)(connectCloudUrl);
+      const message2 = (0, messages_1.getCompletionMessage)(completionMessageKey, connectCloudUrl, pushedToVcs, workspaceName, bannerVariant);
+      if (!message2.title) {
+        out.addNewline();
+        out.writeLines(message2.bodyLines ?? []);
+      } else {
+        out.success(message2);
+      }
       return out.getOutput();
     }
     function getSkippedNxCloudInfo() {
@@ -52242,11 +53517,10 @@ var require_clone_template = __commonJS({
     var fs_1 = require("fs");
     var promises_1 = require("fs/promises");
     var path_1 = require("path");
-    var output_1 = require_output();
     var error_utils_1 = require_error_utils();
     async function cloneTemplate(templateUrl, targetDirectory) {
       if ((0, fs_1.existsSync)(targetDirectory)) {
-        throw new Error(`The directory '${targetDirectory}' already exists and is not empty. Choose a different name or remove the existing directory.`);
+        throw new error_utils_1.CnwError("DIRECTORY_EXISTS", `The directory '${targetDirectory}' already exists. Choose a different name or remove the existing directory.`);
       }
       try {
         await (0, child_process_utils_1.execAndWait)(`git clone --depth 1 "${templateUrl}" "${targetDirectory}"`, process.cwd());
@@ -52255,17 +53529,269 @@ var require_clone_template = __commonJS({
           await (0, promises_1.rm)(gitDir, { recursive: true, force: true });
         }
       } catch (e) {
-        if (e instanceof Error) {
-          output_1.output.error({
-            title: "Failed to create starter workspace",
-            bodyLines: (0, error_utils_1.mapErrorToBodyLines)(e)
+        const message2 = e instanceof Error ? e.message : String(e);
+        throw new error_utils_1.CnwError("TEMPLATE_CLONE_FAILED", `Failed to create starter workspace: ${message2}`);
+      }
+    }
+  }
+});
+
+// node_modules/create-nx-workspace/src/utils/template/update-readme.js
+var require_update_readme = __commonJS({
+  "node_modules/create-nx-workspace/src/utils/template/update-readme.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.updateReadmeContent = updateReadmeContent;
+    exports2.addConnectUrlToReadme = addConnectUrlToReadme;
+    exports2.amendOrCommitReadme = amendOrCommitReadme;
+    var node_fs_1 = require("node:fs");
+    var path_1 = require("path");
+    var child_process_utils_1 = require_child_process_utils();
+    var BEGIN_MARKER = "<!-- BEGIN: nx-cloud -->";
+    var END_MARKER = "<!-- END: nx-cloud -->";
+    var CLOUD_SETUP_SECTION = `## Finish your Nx platform setup
+
+\u{1F680} [Finish setting up your workspace]({{CONNECT_URL}}) to get faster builds with remote caching, distributed task execution, and self-healing CI. [Learn more about Nx Cloud](https://nx.dev/ci/intro/why-nx-cloud).
+`;
+    function updateReadmeContent(readmeContent, connectUrl) {
+      const beginIndex = readmeContent.indexOf(BEGIN_MARKER);
+      const endIndex = readmeContent.indexOf(END_MARKER);
+      if (beginIndex === -1 || endIndex === -1 || beginIndex >= endIndex) {
+        return readmeContent;
+      }
+      if (!connectUrl) {
+        const contentStart = beginIndex + BEGIN_MARKER.length;
+        const contentStartSkipNewline = readmeContent[contentStart] === "\n" ? contentStart + 1 : contentStart;
+        const content = readmeContent.slice(contentStartSkipNewline, endIndex);
+        const afterEnd2 = endIndex + END_MARKER.length;
+        const skipTrailing = readmeContent[afterEnd2] === "\n" ? afterEnd2 + 1 : afterEnd2;
+        return readmeContent.slice(0, beginIndex) + content + readmeContent.slice(skipTrailing);
+      }
+      const section = CLOUD_SETUP_SECTION.replace("{{CONNECT_URL}}", connectUrl);
+      const afterEnd = endIndex + END_MARKER.length;
+      const skipNewline = readmeContent[afterEnd] === "\n" ? afterEnd + 1 : afterEnd;
+      return readmeContent.slice(0, beginIndex) + section + readmeContent.slice(skipNewline);
+    }
+    function addConnectUrlToReadme(directory, connectUrl) {
+      const readmePath = (0, path_1.join)(directory, "README.md");
+      if (!(0, node_fs_1.existsSync)(readmePath)) {
+        return false;
+      }
+      const content = (0, node_fs_1.readFileSync)(readmePath, "utf-8");
+      const updated = updateReadmeContent(content, connectUrl);
+      if (updated !== content) {
+        (0, node_fs_1.writeFileSync)(readmePath, updated);
+        return true;
+      }
+      return false;
+    }
+    async function amendOrCommitReadme(directory, alreadyPushed) {
+      await (0, child_process_utils_1.execAndWait)("git add README.md", directory);
+      if (alreadyPushed) {
+        await (0, child_process_utils_1.execAndWait)('git commit -m "chore: add Nx Cloud setup link to README"', directory);
+        await (0, child_process_utils_1.execAndWait)("git push", directory);
+      } else {
+        try {
+          await (0, child_process_utils_1.execAndWait)("git commit --amend --no-edit", directory);
+        } catch {
+        }
+      }
+    }
+  }
+});
+
+// node_modules/create-nx-workspace/src/utils/ai/ai-output.js
+var require_ai_output = __commonJS({
+  "node_modules/create-nx-workspace/src/utils/ai/ai-output.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SUGGESTED_WORKSPACE_NAME = void 0;
+    exports2.isAiAgent = isAiAgent;
+    exports2.isClaudeCode = isClaudeCode;
+    exports2.isOpenCode = isOpenCode;
+    exports2.isReplitAi = isReplitAi;
+    exports2.isCursorAi = isCursorAi;
+    exports2.writeAiOutput = writeAiOutput;
+    exports2.logProgress = logProgress;
+    exports2.buildTemplateRequiredResult = buildTemplateRequiredResult;
+    exports2.buildSuccessResult = buildSuccessResult;
+    exports2.buildErrorResult = buildErrorResult;
+    var _isAiAgent = null;
+    function isAiAgent() {
+      if (_isAiAgent === null) {
+        _isAiAgent = isClaudeCode() || isOpenCode() || isReplitAi() || isCursorAi();
+      }
+      return _isAiAgent;
+    }
+    function isClaudeCode() {
+      return !!process.env.CLAUDECODE || !!process.env.CLAUDE_CODE;
+    }
+    function isOpenCode() {
+      return !!process.env.OPENCODE;
+    }
+    function isReplitAi() {
+      return !!process.env.REPL_ID;
+    }
+    function isCursorAi() {
+      const pagerMatches = process.env.PAGER === "head -n 10000 | cat";
+      const hasCursorTraceId = !!process.env.CURSOR_TRACE_ID;
+      const hasComposerNoInteraction = !!process.env.COMPOSER_NO_INTERACTION;
+      return pagerMatches && hasCursorTraceId && hasComposerNoInteraction;
+    }
+    function writeAiOutput(message2) {
+      if (isAiAgent()) {
+        process.stdout.write(JSON.stringify(message2) + "\n");
+        if (message2.stage === "complete" && "success" in message2 && message2.success) {
+          const successMsg = message2;
+          const steps = successMsg.userNextSteps.steps;
+          let plainText = "\n---USER_NEXT_STEPS---\n";
+          plainText += "[DISPLAY] Show the user these next steps to complete setup:\n\n";
+          steps.forEach((step, i) => {
+            plainText += `${i + 1}. ${step.title}`;
+            if (step.url) {
+              plainText += `: ${step.url}`;
+            }
+            if (step.note) {
+              plainText += `
+   ${step.note}`;
+            }
+            plainText += "\n";
           });
-        } else {
-          console.error(e);
+          plainText += "---END---\n";
+          process.stdout.write(plainText);
         }
-        process.exit(1);
       }
     }
+    function logProgress(stage, message2) {
+      writeAiOutput({ stage, message: message2 });
+    }
+    function buildTemplateRequiredResult(workspaceName) {
+      const name = workspaceName || exports2.SUGGESTED_WORKSPACE_NAME;
+      return {
+        stage: "needs_input",
+        success: false,
+        title: "Template Selection Required",
+        message: "Ask the user which workspace type they want, then run again with --template. If the directory exists, append a number (e.g., my-nx-repo-2).",
+        suggestedName: name,
+        templates: [
+          {
+            name: "Empty Monorepo",
+            value: "nrwl/empty-template",
+            description: "Minimal workspace to build on - best for custom setups or learning Nx."
+          },
+          {
+            name: "React Fullstack",
+            value: "nrwl/react-template",
+            description: "Complete React + Express monorepo with examples and best practices."
+          },
+          {
+            name: "Angular Fullstack",
+            value: "nrwl/angular-template",
+            description: "Complete Angular + Express monorepo with examples."
+          },
+          {
+            name: "TypeScript/npm Packages",
+            value: "nrwl/typescript-template",
+            description: "For building and publishing npm packages."
+          }
+        ],
+        recommendedTemplate: "nrwl/empty-template",
+        exampleCommand: `npx create-nx-workspace@latest ${name} --template=nrwl/empty-template`,
+        docsGettingStarted: "https://nx.dev/getting-started/intro"
+      };
+    }
+    function buildSuccessResult(options) {
+      const { workspacePath, workspaceName, template: template2, preset, nxCloudConnectUrl, nxCloudError } = options;
+      const resultData = {
+        title: "Nx Workspace Created Successfully",
+        workspacePath,
+        workspaceName
+      };
+      if (template2) {
+        resultData.template = template2;
+      }
+      if (preset) {
+        resultData.preset = preset;
+      }
+      const steps = [];
+      if (nxCloudConnectUrl) {
+        steps.push({
+          title: "Connect to Nx Cloud (Recommended)",
+          url: nxCloudConnectUrl,
+          note: "Complete setup to enable remote caching and CI insights"
+        });
+      }
+      const userNextSteps = {
+        description: "CRITICAL: Show the user these exact steps to complete setup.",
+        steps
+      };
+      const successResult = {
+        stage: "complete",
+        success: true,
+        result: resultData,
+        userNextSteps,
+        docs: {
+          gettingStarted: "https://nx.dev/getting-started/intro",
+          nxCloud: "https://nx.dev/ci/intro/why-nx-cloud"
+        }
+      };
+      if (nxCloudError) {
+        successResult.nxCloudError = nxCloudError;
+      }
+      return successResult;
+    }
+    function buildErrorResult(error, errorCode, errorLogPath) {
+      const hints = getErrorHints(errorCode);
+      return {
+        stage: "error",
+        success: false,
+        title: "Workspace Creation Failed",
+        error,
+        errorCode,
+        hints,
+        errorLogPath,
+        docsGettingStarted: "https://nx.dev/getting-started/intro"
+      };
+    }
+    function getErrorHints(errorCode) {
+      switch (errorCode) {
+        case "DIRECTORY_EXISTS":
+          return [
+            "Choose a different workspace name",
+            "Remove the existing directory with 'rm -rf <directory>'"
+          ];
+        case "INVALID_FOLDER_NAME":
+          return [
+            "Workspace names must start with a letter",
+            "Examples of valid names: myapp, MyApp, my-app, my_app"
+          ];
+        case "INVALID_PRESET":
+          return [
+            "Check the preset name spelling",
+            "Run with --help to see available presets",
+            "Use --template for template-based workspaces"
+          ];
+        case "NETWORK_ERROR":
+          return [
+            "Check your internet connection",
+            "Try again in a few moments",
+            "Check if npm/yarn registry is accessible"
+          ];
+        case "PACKAGE_INSTALL_ERROR":
+          return [
+            "Check your package manager is installed correctly",
+            "Try clearing npm/yarn cache",
+            "Check for conflicting global packages"
+          ];
+        default:
+          return [
+            "Check the error message for details",
+            "Visit https://nx.dev/getting-started/intro for documentation",
+            "Report issues at https://github.com/nrwl/nx/issues"
+          ];
+      }
+    }
+    exports2.SUGGESTED_WORKSPACE_NAME = "my-nx-repo";
   }
 });
 
@@ -52277,6 +53803,7 @@ var require_create_workspace = __commonJS({
     exports2.getInterruptedWorkspaceState = getInterruptedWorkspaceState;
     exports2.createWorkspace = createWorkspace2;
     exports2.extractConnectUrl = extractConnectUrl;
+    var node_fs_1 = require("node:fs");
     var path_1 = require("path");
     var create_empty_workspace_1 = require_create_empty_workspace();
     var create_preset_1 = require_create_preset();
@@ -52289,7 +53816,10 @@ var require_create_workspace = __commonJS({
     var get_third_party_preset_1 = require_get_third_party_preset();
     var preset_1 = require_preset();
     var clone_template_1 = require_clone_template();
+    var update_readme_1 = require_update_readme();
     var child_process_utils_1 = require_child_process_utils();
+    var package_manager_1 = require_package_manager();
+    var ai_output_1 = require_ai_output();
     var workspaceDirectory;
     var cloudConnectUrl;
     function getInterruptedWorkspaceState() {
@@ -52307,27 +53837,57 @@ var require_create_workspace = __commonJS({
         const templateUrl = `https://github.com/${options.template}`;
         const workingDir = process.cwd().replace(/\\/g, "/");
         directory = (0, path_1.join)(workingDir, name);
-        const ora = require_ora();
-        const workspaceSetupSpinner = ora(`Creating workspace from template`).start();
+        const aiMode = (0, ai_output_1.isAiAgent)();
+        let workspaceSetupSpinner;
+        if (aiMode) {
+          (0, ai_output_1.logProgress)("cloning", `Cloning template ${options.template}...`);
+        } else {
+          const ora = require_ora();
+          workspaceSetupSpinner = ora(`Creating workspace from template`).start();
+        }
         try {
           await (0, clone_template_1.cloneTemplate)(templateUrl, name);
-          await (0, child_process_utils_1.execAndWait)("npm install --silent --ignore-scripts", directory);
+          const npmLockPath = (0, path_1.join)(directory, "package-lock.json");
+          if ((0, node_fs_1.existsSync)(npmLockPath)) {
+            (0, node_fs_1.unlinkSync)(npmLockPath);
+          }
+          (0, package_manager_1.generatePackageManagerFiles)(directory, packageManager);
+          if (aiMode) {
+            (0, ai_output_1.logProgress)("installing", `Installing dependencies with ${packageManager}...`);
+          }
+          const pmc = (0, package_manager_1.getPackageManagerCommand)(packageManager);
+          if (pmc.preInstall) {
+            await (0, child_process_utils_1.execAndWait)(pmc.preInstall, directory);
+          }
+          await (0, child_process_utils_1.execAndWait)(pmc.install, directory);
           workspaceDirectory = directory;
-          workspaceSetupSpinner.succeed(`Successfully created the workspace: ${directory}`);
+          if (aiMode) {
+            (0, ai_output_1.logProgress)("configuring", `Successfully created the workspace: ${directory}`);
+          } else {
+            workspaceSetupSpinner.succeed(`Successfully created the workspace: ${directory}`);
+          }
         } catch (e) {
-          workspaceSetupSpinner.fail();
+          if (!aiMode) {
+            workspaceSetupSpinner.fail();
+          }
           throw e;
         }
-        if (nxCloud !== "skip") {
+        if (nxCloud !== "skip" && !options.skipCloudConnect) {
           await (0, nx_cloud_1.connectToNxCloudForTemplate)(directory, "create-nx-workspace", useGitHub);
         }
       } else {
+        if (!preset) {
+          throw new Error("Preset is required when not using a template. Please provide --preset or --template.");
+        }
         const tmpDir = await (0, create_sandbox_1.createSandbox)(packageManager);
         const workspaceGlobs = getWorkspaceGlobsFromPreset(preset);
         directory = await (0, create_empty_workspace_1.createEmptyWorkspace)(tmpDir, name, packageManager, {
           ...options,
           preset,
-          workspaceGlobs
+          workspaceGlobs,
+          // We want new workspaces to have a short URL to finish Cloud onboarding, but not have nxCloudId set up since it will be handled as part of the onboarding flow.
+          // This is skipping nxCloudId for the "custom" flow.
+          nxCloud: "skip"
         });
         workspaceDirectory = directory;
         const thirdPartyPackageName = (0, get_third_party_preset_1.getPackageNameFromThirdPartyPreset)(preset);
@@ -52336,14 +53896,19 @@ var require_create_workspace = __commonJS({
         }
       }
       const isTemplate = !!options.template;
-      if (nxCloud !== "skip" && !isTemplate && nxCloud !== "yes") {
-        await (0, setup_ci_1.setupCI)(directory, nxCloud, packageManager);
+      if (nxCloud !== "skip" && !isTemplate) {
+        const ciProvider = nxCloud === "yes" ? "github" : nxCloud;
+        await (0, setup_ci_1.setupCI)(directory, ciProvider, packageManager);
       }
       let pushedToVcs = git_1.VcsPushStatus.SkippedGit;
       if (!skipGit) {
+        const aiMode = (0, ai_output_1.isAiAgent)();
+        if (aiMode) {
+          (0, ai_output_1.logProgress)("initializing", "Initializing git repository...");
+        }
         try {
           await (0, git_1.initializeGitRepo)(directory, { defaultBase, commit });
-          if (commit && !skipGitHubPush && (nxCloud === "github" || isTemplate && nxCloud === "yes")) {
+          if (commit && !skipGitHubPush && (nxCloud === "github" || nxCloud === "yes")) {
             pushedToVcs = await (0, git_1.pushToGitHub)(directory, {
               skipGitHubPush,
               name,
@@ -52353,10 +53918,12 @@ var require_create_workspace = __commonJS({
           }
         } catch (e) {
           if (e instanceof Error) {
-            output_1.output.error({
-              title: "Could not initialize git repository",
-              bodyLines: (0, error_utils_1.mapErrorToBodyLines)(e)
-            });
+            if (!aiMode) {
+              output_1.output.error({
+                title: "Could not initialize git repository",
+                bodyLines: (0, error_utils_1.mapErrorToBodyLines)(e)
+              });
+            }
           } else {
             console.error(e);
           }
@@ -52365,17 +53932,34 @@ var require_create_workspace = __commonJS({
       let connectUrl;
       let nxCloudInfo;
       if (nxCloud !== "skip") {
-        const token = (0, nx_cloud_1.readNxCloudToken)(directory);
+        const aiModeForCloud = (0, ai_output_1.isAiAgent)();
+        if (aiModeForCloud) {
+          (0, ai_output_1.logProgress)("configuring", "Configuring Nx Cloud...");
+        }
+        const token = options.skipCloudConnect ? void 0 : (0, nx_cloud_1.readNxCloudToken)(directory);
         connectUrl = await (0, nx_cloud_1.createNxCloudOnboardingUrl)(nxCloud, token, directory, useGitHub);
         cloudConnectUrl = connectUrl;
-        nxCloudInfo = await (0, nx_cloud_1.getNxCloudInfo)(connectUrl, pushedToVcs, options.completionMessageKey);
+        if (isTemplate) {
+          const readmeUpdated = (0, update_readme_1.addConnectUrlToReadme)(directory, connectUrl);
+          if (readmeUpdated && !skipGit && commit) {
+            const alreadyPushed = pushedToVcs === git_1.VcsPushStatus.PushedToVcs;
+            await (0, update_readme_1.amendOrCommitReadme)(directory, alreadyPushed);
+          }
+        }
+        nxCloudInfo = await (0, nx_cloud_1.getNxCloudInfo)(connectUrl, pushedToVcs, options.completionMessageKey, name);
       } else if (isTemplate && nxCloud === "skip") {
+        const readmeUpdated = (0, update_readme_1.addConnectUrlToReadme)(directory, void 0);
+        if (readmeUpdated && !skipGit && commit) {
+          const alreadyPushed = pushedToVcs === git_1.VcsPushStatus.PushedToVcs;
+          await (0, update_readme_1.amendOrCommitReadme)(directory, alreadyPushed);
+        }
         nxCloudInfo = (0, nx_cloud_1.getSkippedNxCloudInfo)();
       }
       return {
         nxCloudInfo,
         directory,
-        pushedToVcs
+        pushedToVcs,
+        connectUrl
       };
     }
     function extractConnectUrl(text) {
@@ -57110,6 +58694,7 @@ var require_pattern = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     var code_1 = require_code2();
+    var util_1 = require_util3();
     var codegen_1 = require_codegen();
     var error = {
       message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
@@ -57122,10 +58707,18 @@ var require_pattern = __commonJS({
       $data: true,
       error,
       code(cxt) {
-        const { data, $data, schema, schemaCode, it } = cxt;
+        const { gen, data, $data, schema, schemaCode, it } = cxt;
         const u = it.opts.unicodeRegExp ? "u" : "";
-        const regExp = $data ? (0, codegen_1._)`(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema);
-        cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+        if ($data) {
+          const { regExp } = it.opts.code;
+          const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._)`new RegExp` : (0, util_1.useFunc)(gen, regExp);
+          const valid = gen.let("valid");
+          gen.try(() => gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
+          cxt.fail$data((0, codegen_1._)`!${valid}`);
+        } else {
+          const regExp = (0, code_1.usePattern)(cxt, schema);
+          cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+        }
       }
     };
     exports2.default = def;
@@ -59269,10 +60862,11 @@ __export(base_exports, {
   scrollUp: () => scrollUp,
   setCwd: () => setCwd
 });
-var import_node_process2, ESC2, OSC, BEL, SEP, isTerminalApp, isWindows3, cwdFunction, cursorTo2, cursorMove, cursorUp2, cursorDown2, cursorForward, cursorBackward, cursorLeft2, cursorSavePosition, cursorRestorePosition, cursorGetPosition, cursorNextLine, cursorPrevLine, cursorHide2, cursorShow2, eraseLines2, eraseEndLine, eraseStartLine, eraseLine2, eraseDown, eraseUp, eraseScreen, scrollUp, scrollDown, clearScreen, clearViewport, clearTerminal, enterAlternativeScreen, exitAlternativeScreen, beep, link, image, iTerm, ConEmu, setCwd;
+var import_node_process2, import_node_os2, ESC2, OSC, BEL, SEP, isTerminalApp, isWindows3, isTmux, cwdFunction, wrapOsc, cursorTo2, cursorMove, cursorUp2, cursorDown2, cursorForward, cursorBackward, cursorLeft2, cursorSavePosition, cursorRestorePosition, cursorGetPosition, cursorNextLine, cursorPrevLine, cursorHide2, cursorShow2, eraseLines2, eraseEndLine, eraseStartLine, eraseLine2, eraseDown, eraseUp, eraseScreen, scrollUp, scrollDown, clearScreen, clearViewport, isOldWindows, clearTerminal, enterAlternativeScreen, exitAlternativeScreen, beep, link, image, iTerm, ConEmu, setCwd;
 var init_base = __esm({
   "node_modules/log-update/node_modules/ansi-escapes/base.js"() {
     import_node_process2 = __toESM(require("node:process"), 1);
+    import_node_os2 = __toESM(require("node:os"), 1);
     init_environment();
     ESC2 = "\x1B[";
     OSC = "\x1B]";
@@ -59280,9 +60874,16 @@ var init_base = __esm({
     SEP = ";";
     isTerminalApp = !isBrowser && import_node_process2.default.env.TERM_PROGRAM === "Apple_Terminal";
     isWindows3 = !isBrowser && import_node_process2.default.platform === "win32";
+    isTmux = !isBrowser && (import_node_process2.default.env.TERM?.startsWith("screen") || import_node_process2.default.env.TERM?.startsWith("tmux") || import_node_process2.default.env.TMUX !== void 0);
     cwdFunction = isBrowser ? () => {
       throw new Error("`process.cwd()` only works in Node.js, not the browser.");
     } : import_node_process2.default.cwd;
+    wrapOsc = (sequence) => {
+      if (isTmux) {
+        return "\x1BPtmux;" + sequence.replaceAll("\x1B", "\x1B\x1B") + "\x1B\\";
+      }
+      return sequence;
+    };
     cursorTo2 = (x, y) => {
       if (typeof x !== "number") {
         throw new TypeError("The `x` argument is required");
@@ -59341,24 +60942,30 @@ var init_base = __esm({
     scrollDown = ESC2 + "T";
     clearScreen = "\x1Bc";
     clearViewport = `${eraseScreen}${ESC2}H`;
-    clearTerminal = isWindows3 ? `${eraseScreen}${ESC2}0f` : `${eraseScreen}${ESC2}3J${ESC2}H`;
+    isOldWindows = () => {
+      if (isBrowser || !isWindows3) {
+        return false;
+      }
+      const parts = import_node_os2.default.release().split(".");
+      const major = Number(parts[0]);
+      const build = Number(parts[2] ?? 0);
+      if (major < 10) {
+        return true;
+      }
+      if (major === 10 && build < 10586) {
+        return true;
+      }
+      return false;
+    };
+    clearTerminal = isOldWindows() ? `${eraseScreen}${ESC2}0f` : `${eraseScreen}${ESC2}3J${ESC2}H`;
     enterAlternativeScreen = ESC2 + "?1049h";
     exitAlternativeScreen = ESC2 + "?1049l";
     beep = BEL;
-    link = (text, url2) => [
-      OSC,
-      "8",
-      SEP,
-      SEP,
-      url2,
-      BEL,
-      text,
-      OSC,
-      "8",
-      SEP,
-      SEP,
-      BEL
-    ].join("");
+    link = (text, url2) => {
+      const openLink = wrapOsc(`${OSC}8${SEP}${SEP}${url2}${BEL}`);
+      const closeLink = wrapOsc(`${OSC}8${SEP}${SEP}${BEL}`);
+      return openLink + text + closeLink;
+    };
     image = (data, options = {}) => {
       let returnValue = `${OSC}1337;File=inline=1`;
       if (options.width) {
@@ -59371,10 +60978,10 @@ var init_base = __esm({
         returnValue += ";preserveAspectRatio=0";
       }
       const imageBuffer = Buffer.from(data);
-      return returnValue + `;size=${imageBuffer.byteLength}:` + imageBuffer.toString("base64") + BEL;
+      return wrapOsc(returnValue + `;size=${imageBuffer.byteLength}:` + imageBuffer.toString("base64") + BEL);
     };
     iTerm = {
-      setCwd: (cwd = cwdFunction()) => `${OSC}50;CurrentDir=${cwd}${BEL}`,
+      setCwd: (cwd = cwdFunction()) => wrapOsc(`${OSC}50;CurrentDir=${cwd}${BEL}`),
       annotation(message2, options = {}) {
         let returnValue = `${OSC}1337;`;
         const hasX = options.x !== void 0;
@@ -59389,11 +60996,11 @@ var init_base = __esm({
         } else {
           returnValue += message2;
         }
-        return returnValue + BEL;
+        return wrapOsc(returnValue + BEL);
       }
     };
     ConEmu = {
-      setCwd: (cwd = cwdFunction()) => `${OSC}9;9;${cwd}${BEL}`
+      setCwd: (cwd = cwdFunction()) => wrapOsc(`${OSC}9;9;${cwd}${BEL}`)
     };
     setCwd = (cwd = cwdFunction()) => iTerm.setCwd(cwd) + ConEmu.setCwd(cwd);
   }
@@ -60614,29 +62221,77 @@ __export(log_update_exports, {
   default: () => log_update_default,
   logUpdateStderr: () => logUpdateStderr
 });
-function createLogUpdate(stream4, { showCursor = false } = {}) {
+function createLogUpdate(stream4, { showCursor = false, defaultWidth, defaultHeight } = {}) {
   let previousLineCount = 0;
-  let previousWidth = getWidth(stream4);
+  let previousWidth = getWidth(stream4, defaultWidth);
   let previousOutput = "";
+  const computeFrame = (text, width) => {
+    const textString = String(text);
+    const raw = textString.endsWith("\n") ? textString : `${textString}
+`;
+    const wrapped = wrapAnsi2(raw, width, { trim: false, hard: true, wordWrap: false });
+    const { text: clippedText, wasClipped } = fitToTerminalHeight(stream4, wrapped, defaultHeight);
+    const lines = clippedText === "" ? [] : clippedText.split("\n");
+    return { wrapped: clippedText, lines, wasClipped };
+  };
   const reset2 = () => {
     previousOutput = "";
-    previousWidth = getWidth(stream4);
+    previousWidth = getWidth(stream4, defaultWidth);
     previousLineCount = 0;
   };
   const render = (...arguments_) => {
     if (!showCursor) {
       cli_cursor_default.hide();
     }
-    let output = fitToTerminalHeight(stream4, arguments_.join(" ") + "\n");
-    const width = getWidth(stream4);
-    if (output === previousOutput && previousWidth === width) {
+    const width = getWidth(stream4, defaultWidth);
+    const { wrapped, lines, wasClipped } = computeFrame(arguments_.join(" "), width);
+    if (lines.length === 0) {
+      previousOutput = wrapped;
+      previousWidth = width;
+      previousLineCount = 0;
+      return;
+    }
+    if (wrapped === previousOutput && previousWidth === width) {
       return;
     }
-    previousOutput = output;
+    if (previousLineCount === 0) {
+      stream4.write(wrapped);
+      previousOutput = wrapped;
+      previousWidth = width;
+      previousLineCount = lines.length;
+      return;
+    }
+    if (previousWidth !== width || wasClipped) {
+      stream4.write(base_exports.eraseLines(previousLineCount) + wrapped);
+      previousOutput = wrapped;
+      previousWidth = width;
+      previousLineCount = lines.length;
+      return;
+    }
+    const previousLines = previousOutput === "" ? [] : previousOutput.split("\n");
+    const { start, endPrevious, endNext } = diffFrames(previousLines, lines);
+    if (start === lines.length && previousLineCount === lines.length) {
+      return;
+    }
+    if (start === 0) {
+      stream4.write(base_exports.eraseLines(previousLineCount) + wrapped);
+      previousOutput = wrapped;
+      previousWidth = width;
+      previousLineCount = lines.length;
+      return;
+    }
+    const patch = buildPatch({
+      prevCount: previousLineCount,
+      start,
+      endPrevious,
+      endNext,
+      nextLines: lines,
+      nextWrappedEndsWithNewline: wrapped.endsWith("\n")
+    });
+    stream4.write(patch);
+    previousOutput = wrapped;
     previousWidth = width;
-    output = wrapAnsi2(output, width, { trim: false, hard: true, wordWrap: false });
-    stream4.write(base_exports.eraseLines(previousLineCount) + output);
-    previousLineCount = output.split("\n").length;
+    previousLineCount = lines.length;
   };
   render.clear = () => {
     stream4.write(base_exports.eraseLines(previousLineCount));
@@ -60648,9 +62303,20 @@ function createLogUpdate(stream4, { showCursor = false } = {}) {
       cli_cursor_default.show();
     }
   };
+  render.persist = (...arguments_) => {
+    if (previousLineCount > 0) {
+      stream4.write(base_exports.eraseLines(previousLineCount));
+      previousLineCount = 0;
+    }
+    const text = `${arguments_.join(" ")}`;
+    const width = getWidth(stream4, defaultWidth);
+    const { wrapped: wrappedText } = computeFrame(text, width);
+    stream4.write(wrappedText);
+    reset2();
+  };
   return render;
 }
-var import_node_process5, defaultTerminalHeight, getWidth, fitToTerminalHeight, logUpdate, log_update_default, logUpdateStderr;
+var import_node_process5, getWidth, fitToTerminalHeight, diffFrames, buildPatch, logUpdate, log_update_default, logUpdateStderr;
 var init_log_update = __esm({
   "node_modules/log-update/index.js"() {
     import_node_process5 = __toESM(require("node:process"), 1);
@@ -60659,13 +62325,91 @@ var init_log_update = __esm({
     init_wrap_ansi();
     init_slice_ansi();
     init_strip_ansi();
-    defaultTerminalHeight = 24;
-    getWidth = ({ columns = 80 }) => columns;
-    fitToTerminalHeight = (stream4, text) => {
-      const terminalHeight = stream4.rows ?? defaultTerminalHeight;
-      const lines = text.split("\n");
-      const toRemove = Math.max(0, lines.length - terminalHeight);
-      return toRemove ? sliceAnsi(text, stripAnsi2(lines.slice(0, toRemove).join("\n")).length + 1) : text;
+    getWidth = (stream4, defaultWidth) => stream4.columns ?? defaultWidth ?? 80;
+    fitToTerminalHeight = (stream4, wrappedText, defaultHeight) => {
+      const terminalHeight = stream4.rows ?? defaultHeight ?? 24;
+      if (terminalHeight === void 0) {
+        return { text: wrappedText, wasClipped: false };
+      }
+      if (terminalHeight === 0) {
+        return { text: "", wasClipped: wrappedText !== "" };
+      }
+      const unstyled = stripAnsi2(wrappedText);
+      const newlineCount = [...unstyled].filter((character) => character === "\n").length;
+      const linesCount = newlineCount + 1;
+      const toRemove = Math.max(0, linesCount - terminalHeight);
+      if (toRemove === 0) {
+        return { text: wrappedText, wasClipped: false };
+      }
+      let seen = 0;
+      let cut = 0;
+      for (const [index, character] of [...unstyled].entries()) {
+        if (character === "\n") {
+          seen++;
+          if (seen === toRemove) {
+            cut = index + 1;
+            break;
+          }
+        }
+      }
+      return { text: sliceAnsi(wrappedText, cut), wasClipped: true };
+    };
+    diffFrames = (previousLines, nextLines) => {
+      let start = 0;
+      for (; start < previousLines.length && start < nextLines.length; start++) {
+        if (previousLines[start] !== nextLines[start]) {
+          break;
+        }
+      }
+      let endPrevious = previousLines.length - 1;
+      let endNext = nextLines.length - 1;
+      while (endPrevious >= start && endNext >= start && previousLines[endPrevious] === nextLines[endNext]) {
+        endPrevious--;
+        endNext--;
+      }
+      return { start, endPrevious, endNext };
+    };
+    buildPatch = ({
+      prevCount,
+      start,
+      endPrevious,
+      endNext,
+      nextLines,
+      nextWrappedEndsWithNewline
+    }) => {
+      let sequence = "";
+      const upCount = Math.max(0, prevCount - 1 - start);
+      if (upCount > 0) {
+        sequence += base_exports.cursorUp(upCount);
+      }
+      sequence += base_exports.cursorLeft;
+      const linesToClear = Math.max(0, endPrevious - start + 1);
+      for (let index = 0; index < linesToClear; index++) {
+        sequence += base_exports.eraseLine;
+        if (index < linesToClear - 1) {
+          sequence += base_exports.cursorDown();
+        }
+      }
+      if (linesToClear > 1) {
+        sequence += base_exports.cursorUp(linesToClear - 1);
+      }
+      sequence += base_exports.cursorLeft;
+      const wroteSlice = nextLines.slice(start, endNext + 1);
+      if (wroteSlice.length > 0) {
+        const chunk = wroteSlice.join("\n");
+        sequence += chunk;
+        sequence += base_exports.eraseEndLine;
+        if (nextWrappedEndsWithNewline && !chunk.endsWith("\n")) {
+          sequence += "\n";
+        }
+      }
+      const currentLine = start + wroteSlice.length;
+      const finalLine = nextLines.length - 1;
+      const downCount = finalLine - currentLine;
+      if (downCount > 0) {
+        sequence += base_exports.cursorDown(downCount);
+      }
+      return sequence;
     };
     logUpdate = createLogUpdate(import_node_process5.default.stdout);
     log_update_default = logUpdate;
@@ -62184,7 +63928,7 @@ var wordPattern = new RegExp(
 
 // packages/kong-ts/src/lib/utils.ts
 function isEmpty(value) {
-  return value === void 0 || value === "";
+  return value === void 0 || value.trim() === "";
 }
 
 // node_modules/json-schema-faker/dist/vendor.js
@@ -68561,9 +70305,9 @@ ${indent2}${str}`;
     }
     var Node2 = class {
     };
-    function toJSON2(value, arg, ctx) {
+    function toJSON(value, arg, ctx) {
       if (Array.isArray(value))
-        return value.map((v, i) => toJSON2(v, String(i), ctx));
+        return value.map((v, i) => toJSON(v, String(i), ctx));
       if (value && typeof value.toJSON === "function") {
         const anchor = ctx && ctx.anchors && ctx.anchors.get(value);
         if (anchor)
@@ -68586,7 +70330,7 @@ ${indent2}${str}`;
         this.value = value;
       }
       toJSON(arg, ctx) {
-        return ctx && ctx.keep ? this.value : toJSON2(this.value, arg, ctx);
+        return ctx && ctx.keep ? this.value : toJSON(this.value, arg, ctx);
       }
       toString() {
         return String(this.value);
@@ -68817,7 +70561,7 @@ ${indent2}${s}` : "\n";
           ctx.onCreate(seq);
         let i = 0;
         for (const item of this.items)
-          seq.push(toJSON2(item, String(i++), ctx));
+          seq.push(toJSON(item, String(i++), ctx));
         return seq;
       }
       toString(ctx, onComment, onChompKeep) {
@@ -68872,15 +70616,15 @@ ${indent2}${s}` : "\n";
         }
       }
       addToJSMap(ctx, map) {
-        const key = toJSON2(this.key, "", ctx);
+        const key = toJSON(this.key, "", ctx);
         if (map instanceof Map) {
-          const value = toJSON2(this.value, key, ctx);
+          const value = toJSON(this.value, key, ctx);
           map.set(key, value);
         } else if (map instanceof Set) {
           map.add(key);
         } else {
           const stringKey = stringifyKey(this.key, key, ctx);
-          const value = toJSON2(this.value, stringKey, ctx);
+          const value = toJSON(this.value, stringKey, ctx);
           if (stringKey in map)
             Object.defineProperty(map, stringKey, {
               value,
@@ -69043,7 +70787,7 @@ ${ctx.indent}`;
       }
       toJSON(arg, ctx) {
         if (!ctx)
-          return toJSON2(this.source, arg, ctx);
+          return toJSON(this.source, arg, ctx);
         const {
           anchors,
           maxAliasCount
@@ -70511,7 +72255,7 @@ ${ca}` : ca;
     exports2.strOptions = strOptions2;
     exports2.stringifyNumber = stringifyNumber;
     exports2.stringifyString = stringifyString;
-    exports2.toJSON = toJSON2;
+    exports2.toJSON = toJSON;
   }
 });
 var require_warnings_1000a372 = __commonJS2({
@@ -75557,6 +77301,9 @@ var globalThisPolyfill = (function() {
   }
 })();
 
+// packages/kong-ts/src/lib/cron.ts
+var import_cronstrue = __toESM(require_cronstrue());
+
 // packages/kong-ts/src/lib/jq.ts
 function jqFilter(value) {
   return value;
@@ -75663,11 +77410,11 @@ function isRecord(value) {
   if (constructor === void 0) {
     return true;
   }
-  const prototype3 = constructor.prototype;
-  if (prototype3 === null || typeof prototype3 !== "object" || !validRecordToStringValues.includes(Object.prototype.toString.call(prototype3))) {
+  const prototype2 = constructor.prototype;
+  if (prototype2 === null || typeof prototype2 !== "object" || !validRecordToStringValues.includes(Object.prototype.toString.call(prototype2))) {
     return false;
   }
-  if (!prototype3.hasOwnProperty("isPrototypeOf")) {
+  if (!prototype2.hasOwnProperty("isPrototypeOf")) {
     return false;
   }
   return true;
@@ -78168,6 +79915,11 @@ var dist_default7 = createPrompt((config, done) => {
 // node_modules/@inquirer/rawlist/dist/index.js
 var import_node_util6 = require("node:util");
 var numberRegex = /\d+/;
+var rawlistTheme = {
+  style: {
+    description: (text) => (0, import_node_util6.styleText)("cyan", text)
+  }
+};
 function isSelectableChoice(choice) {
   return choice != null && !Separator.isSeparator(choice);
 }
@@ -78177,11 +79929,12 @@ function normalizeChoices3(choices) {
     if (Separator.isSeparator(choice))
       return choice;
     index += 1;
-    if (typeof choice === "string") {
+    if (typeof choice !== "object" || choice === null || !("value" in choice)) {
+      const name2 = String(choice);
       return {
         value: choice,
-        name: choice,
-        short: choice,
+        name: name2,
+        short: name2,
         key: String(index)
       };
     }
@@ -78190,7 +79943,8 @@ function normalizeChoices3(choices) {
       value: choice.value,
       name,
       short: choice.short ?? name,
-      key: choice.key ?? String(index)
+      key: choice.key ?? String(index),
+      description: choice.description
     };
   });
 }
@@ -78208,9 +79962,12 @@ var dist_default8 = createPrompt((config, done) => {
   const { loop = true } = config;
   const choices = useMemo(() => normalizeChoices3(config.choices), [config.choices]);
   const [status, setStatus] = useState("idle");
-  const [value, setValue] = useState("");
+  const [value, setValue] = useState(() => {
+    const defaultChoice = config.default == null ? void 0 : choices.find((choice) => isSelectableChoice(choice) && choice.value === config.default);
+    return defaultChoice?.key ?? "";
+  });
   const [errorMsg, setError] = useState();
-  const theme = makeTheme(config.theme);
+  const theme = makeTheme(rawlistTheme, config.theme);
   const prefix = usePrefix({ status, theme });
   const bounds = useMemo(() => {
     const first = choices.findIndex(isSelectableChoice);
@@ -78222,11 +79979,11 @@ var dist_default8 = createPrompt((config, done) => {
   }, [choices]);
   useKeypress((key, rl) => {
     if (isEnterKey(key)) {
-      const [selectedChoice] = getSelectedChoice(value, choices);
-      if (isSelectableChoice(selectedChoice)) {
-        setValue(selectedChoice.short);
+      const [selectedChoice2] = getSelectedChoice(value, choices);
+      if (isSelectableChoice(selectedChoice2)) {
+        setValue(selectedChoice2.short);
         setStatus("done");
-        done(selectedChoice.value);
+        done(selectedChoice2.value);
       } else if (value === "") {
         setError("Please input a value");
       } else {
@@ -78234,8 +79991,8 @@ var dist_default8 = createPrompt((config, done) => {
       }
     } else if (isUpKey(key) || isDownKey(key)) {
       rl.clearLine(0);
-      const [selectedChoice, active] = getSelectedChoice(value, choices);
-      if (!selectedChoice) {
+      const [selectedChoice2, active] = getSelectedChoice(value, choices);
+      if (!selectedChoice2) {
         const firstChoice = isDownKey(key) ? choices.find(isSelectableChoice) : choices.findLast(isSelectableChoice);
         setValue(firstChoice.key);
       } else if (loop || isUpKey(key) && active !== bounds.first || isDownKey(key) && active !== bounds.last) {
@@ -78260,7 +80017,7 @@ var dist_default8 = createPrompt((config, done) => {
       return ` ${choice.separator}`;
     }
     const line = `  ${choice.key}) ${choice.name}`;
-    if (choice.key === value.toLowerCase()) {
+    if (choice.key === value) {
       return theme.style.highlight(line);
     }
     return line;
@@ -78269,9 +80026,14 @@ var dist_default8 = createPrompt((config, done) => {
   if (errorMsg) {
     error = theme.style.error(errorMsg);
   }
+  const [selectedChoice] = getSelectedChoice(value, choices);
+  let description = "";
+  if (!errorMsg && selectedChoice?.description) {
+    description = theme.style.description(selectedChoice.description);
+  }
   return [
     `${prefix} ${message2} ${value}`,
-    [choicesStr, error].filter(Boolean).join("\n")
+    [choicesStr, error, description].filter(Boolean).join("\n")
   ];
 });
 
@@ -78370,6 +80132,7 @@ var dist_default10 = createPrompt((config, done) => {
   const [searchTerm, setSearchTerm] = useState("");
   const [searchResults, setSearchResults] = useState([]);
   const [searchError, setSearchError] = useState();
+  const defaultApplied = useRef(false);
   const prefix = usePrefix({ status, theme });
   const bounds = useMemo(() => {
     const first = searchResults.findIndex(isSelectable2);
@@ -78387,9 +80150,16 @@ var dist_default10 = createPrompt((config, done) => {
           signal: controller.signal
         });
         if (!controller.signal.aborted) {
-          setActive(void 0);
+          const normalized = normalizeChoices4(results);
+          let initialActive;
+          if (!defaultApplied.current && "default" in config) {
+            const defaultIndex = normalized.findIndex((item) => isSelectable2(item) && item.value === config.default);
+            initialActive = defaultIndex === -1 ? void 0 : defaultIndex;
+            defaultApplied.current = true;
+          }
+          setActive(initialActive);
           setSearchError(void 0);
-          setSearchResults(normalizeChoices4(results));
+          setSearchResults(normalized);
           setStatus("idle");
         }
       } catch (error2) {
@@ -78505,11 +80275,12 @@ function normalizeChoices5(choices) {
   return choices.map((choice) => {
     if (Separator.isSeparator(choice))
       return choice;
-    if (typeof choice === "string") {
+    if (typeof choice !== "object" || choice === null || !("value" in choice)) {
+      const name2 = String(choice);
       return {
         value: choice,
-        name: choice,
-        short: choice,
+        name: name2,
+        short: name2,
         disabled: false
       };
     }
@@ -78765,12 +80536,19 @@ var PromptsRunner = class {
         return choiceObj;
       });
     }
-    return Object.assign({}, question, {
+    const wrappedQuestion = Object.assign({}, question, {
       message: message2,
       default: defaultValue,
       choices,
       type: question.type in this.prompts ? question.type : "input"
     });
+    if (question.validate) {
+      const originalValidate = question.validate;
+      wrappedQuestion.validate = (value) => {
+        return originalValidate(value, this.answers);
+      };
+    }
+    return wrappedQuestion;
   };
   fetchAnswer = async (rawQuestion) => {
     const question = await this.prepareQuestion(rawQuestion);
@@ -78955,8 +80733,8 @@ var isPlainObject2 = (val) => {
   if (kindOf(val) !== "object") {
     return false;
   }
-  const prototype3 = getPrototypeOf(val);
-  return (prototype3 === null || prototype3 === Object.prototype || Object.getPrototypeOf(prototype3) === null) && !(toStringTag in val) && !(iterator in val);
+  const prototype2 = getPrototypeOf(val);
+  return (prototype2 === null || prototype2 === Object.prototype || Object.getPrototypeOf(prototype2) === null) && !(toStringTag in val) && !(iterator in val);
 };
 var isEmptyObject = (val) => {
   if (!isObject(val) || isBuffer(val)) {
@@ -78979,7 +80757,12 @@ var isFormData = (thing) => {
   kind === "object" && isFunction2(thing.toString) && thing.toString() === "[object FormData]"));
 };
 var isURLSearchParams = kindOfTest("URLSearchParams");
-var [isReadableStream, isRequest, isResponse, isHeaders] = ["ReadableStream", "Request", "Response", "Headers"].map(kindOfTest);
+var [isReadableStream, isRequest, isResponse, isHeaders] = [
+  "ReadableStream",
+  "Request",
+  "Response",
+  "Headers"
+].map(kindOfTest);
 var trim2 = (str) => str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
 function forEach(obj, fn, { allOwnKeys = false } = {}) {
   if (obj === null || typeof obj === "undefined") {
@@ -79032,6 +80815,9 @@ function merge2() {
   const { caseless, skipUndefined } = isContextDefined(this) && this || {};
   const result = {};
   const assignValue = (val, key) => {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      return;
+    }
     const targetKey = caseless && findKey2(result, key) || key;
     if (isPlainObject2(result[targetKey]) && isPlainObject2(val)) {
       result[targetKey] = merge2(result[targetKey], val);
@@ -79049,13 +80835,27 @@ function merge2() {
   return result;
 }
 var extend = (a, b, thisArg, { allOwnKeys } = {}) => {
-  forEach(b, (val, key) => {
-    if (thisArg && isFunction2(val)) {
-      a[key] = bind(val, thisArg);
-    } else {
-      a[key] = val;
-    }
-  }, { allOwnKeys });
+  forEach(
+    b,
+    (val, key) => {
+      if (thisArg && isFunction2(val)) {
+        Object.defineProperty(a, key, {
+          value: bind(val, thisArg),
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      } else {
+        Object.defineProperty(a, key, {
+          value: val,
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      }
+    },
+    { allOwnKeys }
+  );
   return a;
 };
 var stripBOM = (content) => {
@@ -79064,9 +80864,17 @@ var stripBOM = (content) => {
   }
   return content;
 };
-var inherits = (constructor, superConstructor, props, descriptors2) => {
-  constructor.prototype = Object.create(superConstructor.prototype, descriptors2);
-  constructor.prototype.constructor = constructor;
+var inherits = (constructor, superConstructor, props, descriptors) => {
+  constructor.prototype = Object.create(
+    superConstructor.prototype,
+    descriptors
+  );
+  Object.defineProperty(constructor.prototype, "constructor", {
+    value: constructor,
+    writable: true,
+    enumerable: false,
+    configurable: true
+  });
   Object.defineProperty(constructor, "super", {
     value: superConstructor.prototype
   });
@@ -79137,19 +80945,16 @@ var matchAll = (regExp, str) => {
 };
 var isHTMLForm = kindOfTest("HTMLFormElement");
 var toCamelCase = (str) => {
-  return str.toLowerCase().replace(
-    /[-_\s]([a-z\d])(\w*)/g,
-    function replacer(m, p1, p2) {
-      return p1.toUpperCase() + p2;
-    }
-  );
+  return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g, function replacer(m, p1, p2) {
+    return p1.toUpperCase() + p2;
+  });
 };
 var hasOwnProperty = (({ hasOwnProperty: hasOwnProperty2 }) => (obj, prop) => hasOwnProperty2.call(obj, prop))(Object.prototype);
 var isRegExp = kindOfTest("RegExp");
 var reduceDescriptors = (obj, reducer) => {
-  const descriptors2 = Object.getOwnPropertyDescriptors(obj);
+  const descriptors = Object.getOwnPropertyDescriptors(obj);
   const reducedDescriptors = {};
-  forEach(descriptors2, (descriptor, name) => {
+  forEach(descriptors, (descriptor, name) => {
     let ret;
     if ((ret = reducer(descriptor, name, obj)) !== false) {
       reducedDescriptors[name] = ret || descriptor;
@@ -79226,20 +81031,21 @@ var _setImmediate = ((setImmediateSupported, postMessageSupported) => {
     return setImmediate;
   }
   return postMessageSupported ? ((token, callbacks) => {
-    _global.addEventListener("message", ({ source, data }) => {
-      if (source === _global && data === token) {
-        callbacks.length && callbacks.shift()();
-      }
-    }, false);
+    _global.addEventListener(
+      "message",
+      ({ source, data }) => {
+        if (source === _global && data === token) {
+          callbacks.length && callbacks.shift()();
+        }
+      },
+      false
+    );
     return (cb) => {
       callbacks.push(cb);
       _global.postMessage(token, "*");
     };
   })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
-})(
-  typeof setImmediate === "function",
-  isFunction2(_global.postMessage)
-);
+})(typeof setImmediate === "function", isFunction2(_global.postMessage));
 var asap = typeof queueMicrotask !== "undefined" ? queueMicrotask.bind(_global) : typeof process !== "undefined" && process.nextTick || _setImmediate;
 var isIterable = (thing) => thing != null && isFunction2(thing[iterator]);
 var utils_default2 = {
@@ -79304,25 +81110,38 @@ var utils_default2 = {
 };
 
 // node_modules/axios/lib/core/AxiosError.js
-function AxiosError(message2, code, config, request, response) {
-  Error.call(this);
-  if (Error.captureStackTrace) {
-    Error.captureStackTrace(this, this.constructor);
-  } else {
-    this.stack = new Error().stack;
+var AxiosError = class _AxiosError extends Error {
+  static from(error, code, config, request, response, customProps) {
+    const axiosError = new _AxiosError(error.message, code || error.code, config, request, response);
+    axiosError.cause = error;
+    axiosError.name = error.name;
+    customProps && Object.assign(axiosError, customProps);
+    return axiosError;
   }
-  this.message = message2;
-  this.name = "AxiosError";
-  code && (this.code = code);
-  config && (this.config = config);
-  request && (this.request = request);
-  if (response) {
-    this.response = response;
-    this.status = response.status ? response.status : null;
-  }
-}
-utils_default2.inherits(AxiosError, Error, {
-  toJSON: function toJSON() {
+  /**
+   * Create an Error with the specified message, config, error code, request and response.
+   *
+   * @param {string} message The error message.
+   * @param {string} [code] The error code (for example, 'ECONNABORTED').
+   * @param {Object} [config] The config.
+   * @param {Object} [request] The request.
+   * @param {Object} [response] The response.
+   *
+   * @returns {Error} The created error.
+   */
+  constructor(message2, code, config, request, response) {
+    super(message2);
+    this.name = "AxiosError";
+    this.isAxiosError = true;
+    code && (this.code = code);
+    config && (this.config = config);
+    request && (this.request = request);
+    if (response) {
+      this.response = response;
+      this.status = response.status;
+    }
+  }
+  toJSON() {
     return {
       // Standard
       message: this.message,
@@ -79341,45 +81160,19 @@ utils_default2.inherits(AxiosError, Error, {
       status: this.status
     };
   }
-});
-var prototype = AxiosError.prototype;
-var descriptors = {};
-[
-  "ERR_BAD_OPTION_VALUE",
-  "ERR_BAD_OPTION",
-  "ECONNABORTED",
-  "ETIMEDOUT",
-  "ERR_NETWORK",
-  "ERR_FR_TOO_MANY_REDIRECTS",
-  "ERR_DEPRECATED",
-  "ERR_BAD_RESPONSE",
-  "ERR_BAD_REQUEST",
-  "ERR_CANCELED",
-  "ERR_NOT_SUPPORT",
-  "ERR_INVALID_URL"
-  // eslint-disable-next-line func-names
-].forEach((code) => {
-  descriptors[code] = { value: code };
-});
-Object.defineProperties(AxiosError, descriptors);
-Object.defineProperty(prototype, "isAxiosError", { value: true });
-AxiosError.from = (error, code, config, request, response, customProps) => {
-  const axiosError = Object.create(prototype);
-  utils_default2.toFlatObject(error, axiosError, function filter3(obj) {
-    return obj !== Error.prototype;
-  }, (prop) => {
-    return prop !== "isAxiosError";
-  });
-  const msg = error && error.message ? error.message : "Error";
-  const errCode = code == null && error ? error.code : code;
-  AxiosError.call(axiosError, msg, errCode, config, request, response);
-  if (error && axiosError.cause == null) {
-    Object.defineProperty(axiosError, "cause", { value: error, configurable: true });
-  }
-  axiosError.name = error && error.name || "Error";
-  customProps && Object.assign(axiosError, customProps);
-  return axiosError;
 };
+AxiosError.ERR_BAD_OPTION_VALUE = "ERR_BAD_OPTION_VALUE";
+AxiosError.ERR_BAD_OPTION = "ERR_BAD_OPTION";
+AxiosError.ECONNABORTED = "ECONNABORTED";
+AxiosError.ETIMEDOUT = "ETIMEDOUT";
+AxiosError.ERR_NETWORK = "ERR_NETWORK";
+AxiosError.ERR_FR_TOO_MANY_REDIRECTS = "ERR_FR_TOO_MANY_REDIRECTS";
+AxiosError.ERR_DEPRECATED = "ERR_DEPRECATED";
+AxiosError.ERR_BAD_RESPONSE = "ERR_BAD_RESPONSE";
+AxiosError.ERR_BAD_REQUEST = "ERR_BAD_REQUEST";
+AxiosError.ERR_CANCELED = "ERR_CANCELED";
+AxiosError.ERR_NOT_SUPPORT = "ERR_NOT_SUPPORT";
+AxiosError.ERR_INVALID_URL = "ERR_INVALID_URL";
 var AxiosError_default = AxiosError;
 
 // node_modules/axios/lib/platform/node/classes/FormData.js
@@ -79520,11 +81313,11 @@ function AxiosURLSearchParams(params, options) {
   this._pairs = [];
   params && toFormData_default(params, this, options);
 }
-var prototype2 = AxiosURLSearchParams.prototype;
-prototype2.append = function append(name, value) {
+var prototype = AxiosURLSearchParams.prototype;
+prototype.append = function append(name, value) {
   this._pairs.push([name, value]);
 };
-prototype2.toString = function toString2(encoder) {
+prototype.toString = function toString2(encoder) {
   const _encode = encoder ? function(value) {
     return encoder.call(this, value, encode);
   } : encode;
@@ -79543,17 +81336,15 @@ function buildURL(url2, params, options) {
     return url2;
   }
   const _encode = options && options.encode || encode2;
-  if (utils_default2.isFunction(options)) {
-    options = {
-      serialize: options
-    };
-  }
-  const serializeFn = options && options.serialize;
+  const _options = utils_default2.isFunction(options) ? {
+    serialize: options
+  } : options;
+  const serializeFn = _options && _options.serialize;
   let serializedParams;
   if (serializeFn) {
-    serializedParams = serializeFn(params, options);
+    serializedParams = serializeFn(params, _options);
   } else {
-    serializedParams = utils_default2.isURLSearchParams(params) ? params.toString() : new AxiosURLSearchParams_default(params, options).toString(_encode);
+    serializedParams = utils_default2.isURLSearchParams(params) ? params.toString() : new AxiosURLSearchParams_default(params, _options).toString(_encode);
   }
   if (serializedParams) {
     const hashmarkIndex = url2.indexOf("#");
@@ -79575,6 +81366,7 @@ var InterceptorManager = class {
    *
    * @param {Function} fulfilled The function to handle `then` for a `Promise`
    * @param {Function} rejected The function to handle `reject` for a `Promise`
+   * @param {Object} options The options for the interceptor, synchronous and runWhen
    *
    * @return {Number} An ID used to remove interceptor later
    */
@@ -79633,7 +81425,8 @@ var InterceptorManager_default = InterceptorManager;
 var transitional_default = {
   silentJSONParsing: true,
   forcedJSONParsing: true,
-  clarifyTimeoutError: false
+  clarifyTimeoutError: false,
+  legacyInterceptorReqResOrdering: true
 };
 
 // node_modules/axios/lib/platform/node/index.js
@@ -80122,11 +81915,11 @@ var AxiosHeaders = class {
       accessors: {}
     };
     const accessors = internals.accessors;
-    const prototype3 = this.prototype;
+    const prototype2 = this.prototype;
     function defineAccessor(_header) {
       const lHeader = normalizeHeader(_header);
       if (!accessors[lHeader]) {
-        buildAccessors(prototype3, _header);
+        buildAccessors(prototype2, _header);
         accessors[lHeader] = true;
       }
     }
@@ -80166,13 +81959,22 @@ function isCancel(value) {
 }
 
 // node_modules/axios/lib/cancel/CanceledError.js
-function CanceledError(message2, config, request) {
-  AxiosError_default.call(this, message2 == null ? "canceled" : message2, AxiosError_default.ERR_CANCELED, config, request);
-  this.name = "CanceledError";
-}
-utils_default2.inherits(CanceledError, AxiosError_default, {
-  __CANCEL__: true
-});
+var CanceledError = class extends AxiosError_default {
+  /**
+   * A `CanceledError` is an object that is thrown when an operation is canceled.
+   *
+   * @param {string=} message The message.
+   * @param {Object=} config The config.
+   * @param {Object=} request The request.
+   *
+   * @returns {CanceledError} The created error.
+   */
+  constructor(message2, config, request) {
+    super(message2 == null ? "canceled" : message2, AxiosError_default.ERR_CANCELED, config, request);
+    this.name = "CanceledError";
+    this.__CANCEL__ = true;
+  }
+};
 var CanceledError_default = CanceledError;
 
 // node_modules/axios/lib/core/settle.js
@@ -80193,6 +81995,9 @@ function settle(resolve2, reject, response) {
 
 // node_modules/axios/lib/helpers/isAbsoluteURL.js
 function isAbsoluteURL(url2) {
+  if (typeof url2 !== "string") {
+    return false;
+  }
   return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url2);
 }
 
@@ -80220,7 +82025,7 @@ var import_follow_redirects = __toESM(require_follow_redirects(), 1);
 var import_zlib = __toESM(require("zlib"), 1);
 
 // node_modules/axios/lib/env/data.js
-var VERSION = "1.13.2";
+var VERSION = "1.13.5";
 
 // node_modules/axios/lib/helpers/parseProtocol.js
 function parseProtocol(url2) {
@@ -80780,8 +82585,11 @@ function setProxy(options, configProxy, location2) {
       proxy2.auth = (proxy2.username || "") + ":" + (proxy2.password || "");
     }
     if (proxy2.auth) {
-      if (proxy2.auth.username || proxy2.auth.password) {
+      const validProxyAuth = Boolean(proxy2.auth.username || proxy2.auth.password);
+      if (validProxyAuth) {
         proxy2.auth = (proxy2.auth.username || "") + ":" + (proxy2.auth.password || "");
+      } else if (typeof proxy2.auth === "object") {
+        throw new AxiosError_default("Invalid proxy authorization", AxiosError_default.ERR_BAD_OPTION, { proxy: proxy2 });
       }
       const base64 = Buffer.from(proxy2.auth, "utf8").toString("base64");
       options.headers["Proxy-Authorization"] = "Basic " + base64;
@@ -80833,7 +82641,7 @@ var resolveFamily = ({ address, family }) => {
 var buildAddressEntry = (address, family) => resolveFamily(utils_default2.isObject(address) ? address : { address, family });
 var http2Transport = {
   request(options, cb) {
-    const authority = options.protocol + "//" + options.hostname + ":" + (options.port || 80);
+    const authority = options.protocol + "//" + options.hostname + ":" + (options.port || (options.protocol === "https:" ? 443 : 80));
     const { http2Options, headers } = options;
     const session = http2Sessions.getSession(authority, http2Options);
     const {
@@ -81439,11 +83247,16 @@ function mergeConfig(config1, config2) {
     validateStatus: mergeDirectKeys,
     headers: (a, b, prop) => mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true)
   };
-  utils_default2.forEach(Object.keys({ ...config1, ...config2 }), function computeConfigValue(prop) {
-    const merge3 = mergeMap[prop] || mergeDeepProperties;
-    const configValue = merge3(config1[prop], config2[prop], prop);
-    utils_default2.isUndefined(configValue) && merge3 !== mergeDirectKeys || (config[prop] = configValue);
-  });
+  utils_default2.forEach(
+    Object.keys({ ...config1, ...config2 }),
+    function computeConfigValue(prop) {
+      if (prop === "__proto__" || prop === "constructor" || prop === "prototype")
+        return;
+      const merge3 = utils_default2.hasOwnProp(mergeMap, prop) ? mergeMap[prop] : mergeDeepProperties;
+      const configValue = merge3(config1[prop], config2[prop], prop);
+      utils_default2.isUndefined(configValue) && merge3 !== mergeDirectKeys || (config[prop] = configValue);
+    }
+  );
   return config;
 }
 
@@ -81630,7 +83443,7 @@ var composeSignals = (signals3, timeout) => {
     };
     let timer = timeout && setTimeout(() => {
       timer = null;
-      onabort(new AxiosError_default(`timeout ${timeout} of ms exceeded`, AxiosError_default.ETIMEDOUT));
+      onabort(new AxiosError_default(`timeout of ${timeout}ms exceeded`, AxiosError_default.ETIMEDOUT));
     }, timeout);
     const unsubscribe = () => {
       if (signals3) {
@@ -81906,13 +83719,13 @@ var factory = (env2) => {
       unsubscribe && unsubscribe();
       if (err && err.name === "TypeError" && /Load failed|fetch/i.test(err.message)) {
         throw Object.assign(
-          new AxiosError_default("Network Error", AxiosError_default.ERR_NETWORK, config, request),
+          new AxiosError_default("Network Error", AxiosError_default.ERR_NETWORK, config, request, err && err.response),
           {
             cause: err.cause || err
           }
         );
       }
-      throw AxiosError_default.from(err, err && err.code, config, request);
+      throw AxiosError_default.from(err, err && err.code, config, request, err && err.response);
     }
   };
 };
@@ -82161,7 +83974,8 @@ var Axios = class {
       validator_default.assertOptions(transitional2, {
         silentJSONParsing: validators2.transitional(validators2.boolean),
         forcedJSONParsing: validators2.transitional(validators2.boolean),
-        clarifyTimeoutError: validators2.transitional(validators2.boolean)
+        clarifyTimeoutError: validators2.transitional(validators2.boolean),
+        legacyInterceptorReqResOrdering: validators2.transitional(validators2.boolean)
       }, false);
     }
     if (paramsSerializer != null) {
@@ -82205,7 +84019,13 @@ var Axios = class {
         return;
       }
       synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
-      requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+      const transitional3 = config.transitional || transitional_default;
+      const legacyInterceptorReqResOrdering = transitional3 && transitional3.legacyInterceptorReqResOrdering;
+      if (legacyInterceptorReqResOrdering) {
+        requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+      } else {
+        requestInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
+      }
     });
     const responseInterceptorChain = [];
     this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
@@ -83776,7 +85596,7 @@ var {
   bgWhiteBright
 } = createColors();
 
-// node_modules/listr2/dist/index.js
+// node_modules/listr2/dist/index.mjs
 var import_util3 = require("util");
 var import_os2 = require("os");
 var import_string_decoder = require("string_decoder");
@@ -83788,56 +85608,56 @@ var ANSI_ESCAPE_CODES = {
   CURSOR_HIDE: ANSI_ESCAPE + "?25l",
   CURSOR_SHOW: ANSI_ESCAPE + "?25h"
 };
-var ListrEnvironmentVariables = /* @__PURE__ */ (function(ListrEnvironmentVariables$1) {
-  ListrEnvironmentVariables$1["FORCE_UNICODE"] = "LISTR_FORCE_UNICODE";
-  ListrEnvironmentVariables$1["FORCE_TTY"] = "LISTR_FORCE_TTY";
-  ListrEnvironmentVariables$1["DISABLE_COLOR"] = "NO_COLOR";
-  ListrEnvironmentVariables$1["FORCE_COLOR"] = "FORCE_COLOR";
-  return ListrEnvironmentVariables$1;
+var ListrEnvironmentVariables = /* @__PURE__ */ (function(ListrEnvironmentVariables2) {
+  ListrEnvironmentVariables2["FORCE_UNICODE"] = "LISTR_FORCE_UNICODE";
+  ListrEnvironmentVariables2["FORCE_TTY"] = "LISTR_FORCE_TTY";
+  ListrEnvironmentVariables2["DISABLE_COLOR"] = "NO_COLOR";
+  ListrEnvironmentVariables2["FORCE_COLOR"] = "FORCE_COLOR";
+  return ListrEnvironmentVariables2;
 })({});
-var ListrErrorTypes = /* @__PURE__ */ (function(ListrErrorTypes$1) {
-  ListrErrorTypes$1["WILL_RETRY"] = "WILL_RETRY";
-  ListrErrorTypes$1["WILL_ROLLBACK"] = "WILL_ROLLBACK";
-  ListrErrorTypes$1["HAS_FAILED_TO_ROLLBACK"] = "HAS_FAILED_TO_ROLLBACK";
-  ListrErrorTypes$1["HAS_FAILED"] = "HAS_FAILED";
-  ListrErrorTypes$1["HAS_FAILED_WITHOUT_ERROR"] = "HAS_FAILED_WITHOUT_ERROR";
-  return ListrErrorTypes$1;
+var ListrErrorTypes = /* @__PURE__ */ (function(ListrErrorTypes2) {
+  ListrErrorTypes2["WILL_RETRY"] = "WILL_RETRY";
+  ListrErrorTypes2["WILL_ROLLBACK"] = "WILL_ROLLBACK";
+  ListrErrorTypes2["HAS_FAILED_TO_ROLLBACK"] = "HAS_FAILED_TO_ROLLBACK";
+  ListrErrorTypes2["HAS_FAILED"] = "HAS_FAILED";
+  ListrErrorTypes2["HAS_FAILED_WITHOUT_ERROR"] = "HAS_FAILED_WITHOUT_ERROR";
+  return ListrErrorTypes2;
 })({});
-var ListrEventType = /* @__PURE__ */ (function(ListrEventType$1) {
-  ListrEventType$1["SHOULD_REFRESH_RENDER"] = "SHOUD_REFRESH_RENDER";
-  return ListrEventType$1;
+var ListrEventType = /* @__PURE__ */ (function(ListrEventType2) {
+  ListrEventType2["SHOULD_REFRESH_RENDER"] = "SHOUD_REFRESH_RENDER";
+  return ListrEventType2;
 })({});
-var ListrRendererSelection = /* @__PURE__ */ (function(ListrRendererSelection$1) {
-  ListrRendererSelection$1["PRIMARY"] = "PRIMARY";
-  ListrRendererSelection$1["SECONDARY"] = "SECONDARY";
-  ListrRendererSelection$1["SILENT"] = "SILENT";
-  return ListrRendererSelection$1;
+var ListrRendererSelection = /* @__PURE__ */ (function(ListrRendererSelection2) {
+  ListrRendererSelection2["PRIMARY"] = "PRIMARY";
+  ListrRendererSelection2["SECONDARY"] = "SECONDARY";
+  ListrRendererSelection2["SILENT"] = "SILENT";
+  return ListrRendererSelection2;
 })({});
-var ListrTaskEventType = /* @__PURE__ */ (function(ListrTaskEventType$1) {
-  ListrTaskEventType$1["TITLE"] = "TITLE";
-  ListrTaskEventType$1["STATE"] = "STATE";
-  ListrTaskEventType$1["ENABLED"] = "ENABLED";
-  ListrTaskEventType$1["SUBTASK"] = "SUBTASK";
-  ListrTaskEventType$1["PROMPT"] = "PROMPT";
-  ListrTaskEventType$1["OUTPUT"] = "OUTPUT";
-  ListrTaskEventType$1["MESSAGE"] = "MESSAGE";
-  ListrTaskEventType$1["CLOSED"] = "CLOSED";
-  return ListrTaskEventType$1;
+var ListrTaskEventType = /* @__PURE__ */ (function(ListrTaskEventType2) {
+  ListrTaskEventType2["TITLE"] = "TITLE";
+  ListrTaskEventType2["STATE"] = "STATE";
+  ListrTaskEventType2["ENABLED"] = "ENABLED";
+  ListrTaskEventType2["SUBTASK"] = "SUBTASK";
+  ListrTaskEventType2["PROMPT"] = "PROMPT";
+  ListrTaskEventType2["OUTPUT"] = "OUTPUT";
+  ListrTaskEventType2["MESSAGE"] = "MESSAGE";
+  ListrTaskEventType2["CLOSED"] = "CLOSED";
+  return ListrTaskEventType2;
 })({});
-var ListrTaskState = /* @__PURE__ */ (function(ListrTaskState$1) {
-  ListrTaskState$1["WAITING"] = "WAITING";
-  ListrTaskState$1["STARTED"] = "STARTED";
-  ListrTaskState$1["COMPLETED"] = "COMPLETED";
-  ListrTaskState$1["FAILED"] = "FAILED";
-  ListrTaskState$1["SKIPPED"] = "SKIPPED";
-  ListrTaskState$1["ROLLING_BACK"] = "ROLLING_BACK";
-  ListrTaskState$1["ROLLED_BACK"] = "ROLLED_BACK";
-  ListrTaskState$1["RETRY"] = "RETRY";
-  ListrTaskState$1["PAUSED"] = "PAUSED";
-  ListrTaskState$1["PROMPT"] = "PROMPT";
-  ListrTaskState$1["PROMPT_COMPLETED"] = "PROMPT_COMPLETED";
-  ListrTaskState$1["PROMPT_FAILED"] = "PROMPT_FAILED";
-  return ListrTaskState$1;
+var ListrTaskState = /* @__PURE__ */ (function(ListrTaskState2) {
+  ListrTaskState2["WAITING"] = "WAITING";
+  ListrTaskState2["STARTED"] = "STARTED";
+  ListrTaskState2["COMPLETED"] = "COMPLETED";
+  ListrTaskState2["FAILED"] = "FAILED";
+  ListrTaskState2["SKIPPED"] = "SKIPPED";
+  ListrTaskState2["ROLLING_BACK"] = "ROLLING_BACK";
+  ListrTaskState2["ROLLED_BACK"] = "ROLLED_BACK";
+  ListrTaskState2["RETRY"] = "RETRY";
+  ListrTaskState2["PAUSED"] = "PAUSED";
+  ListrTaskState2["PROMPT"] = "PROMPT";
+  ListrTaskState2["PROMPT_COMPLETED"] = "PROMPT_COMPLETED";
+  ListrTaskState2["PROMPT_FAILED"] = "PROMPT_FAILED";
+  return ListrTaskState2;
 })({});
 var EventManager = class {
   emitter = new eventemitter3_default();
@@ -83897,21 +85717,21 @@ var FIGURES_FALLBACK = {
   squareSmallFilled: "\u25A0"
 };
 var figures2 = isUnicodeSupported2() ? FIGURES_MAIN : FIGURES_FALLBACK;
-function splat(message2, ...splat$1) {
-  return (0, import_util3.format)(String(message2), ...splat$1);
+function splat(message2, ...splat2) {
+  return (0, import_util3.format)(String(message2), ...splat2);
 }
-var ListrLogLevels = /* @__PURE__ */ (function(ListrLogLevels$1) {
-  ListrLogLevels$1["STARTED"] = "STARTED";
-  ListrLogLevels$1["COMPLETED"] = "COMPLETED";
-  ListrLogLevels$1["FAILED"] = "FAILED";
-  ListrLogLevels$1["SKIPPED"] = "SKIPPED";
-  ListrLogLevels$1["OUTPUT"] = "OUTPUT";
-  ListrLogLevels$1["TITLE"] = "TITLE";
-  ListrLogLevels$1["ROLLBACK"] = "ROLLBACK";
-  ListrLogLevels$1["RETRY"] = "RETRY";
-  ListrLogLevels$1["PROMPT"] = "PROMPT";
-  ListrLogLevels$1["PAUSED"] = "PAUSED";
-  return ListrLogLevels$1;
+var ListrLogLevels = /* @__PURE__ */ (function(ListrLogLevels2) {
+  ListrLogLevels2["STARTED"] = "STARTED";
+  ListrLogLevels2["COMPLETED"] = "COMPLETED";
+  ListrLogLevels2["FAILED"] = "FAILED";
+  ListrLogLevels2["SKIPPED"] = "SKIPPED";
+  ListrLogLevels2["OUTPUT"] = "OUTPUT";
+  ListrLogLevels2["TITLE"] = "TITLE";
+  ListrLogLevels2["ROLLBACK"] = "ROLLBACK";
+  ListrLogLevels2["RETRY"] = "RETRY";
+  ListrLogLevels2["PROMPT"] = "PROMPT";
+  ListrLogLevels2["PAUSED"] = "PAUSED";
+  return ListrLogLevels2;
 })({});
 var LISTR_LOGGER_STYLE = {
   icon: {
@@ -84126,7 +85946,7 @@ var ProcessOutput = class {
     const output = Object.entries(this.stream).map(([name, stream4]) => ({
       name,
       buffer: stream4.release()
-    })).filter((output$1) => this.options.dump.includes(output$1.name)).flatMap((output$1) => output$1.buffer).sort((a, b) => a.time - b.time).map((message2) => {
+    })).filter((output2) => this.options.dump.includes(output2.name)).flatMap((output2) => output2.buffer).sort((a, b) => a.time - b.time).map((message2) => {
       return {
         ...message2,
         entry: cleanseAnsi(message2.entry)
@@ -84197,25 +86017,26 @@ var Spinner = class {
   }
   stop() {
     clearInterval(this.id);
+    this.id = void 0;
   }
 };
-var ListrDefaultRendererLogLevels = /* @__PURE__ */ (function(ListrDefaultRendererLogLevels$1) {
-  ListrDefaultRendererLogLevels$1["SKIPPED_WITH_COLLAPSE"] = "SKIPPED_WITH_COLLAPSE";
-  ListrDefaultRendererLogLevels$1["SKIPPED_WITHOUT_COLLAPSE"] = "SKIPPED_WITHOUT_COLLAPSE";
-  ListrDefaultRendererLogLevels$1["OUTPUT"] = "OUTPUT";
-  ListrDefaultRendererLogLevels$1["OUTPUT_WITH_BOTTOMBAR"] = "OUTPUT_WITH_BOTTOMBAR";
-  ListrDefaultRendererLogLevels$1["PENDING"] = "PENDING";
-  ListrDefaultRendererLogLevels$1["COMPLETED"] = "COMPLETED";
-  ListrDefaultRendererLogLevels$1["COMPLETED_WITH_FAILED_SUBTASKS"] = "COMPLETED_WITH_FAILED_SUBTASKS";
-  ListrDefaultRendererLogLevels$1["COMPLETED_WITH_FAILED_SISTER_TASKS"] = "COMPLETED_WITH_SISTER_TASKS_FAILED";
-  ListrDefaultRendererLogLevels$1["RETRY"] = "RETRY";
-  ListrDefaultRendererLogLevels$1["ROLLING_BACK"] = "ROLLING_BACK";
-  ListrDefaultRendererLogLevels$1["ROLLED_BACK"] = "ROLLED_BACK";
-  ListrDefaultRendererLogLevels$1["FAILED"] = "FAILED";
-  ListrDefaultRendererLogLevels$1["FAILED_WITH_FAILED_SUBTASKS"] = "FAILED_WITH_SUBTASKS";
-  ListrDefaultRendererLogLevels$1["WAITING"] = "WAITING";
-  ListrDefaultRendererLogLevels$1["PAUSED"] = "PAUSED";
-  return ListrDefaultRendererLogLevels$1;
+var ListrDefaultRendererLogLevels = /* @__PURE__ */ (function(ListrDefaultRendererLogLevels2) {
+  ListrDefaultRendererLogLevels2["SKIPPED_WITH_COLLAPSE"] = "SKIPPED_WITH_COLLAPSE";
+  ListrDefaultRendererLogLevels2["SKIPPED_WITHOUT_COLLAPSE"] = "SKIPPED_WITHOUT_COLLAPSE";
+  ListrDefaultRendererLogLevels2["OUTPUT"] = "OUTPUT";
+  ListrDefaultRendererLogLevels2["OUTPUT_WITH_BOTTOMBAR"] = "OUTPUT_WITH_BOTTOMBAR";
+  ListrDefaultRendererLogLevels2["PENDING"] = "PENDING";
+  ListrDefaultRendererLogLevels2["COMPLETED"] = "COMPLETED";
+  ListrDefaultRendererLogLevels2["COMPLETED_WITH_FAILED_SUBTASKS"] = "COMPLETED_WITH_FAILED_SUBTASKS";
+  ListrDefaultRendererLogLevels2["COMPLETED_WITH_FAILED_SISTER_TASKS"] = "COMPLETED_WITH_SISTER_TASKS_FAILED";
+  ListrDefaultRendererLogLevels2["RETRY"] = "RETRY";
+  ListrDefaultRendererLogLevels2["ROLLING_BACK"] = "ROLLING_BACK";
+  ListrDefaultRendererLogLevels2["ROLLED_BACK"] = "ROLLED_BACK";
+  ListrDefaultRendererLogLevels2["FAILED"] = "FAILED";
+  ListrDefaultRendererLogLevels2["FAILED_WITH_FAILED_SUBTASKS"] = "FAILED_WITH_SUBTASKS";
+  ListrDefaultRendererLogLevels2["WAITING"] = "WAITING";
+  ListrDefaultRendererLogLevels2["PAUSED"] = "PAUSED";
+  return ListrDefaultRendererLogLevels2;
 })({});
 var LISTR_DEFAULT_RENDERER_STYLE = {
   icon: {
@@ -84455,7 +86276,7 @@ var DefaultRenderer = class DefaultRenderer2 {
           this.activePrompt = task.id;
         }
       }
-      if (task.hasTitle()) if (!(tasks.some((task$1) => task$1.hasFailed()) && !task.hasFailed() && task.options.exitOnError !== false && !(task.isCompleted() || task.isSkipped()))) if (task.hasFailed() && rendererOptions.collapseErrors) output.push(...this.format(!task.hasSubtasks() && task.message.error && rendererOptions.showErrorMessage ? task.message.error : task.title, this.style(task), level));
+      if (task.hasTitle()) if (!(tasks.some((task2) => task2.hasFailed()) && !task.hasFailed() && task.options.exitOnError !== false && !(task.isCompleted() || task.isSkipped()))) if (task.hasFailed() && rendererOptions.collapseErrors) output.push(...this.format(!task.hasSubtasks() && task.message.error && rendererOptions.showErrorMessage ? task.message.error : task.title, this.style(task), level));
       else if (task.isSkipped() && rendererOptions.collapseSkips) output.push(...this.format(this.logger.suffix(task.message.skip && rendererOptions.showSkipMessage ? task.message.skip : task.title, {
         field: ListrLogLevels.SKIPPED,
         condition: rendererOptions.suffixSkips,
@@ -86299,7 +88120,7 @@ tmp/lib/tmp.js:
    *)
 
 axios/dist/node/axios.cjs:
-  (*! Axios v1.13.2 Copyright (c) 2025 Matt Zabriskie and contributors *)
+  (*! Axios v1.13.5 Copyright (c) 2026 Matt Zabriskie and contributors *)
 
 json-schema-faker/dist/vendor.js:
   (*!