@wix/cli 1.1.72 → 1.1.74

package/build/{chunk-XP2YHRIC.js → chunk-CIEBMSKA.js}

@@ -8,8 +8,9 @@ import {
   init_tslib_es6,
   require_has_flag,
   require_is_ci,
+  require_react,
   require_supports_color
-} from "./chunk-W423UTD3.js";
+} from "./chunk-LXW2RB2I.js";
 import {
   isUnicodeSupported,
   require_cli_spinners,
@@ -31,293 +32,6 @@ import {
   init_esm_shims
 } from "./chunk-PYIAC2GK.js";
 
-// ../../node_modules/react/cjs/react.production.min.js
-var require_react_production_min = __commonJS({
-  "../../node_modules/react/cjs/react.production.min.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    var l = Symbol.for("react.element");
-    var n2 = Symbol.for("react.portal");
-    var p = Symbol.for("react.fragment");
-    var q = Symbol.for("react.strict_mode");
-    var r2 = Symbol.for("react.profiler");
-    var t3 = Symbol.for("react.provider");
-    var u = Symbol.for("react.context");
-    var v = Symbol.for("react.forward_ref");
-    var w = Symbol.for("react.suspense");
-    var x = Symbol.for("react.memo");
-    var y = Symbol.for("react.lazy");
-    var z = Symbol.iterator;
-    function A(a2) {
-      if (null === a2 || "object" !== typeof a2) return null;
-      a2 = z && a2[z] || a2["@@iterator"];
-      return "function" === typeof a2 ? a2 : null;
-    }
-    var B = { isMounted: function() {
-      return false;
-    }, enqueueForceUpdate: function() {
-    }, enqueueReplaceState: function() {
-    }, enqueueSetState: function() {
-    } };
-    var C = Object.assign;
-    var D = {};
-    function E2(a2, b, e2) {
-      this.props = a2;
-      this.context = b;
-      this.refs = D;
-      this.updater = e2 || B;
-    }
-    E2.prototype.isReactComponent = {};
-    E2.prototype.setState = function(a2, b) {
-      if ("object" !== typeof a2 && "function" !== typeof a2 && null != a2) throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
-      this.updater.enqueueSetState(this, a2, b, "setState");
-    };
-    E2.prototype.forceUpdate = function(a2) {
-      this.updater.enqueueForceUpdate(this, a2, "forceUpdate");
-    };
-    function F() {
-    }
-    F.prototype = E2.prototype;
-    function G(a2, b, e2) {
-      this.props = a2;
-      this.context = b;
-      this.refs = D;
-      this.updater = e2 || B;
-    }
-    var H = G.prototype = new F();
-    H.constructor = G;
-    C(H, E2.prototype);
-    H.isPureReactComponent = true;
-    var I = Array.isArray;
-    var J = Object.prototype.hasOwnProperty;
-    var K = { current: null };
-    var L = { key: true, ref: true, __self: true, __source: true };
-    function M(a2, b, e2) {
-      var d, c2 = {}, k = null, h = null;
-      if (null != b) for (d in void 0 !== b.ref && (h = b.ref), void 0 !== b.key && (k = "" + b.key), b) J.call(b, d) && !L.hasOwnProperty(d) && (c2[d] = b[d]);
-      var g = arguments.length - 2;
-      if (1 === g) c2.children = e2;
-      else if (1 < g) {
-        for (var f = Array(g), m = 0; m < g; m++) f[m] = arguments[m + 2];
-        c2.children = f;
-      }
-      if (a2 && a2.defaultProps) for (d in g = a2.defaultProps, g) void 0 === c2[d] && (c2[d] = g[d]);
-      return { $$typeof: l, type: a2, key: k, ref: h, props: c2, _owner: K.current };
-    }
-    function N(a2, b) {
-      return { $$typeof: l, type: a2.type, key: b, ref: a2.ref, props: a2.props, _owner: a2._owner };
-    }
-    function O(a2) {
-      return "object" === typeof a2 && null !== a2 && a2.$$typeof === l;
-    }
-    function escape3(a2) {
-      var b = { "=": "=0", ":": "=2" };
-      return "$" + a2.replace(/[=:]/g, function(a3) {
-        return b[a3];
-      });
-    }
-    var P = /\/+/g;
-    function Q(a2, b) {
-      return "object" === typeof a2 && null !== a2 && null != a2.key ? escape3("" + a2.key) : b.toString(36);
-    }
-    function R(a2, b, e2, d, c2) {
-      var k = typeof a2;
-      if ("undefined" === k || "boolean" === k) a2 = null;
-      var h = false;
-      if (null === a2) h = true;
-      else switch (k) {
-        case "string":
-        case "number":
-          h = true;
-          break;
-        case "object":
-          switch (a2.$$typeof) {
-            case l:
-            case n2:
-              h = true;
-          }
-      }
-      if (h) return h = a2, c2 = c2(h), a2 = "" === d ? "." + Q(h, 0) : d, I(c2) ? (e2 = "", null != a2 && (e2 = a2.replace(P, "$&/") + "/"), R(c2, b, e2, "", function(a3) {
-        return a3;
-      })) : null != c2 && (O(c2) && (c2 = N(c2, e2 + (!c2.key || h && h.key === c2.key ? "" : ("" + c2.key).replace(P, "$&/") + "/") + a2)), b.push(c2)), 1;
-      h = 0;
-      d = "" === d ? "." : d + ":";
-      if (I(a2)) for (var g = 0; g < a2.length; g++) {
-        k = a2[g];
-        var f = d + Q(k, g);
-        h += R(k, b, e2, f, c2);
-      }
-      else if (f = A(a2), "function" === typeof f) for (a2 = f.call(a2), g = 0; !(k = a2.next()).done; ) k = k.value, f = d + Q(k, g++), h += R(k, b, e2, f, c2);
-      else if ("object" === k) throw b = String(a2), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b ? "object with keys {" + Object.keys(a2).join(", ") + "}" : b) + "). If you meant to render a collection of children, use an array instead.");
-      return h;
-    }
-    function S(a2, b, e2) {
-      if (null == a2) return a2;
-      var d = [], c2 = 0;
-      R(a2, d, "", "", function(a3) {
-        return b.call(e2, a3, c2++);
-      });
-      return d;
-    }
-    function T(a2) {
-      if (-1 === a2._status) {
-        var b = a2._result;
-        b = b();
-        b.then(function(b2) {
-          if (0 === a2._status || -1 === a2._status) a2._status = 1, a2._result = b2;
-        }, function(b2) {
-          if (0 === a2._status || -1 === a2._status) a2._status = 2, a2._result = b2;
-        });
-        -1 === a2._status && (a2._status = 0, a2._result = b);
-      }
-      if (1 === a2._status) return a2._result.default;
-      throw a2._result;
-    }
-    var U = { current: null };
-    var V = { transition: null };
-    var W = { ReactCurrentDispatcher: U, ReactCurrentBatchConfig: V, ReactCurrentOwner: K };
-    function X() {
-      throw Error("act(...) is not supported in production builds of React.");
-    }
-    exports.Children = { map: S, forEach: function(a2, b, e2) {
-      S(a2, function() {
-        b.apply(this, arguments);
-      }, e2);
-    }, count: function(a2) {
-      var b = 0;
-      S(a2, function() {
-        b++;
-      });
-      return b;
-    }, toArray: function(a2) {
-      return S(a2, function(a3) {
-        return a3;
-      }) || [];
-    }, only: function(a2) {
-      if (!O(a2)) throw Error("React.Children.only expected to receive a single React element child.");
-      return a2;
-    } };
-    exports.Component = E2;
-    exports.Fragment = p;
-    exports.Profiler = r2;
-    exports.PureComponent = G;
-    exports.StrictMode = q;
-    exports.Suspense = w;
-    exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W;
-    exports.act = X;
-    exports.cloneElement = function(a2, b, e2) {
-      if (null === a2 || void 0 === a2) throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a2 + ".");
-      var d = C({}, a2.props), c2 = a2.key, k = a2.ref, h = a2._owner;
-      if (null != b) {
-        void 0 !== b.ref && (k = b.ref, h = K.current);
-        void 0 !== b.key && (c2 = "" + b.key);
-        if (a2.type && a2.type.defaultProps) var g = a2.type.defaultProps;
-        for (f in b) J.call(b, f) && !L.hasOwnProperty(f) && (d[f] = void 0 === b[f] && void 0 !== g ? g[f] : b[f]);
-      }
-      var f = arguments.length - 2;
-      if (1 === f) d.children = e2;
-      else if (1 < f) {
-        g = Array(f);
-        for (var m = 0; m < f; m++) g[m] = arguments[m + 2];
-        d.children = g;
-      }
-      return { $$typeof: l, type: a2.type, key: c2, ref: k, props: d, _owner: h };
-    };
-    exports.createContext = function(a2) {
-      a2 = { $$typeof: u, _currentValue: a2, _currentValue2: a2, _threadCount: 0, Provider: null, Consumer: null, _defaultValue: null, _globalName: null };
-      a2.Provider = { $$typeof: t3, _context: a2 };
-      return a2.Consumer = a2;
-    };
-    exports.createElement = M;
-    exports.createFactory = function(a2) {
-      var b = M.bind(null, a2);
-      b.type = a2;
-      return b;
-    };
-    exports.createRef = function() {
-      return { current: null };
-    };
-    exports.forwardRef = function(a2) {
-      return { $$typeof: v, render: a2 };
-    };
-    exports.isValidElement = O;
-    exports.lazy = function(a2) {
-      return { $$typeof: y, _payload: { _status: -1, _result: a2 }, _init: T };
-    };
-    exports.memo = function(a2, b) {
-      return { $$typeof: x, type: a2, compare: void 0 === b ? null : b };
-    };
-    exports.startTransition = function(a2) {
-      var b = V.transition;
-      V.transition = {};
-      try {
-        a2();
-      } finally {
-        V.transition = b;
-      }
-    };
-    exports.unstable_act = X;
-    exports.useCallback = function(a2, b) {
-      return U.current.useCallback(a2, b);
-    };
-    exports.useContext = function(a2) {
-      return U.current.useContext(a2);
-    };
-    exports.useDebugValue = function() {
-    };
-    exports.useDeferredValue = function(a2) {
-      return U.current.useDeferredValue(a2);
-    };
-    exports.useEffect = function(a2, b) {
-      return U.current.useEffect(a2, b);
-    };
-    exports.useId = function() {
-      return U.current.useId();
-    };
-    exports.useImperativeHandle = function(a2, b, e2) {
-      return U.current.useImperativeHandle(a2, b, e2);
-    };
-    exports.useInsertionEffect = function(a2, b) {
-      return U.current.useInsertionEffect(a2, b);
-    };
-    exports.useLayoutEffect = function(a2, b) {
-      return U.current.useLayoutEffect(a2, b);
-    };
-    exports.useMemo = function(a2, b) {
-      return U.current.useMemo(a2, b);
-    };
-    exports.useReducer = function(a2, b, e2) {
-      return U.current.useReducer(a2, b, e2);
-    };
-    exports.useRef = function(a2) {
-      return U.current.useRef(a2);
-    };
-    exports.useState = function(a2) {
-      return U.current.useState(a2);
-    };
-    exports.useSyncExternalStore = function(a2, b, e2) {
-      return U.current.useSyncExternalStore(a2, b, e2);
-    };
-    exports.useTransition = function() {
-      return U.current.useTransition();
-    };
-    exports.version = "18.3.1";
-  }
-});
-
-// ../../node_modules/react/index.js
-var require_react = __commonJS({
-  "../../node_modules/react/index.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    if (true) {
-      module.exports = require_react_production_min();
-    } else {
-      module.exports = null;
-    }
-  }
-});
-
 // ../../node_modules/lodash/isObject.js
 var require_isObject = __commonJS({
   "../../node_modules/lodash/isObject.js"(exports, module) {
@@ -702,11 +416,11 @@ var require_signal_exit = __commonJS({
   "../../node_modules/signal-exit/index.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var process12 = global.process;
-    var processOk = function(process13) {
-      return process13 && typeof process13 === "object" && typeof process13.removeListener === "function" && typeof process13.emit === "function" && typeof process13.reallyExit === "function" && typeof process13.listeners === "function" && typeof process13.kill === "function" && typeof process13.pid === "number" && typeof process13.on === "function";
+    var process14 = global.process;
+    var processOk = function(process15) {
+      return process15 && typeof process15 === "object" && typeof process15.removeListener === "function" && typeof process15.emit === "function" && typeof process15.reallyExit === "function" && typeof process15.listeners === "function" && typeof process15.kill === "function" && typeof process15.pid === "number" && typeof process15.on === "function";
     };
-    if (!processOk(process12)) {
+    if (!processOk(process14)) {
       module.exports = function() {
         return function() {
         };
@@ -714,15 +428,15 @@ var require_signal_exit = __commonJS({
     } else {
       assert = __require("assert");
       signals = require_signals();
-      isWin = /^win/i.test(process12.platform);
+      isWin = /^win/i.test(process14.platform);
       EE = __require("events");
       if (typeof EE !== "function") {
         EE = EE.EventEmitter;
       }
-      if (process12.__signal_exit_emitter__) {
-        emitter = process12.__signal_exit_emitter__;
+      if (process14.__signal_exit_emitter__) {
+        emitter = process14.__signal_exit_emitter__;
       } else {
-        emitter = process12.__signal_exit_emitter__ = new EE();
+        emitter = process14.__signal_exit_emitter__ = new EE();
         emitter.count = 0;
         emitter.emitted = {};
       }
@@ -759,12 +473,12 @@ var require_signal_exit = __commonJS({
         loaded = false;
         signals.forEach(function(sig) {
           try {
-            process12.removeListener(sig, sigListeners[sig]);
+            process14.removeListener(sig, sigListeners[sig]);
           } catch (er) {
           }
         });
-        process12.emit = originalProcessEmit;
-        process12.reallyExit = originalProcessReallyExit;
+        process14.emit = originalProcessEmit;
+        process14.reallyExit = originalProcessReallyExit;
         emitter.count -= 1;
       };
       module.exports.unload = unload;
@@ -781,7 +495,7 @@ var require_signal_exit = __commonJS({
           if (!processOk(global.process)) {
             return;
           }
-          var listeners = process12.listeners(sig);
+          var listeners = process14.listeners(sig);
           if (listeners.length === emitter.count) {
             unload();
             emit("exit", null, sig);
@@ -789,7 +503,7 @@ var require_signal_exit = __commonJS({
             if (isWin && sig === "SIGHUP") {
               sig = "SIGINT";
             }
-            process12.kill(process12.pid, sig);
+            process14.kill(process14.pid, sig);
           }
         };
       });
@@ -805,36 +519,36 @@ var require_signal_exit = __commonJS({
         emitter.count += 1;
         signals = signals.filter(function(sig) {
           try {
-            process12.on(sig, sigListeners[sig]);
+            process14.on(sig, sigListeners[sig]);
             return true;
           } catch (er) {
             return false;
           }
         });
-        process12.emit = processEmit;
-        process12.reallyExit = processReallyExit;
+        process14.emit = processEmit;
+        process14.reallyExit = processReallyExit;
       };
       module.exports.load = load;
-      originalProcessReallyExit = process12.reallyExit;
+      originalProcessReallyExit = process14.reallyExit;
       processReallyExit = function processReallyExit2(code) {
         if (!processOk(global.process)) {
           return;
         }
-        process12.exitCode = code || /* istanbul ignore next */
+        process14.exitCode = code || /* istanbul ignore next */
         0;
-        emit("exit", process12.exitCode, null);
-        emit("afterexit", process12.exitCode, null);
-        originalProcessReallyExit.call(process12, process12.exitCode);
+        emit("exit", process14.exitCode, null);
+        emit("afterexit", process14.exitCode, null);
+        originalProcessReallyExit.call(process14, process14.exitCode);
       };
-      originalProcessEmit = process12.emit;
+      originalProcessEmit = process14.emit;
       processEmit = function processEmit2(ev, arg) {
         if (ev === "exit" && processOk(global.process)) {
           if (arg !== void 0) {
-            process12.exitCode = arg;
+            process14.exitCode = arg;
           }
           var ret = originalProcessEmit.apply(this, arguments);
-          emit("exit", process12.exitCode, null);
-          emit("afterexit", process12.exitCode, null);
+          emit("exit", process14.exitCode, null);
+          emit("afterexit", process14.exitCode, null);
           return ret;
         } else {
           return originalProcessEmit.apply(this, arguments);
@@ -6201,7 +5915,7 @@ var require_stack_utils = __commonJS({
   "../../node_modules/stack-utils/index.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var escapeStringRegexp = require_escape_string_regexp();
+    var escapeStringRegexp2 = require_escape_string_regexp();
     var cwd2 = typeof process === "object" && process && typeof process.cwd === "function" ? process.cwd() : ".";
     var natives = [].concat(
       __require("module").builtinModules,
@@ -6354,21 +6068,21 @@ var require_stack_utils = __commonJS({
         return res;
       }
       parseLine(line) {
-        const match4 = line && line.match(re);
-        if (!match4) {
+        const match6 = line && line.match(re);
+        if (!match6) {
           return null;
         }
-        const ctor = match4[1] === "new";
-        let fname = match4[2];
-        const evalOrigin = match4[3];
-        const evalFile = match4[4];
-        const evalLine = Number(match4[5]);
-        const evalCol = Number(match4[6]);
-        let file = match4[7];
-        const lnum = match4[8];
-        const col = match4[9];
-        const native = match4[10] === "native";
-        const closeParen = match4[11] === ")";
+        const ctor = match6[1] === "new";
+        let fname = match6[2];
+        const evalOrigin = match6[3];
+        const evalFile = match6[4];
+        const evalLine = Number(match6[5]);
+        const evalCol = Number(match6[6]);
+        let file = match6[7];
+        const lnum = match6[8];
+        const col = match6[9];
+        const native = match6[10] === "native";
+        const closeParen = match6[11] === ")";
         let method;
         const res = {};
         if (lnum) {
@@ -6439,7 +6153,7 @@ var require_stack_utils = __commonJS({
       if (ignoredPackages.length === 0) {
         return [];
       }
-      const packages = ignoredPackages.map((mod) => escapeStringRegexp(mod));
+      const packages = ignoredPackages.map((mod) => escapeStringRegexp2(mod));
       return new RegExp(`[/\\\\]node_modules[/\\\\](?:${packages.join("|")})[/\\\\][^:]+:\\d+:\\d+`);
     }
     var re = new RegExp(
@@ -6533,6 +6247,725 @@ var require_supports_hyperlinks = __commonJS({
   }
 });
 
+// ../../node_modules/lodash.isequal/index.js
+var require_lodash = __commonJS({
+  "../../node_modules/lodash.isequal/index.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var LARGE_ARRAY_SIZE = 200;
+    var HASH_UNDEFINED = "__lodash_hash_undefined__";
+    var COMPARE_PARTIAL_FLAG = 1;
+    var COMPARE_UNORDERED_FLAG = 2;
+    var MAX_SAFE_INTEGER = 9007199254740991;
+    var argsTag = "[object Arguments]";
+    var arrayTag = "[object Array]";
+    var asyncTag = "[object AsyncFunction]";
+    var boolTag = "[object Boolean]";
+    var dateTag = "[object Date]";
+    var errorTag = "[object Error]";
+    var funcTag = "[object Function]";
+    var genTag = "[object GeneratorFunction]";
+    var mapTag = "[object Map]";
+    var numberTag = "[object Number]";
+    var nullTag = "[object Null]";
+    var objectTag = "[object Object]";
+    var promiseTag = "[object Promise]";
+    var proxyTag = "[object Proxy]";
+    var regexpTag = "[object RegExp]";
+    var setTag = "[object Set]";
+    var stringTag = "[object String]";
+    var symbolTag = "[object Symbol]";
+    var undefinedTag = "[object Undefined]";
+    var weakMapTag = "[object WeakMap]";
+    var arrayBufferTag = "[object ArrayBuffer]";
+    var dataViewTag = "[object DataView]";
+    var float32Tag = "[object Float32Array]";
+    var float64Tag = "[object Float64Array]";
+    var int8Tag = "[object Int8Array]";
+    var int16Tag = "[object Int16Array]";
+    var int32Tag = "[object Int32Array]";
+    var uint8Tag = "[object Uint8Array]";
+    var uint8ClampedTag = "[object Uint8ClampedArray]";
+    var uint16Tag = "[object Uint16Array]";
+    var uint32Tag = "[object Uint32Array]";
+    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+    var reIsHostCtor = /^\[object .+?Constructor\]$/;
+    var reIsUint = /^(?:0|[1-9]\d*)$/;
+    var typedArrayTags = {};
+    typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+    typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+    var root = freeGlobal || freeSelf || Function("return this")();
+    var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+    var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+    var moduleExports = freeModule && freeModule.exports === freeExports;
+    var freeProcess = moduleExports && freeGlobal.process;
+    var nodeUtil = function() {
+      try {
+        return freeProcess && freeProcess.binding && freeProcess.binding("util");
+      } catch (e2) {
+      }
+    }();
+    var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+    function arrayFilter(array, predicate) {
+      var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+      while (++index < length) {
+        var value2 = array[index];
+        if (predicate(value2, index, array)) {
+          result[resIndex++] = value2;
+        }
+      }
+      return result;
+    }
+    function arrayPush(array, values) {
+      var index = -1, length = values.length, offset = array.length;
+      while (++index < length) {
+        array[offset + index] = values[index];
+      }
+      return array;
+    }
+    function arraySome(array, predicate) {
+      var index = -1, length = array == null ? 0 : array.length;
+      while (++index < length) {
+        if (predicate(array[index], index, array)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function baseTimes(n2, iteratee) {
+      var index = -1, result = Array(n2);
+      while (++index < n2) {
+        result[index] = iteratee(index);
+      }
+      return result;
+    }
+    function baseUnary(func) {
+      return function(value2) {
+        return func(value2);
+      };
+    }
+    function cacheHas(cache3, key) {
+      return cache3.has(key);
+    }
+    function getValue(object, key) {
+      return object == null ? void 0 : object[key];
+    }
+    function mapToArray(map) {
+      var index = -1, result = Array(map.size);
+      map.forEach(function(value2, key) {
+        result[++index] = [key, value2];
+      });
+      return result;
+    }
+    function overArg(func, transform) {
+      return function(arg) {
+        return func(transform(arg));
+      };
+    }
+    function setToArray(set) {
+      var index = -1, result = Array(set.size);
+      set.forEach(function(value2) {
+        result[++index] = value2;
+      });
+      return result;
+    }
+    var arrayProto = Array.prototype;
+    var funcProto = Function.prototype;
+    var objectProto = Object.prototype;
+    var coreJsData = root["__core-js_shared__"];
+    var funcToString = funcProto.toString;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    var maskSrcKey = function() {
+      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+      return uid ? "Symbol(src)_1." + uid : "";
+    }();
+    var nativeObjectToString = objectProto.toString;
+    var reIsNative = RegExp(
+      "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+    );
+    var Buffer2 = moduleExports ? root.Buffer : void 0;
+    var Symbol2 = root.Symbol;
+    var Uint8Array2 = root.Uint8Array;
+    var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+    var splice = arrayProto.splice;
+    var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
+    var nativeGetSymbols = Object.getOwnPropertySymbols;
+    var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
+    var nativeKeys = overArg(Object.keys, Object);
+    var DataView = getNative(root, "DataView");
+    var Map2 = getNative(root, "Map");
+    var Promise2 = getNative(root, "Promise");
+    var Set2 = getNative(root, "Set");
+    var WeakMap2 = getNative(root, "WeakMap");
+    var nativeCreate = getNative(Object, "create");
+    var dataViewCtorString = toSource(DataView);
+    var mapCtorString = toSource(Map2);
+    var promiseCtorString = toSource(Promise2);
+    var setCtorString = toSource(Set2);
+    var weakMapCtorString = toSource(WeakMap2);
+    var symbolProto = Symbol2 ? Symbol2.prototype : void 0;
+    var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+    function Hash(entries) {
+      var index = -1, length = entries == null ? 0 : entries.length;
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+    function hashClear() {
+      this.__data__ = nativeCreate ? nativeCreate(null) : {};
+      this.size = 0;
+    }
+    function hashDelete(key) {
+      var result = this.has(key) && delete this.__data__[key];
+      this.size -= result ? 1 : 0;
+      return result;
+    }
+    function hashGet(key) {
+      var data = this.__data__;
+      if (nativeCreate) {
+        var result = data[key];
+        return result === HASH_UNDEFINED ? void 0 : result;
+      }
+      return hasOwnProperty.call(data, key) ? data[key] : void 0;
+    }
+    function hashHas(key) {
+      var data = this.__data__;
+      return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
+    }
+    function hashSet(key, value2) {
+      var data = this.__data__;
+      this.size += this.has(key) ? 0 : 1;
+      data[key] = nativeCreate && value2 === void 0 ? HASH_UNDEFINED : value2;
+      return this;
+    }
+    Hash.prototype.clear = hashClear;
+    Hash.prototype["delete"] = hashDelete;
+    Hash.prototype.get = hashGet;
+    Hash.prototype.has = hashHas;
+    Hash.prototype.set = hashSet;
+    function ListCache(entries) {
+      var index = -1, length = entries == null ? 0 : entries.length;
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+    function listCacheClear() {
+      this.__data__ = [];
+      this.size = 0;
+    }
+    function listCacheDelete(key) {
+      var data = this.__data__, index = assocIndexOf(data, key);
+      if (index < 0) {
+        return false;
+      }
+      var lastIndex = data.length - 1;
+      if (index == lastIndex) {
+        data.pop();
+      } else {
+        splice.call(data, index, 1);
+      }
+      --this.size;
+      return true;
+    }
+    function listCacheGet(key) {
+      var data = this.__data__, index = assocIndexOf(data, key);
+      return index < 0 ? void 0 : data[index][1];
+    }
+    function listCacheHas(key) {
+      return assocIndexOf(this.__data__, key) > -1;
+    }
+    function listCacheSet(key, value2) {
+      var data = this.__data__, index = assocIndexOf(data, key);
+      if (index < 0) {
+        ++this.size;
+        data.push([key, value2]);
+      } else {
+        data[index][1] = value2;
+      }
+      return this;
+    }
+    ListCache.prototype.clear = listCacheClear;
+    ListCache.prototype["delete"] = listCacheDelete;
+    ListCache.prototype.get = listCacheGet;
+    ListCache.prototype.has = listCacheHas;
+    ListCache.prototype.set = listCacheSet;
+    function MapCache(entries) {
+      var index = -1, length = entries == null ? 0 : entries.length;
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+    function mapCacheClear() {
+      this.size = 0;
+      this.__data__ = {
+        "hash": new Hash(),
+        "map": new (Map2 || ListCache)(),
+        "string": new Hash()
+      };
+    }
+    function mapCacheDelete(key) {
+      var result = getMapData(this, key)["delete"](key);
+      this.size -= result ? 1 : 0;
+      return result;
+    }
+    function mapCacheGet(key) {
+      return getMapData(this, key).get(key);
+    }
+    function mapCacheHas(key) {
+      return getMapData(this, key).has(key);
+    }
+    function mapCacheSet(key, value2) {
+      var data = getMapData(this, key), size = data.size;
+      data.set(key, value2);
+      this.size += data.size == size ? 0 : 1;
+      return this;
+    }
+    MapCache.prototype.clear = mapCacheClear;
+    MapCache.prototype["delete"] = mapCacheDelete;
+    MapCache.prototype.get = mapCacheGet;
+    MapCache.prototype.has = mapCacheHas;
+    MapCache.prototype.set = mapCacheSet;
+    function SetCache(values) {
+      var index = -1, length = values == null ? 0 : values.length;
+      this.__data__ = new MapCache();
+      while (++index < length) {
+        this.add(values[index]);
+      }
+    }
+    function setCacheAdd(value2) {
+      this.__data__.set(value2, HASH_UNDEFINED);
+      return this;
+    }
+    function setCacheHas(value2) {
+      return this.__data__.has(value2);
+    }
+    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+    SetCache.prototype.has = setCacheHas;
+    function Stack(entries) {
+      var data = this.__data__ = new ListCache(entries);
+      this.size = data.size;
+    }
+    function stackClear() {
+      this.__data__ = new ListCache();
+      this.size = 0;
+    }
+    function stackDelete(key) {
+      var data = this.__data__, result = data["delete"](key);
+      this.size = data.size;
+      return result;
+    }
+    function stackGet(key) {
+      return this.__data__.get(key);
+    }
+    function stackHas(key) {
+      return this.__data__.has(key);
+    }
+    function stackSet(key, value2) {
+      var data = this.__data__;
+      if (data instanceof ListCache) {
+        var pairs = data.__data__;
+        if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
+          pairs.push([key, value2]);
+          this.size = ++data.size;
+          return this;
+        }
+        data = this.__data__ = new MapCache(pairs);
+      }
+      data.set(key, value2);
+      this.size = data.size;
+      return this;
+    }
+    Stack.prototype.clear = stackClear;
+    Stack.prototype["delete"] = stackDelete;
+    Stack.prototype.get = stackGet;
+    Stack.prototype.has = stackHas;
+    Stack.prototype.set = stackSet;
+    function arrayLikeKeys(value2, inherited) {
+      var isArr = isArray(value2), isArg = !isArr && isArguments(value2), isBuff = !isArr && !isArg && isBuffer(value2), isType5 = !isArr && !isArg && !isBuff && isTypedArray(value2), skipIndexes = isArr || isArg || isBuff || isType5, result = skipIndexes ? baseTimes(value2.length, String) : [], length = result.length;
+      for (var key in value2) {
+        if ((inherited || hasOwnProperty.call(value2, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+        (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+        isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+        isType5 && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+        isIndex(key, length)))) {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+    function assocIndexOf(array, key) {
+      var length = array.length;
+      while (length--) {
+        if (eq(array[length][0], key)) {
+          return length;
+        }
+      }
+      return -1;
+    }
+    function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+      var result = keysFunc(object);
+      return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+    }
+    function baseGetTag(value2) {
+      if (value2 == null) {
+        return value2 === void 0 ? undefinedTag : nullTag;
+      }
+      return symToStringTag && symToStringTag in Object(value2) ? getRawTag(value2) : objectToString(value2);
+    }
+    function baseIsArguments(value2) {
+      return isObjectLike(value2) && baseGetTag(value2) == argsTag;
+    }
+    function baseIsEqual(value2, other, bitmask, customizer, stack) {
+      if (value2 === other) {
+        return true;
+      }
+      if (value2 == null || other == null || !isObjectLike(value2) && !isObjectLike(other)) {
+        return value2 !== value2 && other !== other;
+      }
+      return baseIsEqualDeep(value2, other, bitmask, customizer, baseIsEqual, stack);
+    }
+    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+      var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
+      objTag = objTag == argsTag ? objectTag : objTag;
+      othTag = othTag == argsTag ? objectTag : othTag;
+      var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
+      if (isSameTag && isBuffer(object)) {
+        if (!isBuffer(other)) {
+          return false;
+        }
+        objIsArr = true;
+        objIsObj = false;
+      }
+      if (isSameTag && !objIsObj) {
+        stack || (stack = new Stack());
+        return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+      }
+      if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+        var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
+        if (objIsWrapped || othIsWrapped) {
+          var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+          stack || (stack = new Stack());
+          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+        }
+      }
+      if (!isSameTag) {
+        return false;
+      }
+      stack || (stack = new Stack());
+      return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+    }
+    function baseIsNative(value2) {
+      if (!isObject2(value2) || isMasked(value2)) {
+        return false;
+      }
+      var pattern = isFunction(value2) ? reIsNative : reIsHostCtor;
+      return pattern.test(toSource(value2));
+    }
+    function baseIsTypedArray(value2) {
+      return isObjectLike(value2) && isLength(value2.length) && !!typedArrayTags[baseGetTag(value2)];
+    }
+    function baseKeys(object) {
+      if (!isPrototype(object)) {
+        return nativeKeys(object);
+      }
+      var result = [];
+      for (var key in Object(object)) {
+        if (hasOwnProperty.call(object, key) && key != "constructor") {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
+      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+        return false;
+      }
+      var stacked = stack.get(array);
+      if (stacked && stack.get(other)) {
+        return stacked == other;
+      }
+      var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : void 0;
+      stack.set(array, other);
+      stack.set(other, array);
+      while (++index < arrLength) {
+        var arrValue = array[index], othValue = other[index];
+        if (customizer) {
+          var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+        }
+        if (compared !== void 0) {
+          if (compared) {
+            continue;
+          }
+          result = false;
+          break;
+        }
+        if (seen) {
+          if (!arraySome(other, function(othValue2, othIndex) {
+            if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+              return seen.push(othIndex);
+            }
+          })) {
+            result = false;
+            break;
+          }
+        } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+          result = false;
+          break;
+        }
+      }
+      stack["delete"](array);
+      stack["delete"](other);
+      return result;
+    }
+    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+      switch (tag) {
+        case dataViewTag:
+          if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+            return false;
+          }
+          object = object.buffer;
+          other = other.buffer;
+        case arrayBufferTag:
+          if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
+            return false;
+          }
+          return true;
+        case boolTag:
+        case dateTag:
+        case numberTag:
+          return eq(+object, +other);
+        case errorTag:
+          return object.name == other.name && object.message == other.message;
+        case regexpTag:
+        case stringTag:
+          return object == other + "";
+        case mapTag:
+          var convert = mapToArray;
+        case setTag:
+          var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
+          convert || (convert = setToArray);
+          if (object.size != other.size && !isPartial) {
+            return false;
+          }
+          var stacked = stack.get(object);
+          if (stacked) {
+            return stacked == other;
+          }
+          bitmask |= COMPARE_UNORDERED_FLAG;
+          stack.set(object, other);
+          var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+          stack["delete"](object);
+          return result;
+        case symbolTag:
+          if (symbolValueOf) {
+            return symbolValueOf.call(object) == symbolValueOf.call(other);
+          }
+      }
+      return false;
+    }
+    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
+      if (objLength != othLength && !isPartial) {
+        return false;
+      }
+      var index = objLength;
+      while (index--) {
+        var key = objProps[index];
+        if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+          return false;
+        }
+      }
+      var stacked = stack.get(object);
+      if (stacked && stack.get(other)) {
+        return stacked == other;
+      }
+      var result = true;
+      stack.set(object, other);
+      stack.set(other, object);
+      var skipCtor = isPartial;
+      while (++index < objLength) {
+        key = objProps[index];
+        var objValue = object[key], othValue = other[key];
+        if (customizer) {
+          var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+        }
+        if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+          result = false;
+          break;
+        }
+        skipCtor || (skipCtor = key == "constructor");
+      }
+      if (result && !skipCtor) {
+        var objCtor = object.constructor, othCtor = other.constructor;
+        if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+          result = false;
+        }
+      }
+      stack["delete"](object);
+      stack["delete"](other);
+      return result;
+    }
+    function getAllKeys(object) {
+      return baseGetAllKeys(object, keys, getSymbols);
+    }
+    function getMapData(map, key) {
+      var data = map.__data__;
+      return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+    }
+    function getNative(object, key) {
+      var value2 = getValue(object, key);
+      return baseIsNative(value2) ? value2 : void 0;
+    }
+    function getRawTag(value2) {
+      var isOwn = hasOwnProperty.call(value2, symToStringTag), tag = value2[symToStringTag];
+      try {
+        value2[symToStringTag] = void 0;
+        var unmasked = true;
+      } catch (e2) {
+      }
+      var result = nativeObjectToString.call(value2);
+      if (unmasked) {
+        if (isOwn) {
+          value2[symToStringTag] = tag;
+        } else {
+          delete value2[symToStringTag];
+        }
+      }
+      return result;
+    }
+    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+      if (object == null) {
+        return [];
+      }
+      object = Object(object);
+      return arrayFilter(nativeGetSymbols(object), function(symbol) {
+        return propertyIsEnumerable.call(object, symbol);
+      });
+    };
+    var getTag = baseGetTag;
+    if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap2 && getTag(new WeakMap2()) != weakMapTag) {
+      getTag = function(value2) {
+        var result = baseGetTag(value2), Ctor = result == objectTag ? value2.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+        if (ctorString) {
+          switch (ctorString) {
+            case dataViewCtorString:
+              return dataViewTag;
+            case mapCtorString:
+              return mapTag;
+            case promiseCtorString:
+              return promiseTag;
+            case setCtorString:
+              return setTag;
+            case weakMapCtorString:
+              return weakMapTag;
+          }
+        }
+        return result;
+      };
+    }
+    function isIndex(value2, length) {
+      length = length == null ? MAX_SAFE_INTEGER : length;
+      return !!length && (typeof value2 == "number" || reIsUint.test(value2)) && (value2 > -1 && value2 % 1 == 0 && value2 < length);
+    }
+    function isKeyable(value2) {
+      var type = typeof value2;
+      return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value2 !== "__proto__" : value2 === null;
+    }
+    function isMasked(func) {
+      return !!maskSrcKey && maskSrcKey in func;
+    }
+    function isPrototype(value2) {
+      var Ctor = value2 && value2.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
+      return value2 === proto;
+    }
+    function objectToString(value2) {
+      return nativeObjectToString.call(value2);
+    }
+    function toSource(func) {
+      if (func != null) {
+        try {
+          return funcToString.call(func);
+        } catch (e2) {
+        }
+        try {
+          return func + "";
+        } catch (e2) {
+        }
+      }
+      return "";
+    }
+    function eq(value2, other) {
+      return value2 === other || value2 !== value2 && other !== other;
+    }
+    var isArguments = baseIsArguments(/* @__PURE__ */ function() {
+      return arguments;
+    }()) ? baseIsArguments : function(value2) {
+      return isObjectLike(value2) && hasOwnProperty.call(value2, "callee") && !propertyIsEnumerable.call(value2, "callee");
+    };
+    var isArray = Array.isArray;
+    function isArrayLike(value2) {
+      return value2 != null && isLength(value2.length) && !isFunction(value2);
+    }
+    var isBuffer = nativeIsBuffer || stubFalse;
+    function isEqual2(value2, other) {
+      return baseIsEqual(value2, other);
+    }
+    function isFunction(value2) {
+      if (!isObject2(value2)) {
+        return false;
+      }
+      var tag = baseGetTag(value2);
+      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+    }
+    function isLength(value2) {
+      return typeof value2 == "number" && value2 > -1 && value2 % 1 == 0 && value2 <= MAX_SAFE_INTEGER;
+    }
+    function isObject2(value2) {
+      var type = typeof value2;
+      return value2 != null && (type == "object" || type == "function");
+    }
+    function isObjectLike(value2) {
+      return value2 != null && typeof value2 == "object";
+    }
+    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+    function keys(object) {
+      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+    }
+    function stubArray() {
+      return [];
+    }
+    function stubFalse() {
+      return false;
+    }
+    module.exports = isEqual2;
+  }
+});
+
+// ../../node_modules/arr-rotate/index.js
+var require_arr_rotate = __commonJS({
+  "../../node_modules/arr-rotate/index.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    module.exports = (input, n2) => {
+      if (!Array.isArray(input)) {
+        throw new TypeError(`Expected an array, got ${typeof input}`);
+      }
+      const x = input.slice();
+      const num = typeof n2 === "number" ? n2 : 0;
+      return x.splice(-num % x.length).concat(x);
+    };
+  }
+});
+
 // ../../node_modules/void-elements/index.js
 var require_void_elements = __commonJS({
   "../../node_modules/void-elements/index.js"(exports, module) {
@@ -6729,12 +7162,12 @@ var getAllProperties = (object) => {
 };
 function autoBind(self2, { include, exclude } = {}) {
   const filter = (key) => {
-    const match4 = (pattern) => typeof pattern === "string" ? key === pattern : pattern.test(key);
+    const match6 = (pattern) => typeof pattern === "string" ? key === pattern : pattern.test(key);
     if (include) {
-      return include.some(match4);
+      return include.some(match6);
     }
     if (exclude) {
-      return !exclude.some(match4);
+      return !exclude.some(match6);
     }
     return true;
   };
@@ -8777,7 +9210,7 @@ var styles_default = styles2;
 // ../../node_modules/ink/build/reconciler.js
 if (process3.env["DEV"] === "true") {
   try {
-    await import("./devtools-YPSDP32D.js");
+    await import("./devtools-JB2HYTEA.js");
   } catch (error) {
     if (error.code === "MODULE_NOT_FOUND") {
       console.warn(`
@@ -10881,7 +11314,7 @@ var Text2 = ({
 
 // ../cli-ui-kit/src/components/ConfirmInput/ConfirmInput.tsx
 init_esm_shims();
-var import_react33 = __toESM(require_react(), 1);
+var import_react34 = __toESM(require_react(), 1);
 var import_variant3 = __toESM(require_lib(), 1);
 
 // ../cli-ui-kit/src/input-state.ts
@@ -10896,7 +11329,7 @@ var InputState = (0, import_variant.variant)(
 
 // ../cli-ui-kit/src/components/InputLabel.tsx
 init_esm_shims();
-var import_react29 = __toESM(require_react(), 1);
+var import_react30 = __toESM(require_react(), 1);
 
 // ../cli-ui-kit/src/icons/index.ts
 init_esm_shims();
@@ -10929,57 +11362,68 @@ var QuestionMarkIcon = () => {
   return /* @__PURE__ */ import_react25.default.createElement(Text2, null, "?");
 };
 
-// ../cli-ui-kit/src/icons/Success.tsx
+// ../cli-ui-kit/src/icons/Radio.tsx
 init_esm_shims();
 var import_react26 = __toESM(require_react(), 1);
+var RadioIcon = ({ selected }) => {
+  let content = isUnicodeSupported() ? "\u25CB" : "o";
+  if (selected) {
+    content = isUnicodeSupported() ? "\u25CF" : "\u2022";
+  }
+  return /* @__PURE__ */ import_react26.default.createElement(Text2, null, content);
+};
+
+// ../cli-ui-kit/src/icons/Success.tsx
+init_esm_shims();
+var import_react27 = __toESM(require_react(), 1);
 var SuccessIcon = () => {
-  return /* @__PURE__ */ import_react26.default.createElement(Text2, null, isUnicodeSupported() ? "\u2714" : "\u221A");
+  return /* @__PURE__ */ import_react27.default.createElement(Text2, null, isUnicodeSupported() ? "\u2714" : "\u221A");
 };
 
 // ../cli-ui-kit/src/icons/Warning.tsx
 init_esm_shims();
-var import_react27 = __toESM(require_react(), 1);
+var import_react28 = __toESM(require_react(), 1);
 var WarningIcon = () => {
-  return /* @__PURE__ */ import_react27.default.createElement(Text2, null, isUnicodeSupported() ? "\u26A0" : "\u203C");
+  return /* @__PURE__ */ import_react28.default.createElement(Text2, null, isUnicodeSupported() ? "\u26A0" : "\u203C");
 };
 
 // ../cli-ui-kit/src/icons/Insight.tsx
 init_esm_shims();
-var import_react28 = __toESM(require_react(), 1);
+var import_react29 = __toESM(require_react(), 1);
 var InsightIcon = () => {
-  return /* @__PURE__ */ import_react28.default.createElement(Text2, null, isUnicodeSupported() ? "\u{1F4A1}" : "!");
+  return /* @__PURE__ */ import_react29.default.createElement(Text2, null, isUnicodeSupported() ? "\u{1F4A1}" : "!");
 };
 
 // ../cli-ui-kit/src/components/InputLabel.tsx
 var InputLabel = ({ children, icon }) => {
-  return /* @__PURE__ */ import_react29.default.createElement(Text2, null, icon ?? /* @__PURE__ */ import_react29.default.createElement(Text2, { skin: "question", bold: true }, /* @__PURE__ */ import_react29.default.createElement(QuestionMarkIcon, null)), " ", /* @__PURE__ */ import_react29.default.createElement(Text2, { skin: "question", bold: true }, children));
+  return /* @__PURE__ */ import_react30.default.createElement(Text2, null, icon ?? /* @__PURE__ */ import_react30.default.createElement(Text2, { skin: "question", bold: true }, /* @__PURE__ */ import_react30.default.createElement(QuestionMarkIcon, null)), " ", /* @__PURE__ */ import_react30.default.createElement(Text2, { skin: "question", bold: true }, children));
 };
 
 // ../cli-ui-kit/src/components/ConfirmInput/Placeholder.tsx
 init_esm_shims();
-var import_react30 = __toESM(require_react(), 1);
+var import_react31 = __toESM(require_react(), 1);
 var import_variant2 = __toESM(require_lib(), 1);
 var Placeholder = ({ inputState }) => {
   return (0, import_variant2.match)(inputState, {
-    NotSubmitted: ({ value: value2 }) => /* @__PURE__ */ import_react30.default.createElement(Text2, { skin: "secondary" }, "(", value2 ? "Y/n" : "y/N", ")"),
-    Submitted: ({ value: value2 }) => /* @__PURE__ */ import_react30.default.createElement(Text2, null, value2 ? "Yes" : "No")
+    NotSubmitted: ({ value: value2 }) => /* @__PURE__ */ import_react31.default.createElement(Text2, { skin: "secondary" }, "(", value2 ? "Y/n" : "y/N", ")"),
+    Submitted: ({ value: value2 }) => /* @__PURE__ */ import_react31.default.createElement(Text2, null, value2 ? "Yes" : "No")
   });
 };
 
 // ../cli-ui-kit/src/components/ConfirmInput/Input.tsx
 init_esm_shims();
-var import_react32 = __toESM(require_react(), 1);
+var import_react33 = __toESM(require_react(), 1);
 
 // ../../node_modules/ink-text-input/build/index.js
 init_esm_shims();
-var import_react31 = __toESM(require_react(), 1);
+var import_react32 = __toESM(require_react(), 1);
 function TextInput({ value: originalValue, placeholder = "", focus = true, mask, highlightPastedText = false, showCursor = true, onChange, onSubmit }) {
-  const [state, setState] = (0, import_react31.useState)({
+  const [state, setState] = (0, import_react32.useState)({
     cursorOffset: (originalValue || "").length,
     cursorWidth: 0
   });
   const { cursorOffset, cursorWidth } = state;
-  (0, import_react31.useEffect)(() => {
+  (0, import_react32.useEffect)(() => {
     setState((previousState) => {
       if (!focus || !showCursor) {
         return previousState;
@@ -11057,13 +11501,13 @@ function TextInput({ value: originalValue, placeholder = "", focus = true, mask,
       onChange(nextValue);
     }
   }, { isActive: focus });
-  return import_react31.default.createElement(Text, null, placeholder ? value2.length > 0 ? renderedValue : renderedPlaceholder : renderedValue);
+  return import_react32.default.createElement(Text, null, placeholder ? value2.length > 0 ? renderedValue : renderedPlaceholder : renderedValue);
 }
 var build_default = TextInput;
 
 // ../cli-ui-kit/src/components/ConfirmInput/Input.tsx
 var Input = ({ initialValue, onSubmit }) => {
-  const handleChange = (0, import_react32.useCallback)(
+  const handleChange = (0, import_react33.useCallback)(
     (rawKey) => {
       const key = rawKey.toLowerCase();
       if (["y", "n"].includes(key)) {
@@ -11072,7 +11516,7 @@ var Input = ({ initialValue, onSubmit }) => {
     },
     [onSubmit]
   );
-  return /* @__PURE__ */ import_react32.default.createElement(
+  return /* @__PURE__ */ import_react33.default.createElement(
     build_default,
     {
       value: "",
@@ -11090,17 +11534,17 @@ var ConfirmInput = ({
   initialValue = true,
   onSubmit
 }) => {
-  const [inputState, setInputState] = (0, import_react33.useState)(
+  const [inputState, setInputState] = (0, import_react34.useState)(
     () => InputState.NotSubmitted(initialValue)
   );
-  const handleSubmit = (0, import_react33.useCallback)(
+  const handleSubmit = (0, import_react34.useCallback)(
     (value2) => {
       setInputState(InputState.Submitted(value2));
       onSubmit(value2);
     },
     [onSubmit]
   );
-  return /* @__PURE__ */ import_react33.default.createElement(Text2, null, /* @__PURE__ */ import_react33.default.createElement(InputLabel, null, label), " ", info && (0, import_variant3.isType)(inputState, InputState.NotSubmitted) && /* @__PURE__ */ import_react33.default.createElement(Text2, { skin: "secondary" }, info, " "), /* @__PURE__ */ import_react33.default.createElement(Placeholder, { inputState }), (0, import_variant3.isType)(inputState, InputState.NotSubmitted) && /* @__PURE__ */ import_react33.default.createElement(Input, { initialValue, onSubmit: handleSubmit }));
+  return /* @__PURE__ */ import_react34.default.createElement(Text2, null, /* @__PURE__ */ import_react34.default.createElement(InputLabel, null, label), " ", info && (0, import_variant3.isType)(inputState, InputState.NotSubmitted) && /* @__PURE__ */ import_react34.default.createElement(Text2, { skin: "secondary" }, info, " "), /* @__PURE__ */ import_react34.default.createElement(Placeholder, { inputState }), (0, import_variant3.isType)(inputState, InputState.NotSubmitted) && /* @__PURE__ */ import_react34.default.createElement(Input, { initialValue, onSubmit: handleSubmit }));
 };
 
 // ../cli-ui-kit/src/components/ConfirmInput/index.ts
@@ -11108,37 +11552,37 @@ init_esm_shims();
 
 // ../cli-ui-kit/src/components/Alert.tsx
 init_esm_shims();
-var import_react34 = __toESM(require_react(), 1);
+var import_react35 = __toESM(require_react(), 1);
 var import_variant4 = __toESM(require_lib(), 1);
 var Alert = ({ type, children }) => {
   const icon = (0, import_variant4.match)(type, {
     error: (0, import_variant4.constant)(
-      /* @__PURE__ */ import_react34.default.createElement(Text2, { skin: "error" }, /* @__PURE__ */ import_react34.default.createElement(ErrorIcon, null))
+      /* @__PURE__ */ import_react35.default.createElement(Text2, { skin: "error" }, /* @__PURE__ */ import_react35.default.createElement(ErrorIcon, null))
     ),
     warning: (0, import_variant4.constant)(
-      /* @__PURE__ */ import_react34.default.createElement(Text2, { skin: "warning" }, /* @__PURE__ */ import_react34.default.createElement(WarningIcon, null))
+      /* @__PURE__ */ import_react35.default.createElement(Text2, { skin: "warning" }, /* @__PURE__ */ import_react35.default.createElement(WarningIcon, null))
     ),
     success: (0, import_variant4.constant)(
-      /* @__PURE__ */ import_react34.default.createElement(Text2, { skin: "success" }, /* @__PURE__ */ import_react34.default.createElement(SuccessIcon, null))
+      /* @__PURE__ */ import_react35.default.createElement(Text2, { skin: "success" }, /* @__PURE__ */ import_react35.default.createElement(SuccessIcon, null))
     ),
-    insight: (0, import_variant4.constant)(/* @__PURE__ */ import_react34.default.createElement(InsightIcon, null))
+    insight: (0, import_variant4.constant)(/* @__PURE__ */ import_react35.default.createElement(InsightIcon, null))
   });
-  return /* @__PURE__ */ import_react34.default.createElement(Text2, null, icon, " ", children);
+  return /* @__PURE__ */ import_react35.default.createElement(Text2, null, icon, " ", children);
 };
 
 // ../cli-ui-kit/src/components/Badge.tsx
 init_esm_shims();
-var import_react35 = __toESM(require_react(), 1);
+var import_react36 = __toESM(require_react(), 1);
 var skins2 = {
   success: { backgroundColor: "green" }
 };
 var Badge = ({ children, skin }) => {
-  return /* @__PURE__ */ import_react35.default.createElement(Text, { ...skins2[skin] }, " ", children, " ");
+  return /* @__PURE__ */ import_react36.default.createElement(Text, { ...skins2[skin] }, " ", children, " ");
 };
 
 // ../cli-ui-kit/src/components/Link.tsx
 init_esm_shims();
-var import_react36 = __toESM(require_react(), 1);
+var import_react37 = __toESM(require_react(), 1);
 
 // ../../node_modules/terminal-link/index.js
 init_esm_shims();
@@ -11285,31 +11729,31 @@ terminalLink.stderr.isSupported = import_supports_hyperlinks.default.stderr;
 var Link = ({ skin, children, url }) => {
   if (children) {
     if (terminalLink.isSupported) {
-      return /* @__PURE__ */ import_react36.default.createElement(
+      return /* @__PURE__ */ import_react37.default.createElement(
         Transform,
         {
           transform: (childrenAsString) => terminalLink(childrenAsString, url, { fallback: false })
         },
-        /* @__PURE__ */ import_react36.default.createElement(Text2, { skin }, children)
+        /* @__PURE__ */ import_react37.default.createElement(Text2, { skin }, children)
       );
     }
-    return /* @__PURE__ */ import_react36.default.createElement(Text2, null, /* @__PURE__ */ import_react36.default.createElement(Text2, { skin }, children), " (", url, ")");
+    return /* @__PURE__ */ import_react37.default.createElement(Text2, null, /* @__PURE__ */ import_react37.default.createElement(Text2, { skin }, children), " (", url, ")");
   }
-  return /* @__PURE__ */ import_react36.default.createElement(Text2, { skin: "info" }, url);
+  return /* @__PURE__ */ import_react37.default.createElement(Text2, { skin: "info" }, url);
 };
 
 // ../cli-ui-kit/src/components/Spinner.tsx
 init_esm_shims();
-var import_react38 = __toESM(require_react(), 1);
+var import_react39 = __toESM(require_react(), 1);
 
 // ../../node_modules/ink-spinner/build/index.js
 init_esm_shims();
-var import_react37 = __toESM(require_react(), 1);
+var import_react38 = __toESM(require_react(), 1);
 var import_cli_spinners = __toESM(require_cli_spinners(), 1);
 function Spinner({ type = "dots" }) {
-  const [frame, setFrame] = (0, import_react37.useState)(0);
+  const [frame, setFrame] = (0, import_react38.useState)(0);
   const spinner = import_cli_spinners.default[type];
-  (0, import_react37.useEffect)(() => {
+  (0, import_react38.useEffect)(() => {
     const timer = setInterval(() => {
       setFrame((previousFrame) => {
         const isLastFrame = previousFrame === spinner.frames.length - 1;
@@ -11320,15 +11764,15 @@ function Spinner({ type = "dots" }) {
       clearInterval(timer);
     };
   }, [spinner]);
-  return import_react37.default.createElement(Text, null, spinner.frames[frame]);
+  return import_react38.default.createElement(Text, null, spinner.frames[frame]);
 }
 var build_default2 = Spinner;
 
 // ../cli-ui-kit/src/components/Spinner.tsx
 var Spinner2 = ({ text }) => {
-  const spinnerNode = /* @__PURE__ */ import_react38.default.createElement(Text2, { skin: "info" }, /* @__PURE__ */ import_react38.default.createElement(build_default2, { type: "dots" }));
+  const spinnerNode = /* @__PURE__ */ import_react39.default.createElement(Text2, { skin: "info" }, /* @__PURE__ */ import_react39.default.createElement(build_default2, { type: "dots" }));
   if (text) {
-    return /* @__PURE__ */ import_react38.default.createElement(Box_default, { gap: 1 }, spinnerNode, typeof text === "string" ? /* @__PURE__ */ import_react38.default.createElement(Text2, null, text) : text);
+    return /* @__PURE__ */ import_react39.default.createElement(Box_default, { gap: 1 }, spinnerNode, typeof text === "string" ? /* @__PURE__ */ import_react39.default.createElement(Text2, null, text) : text);
   }
   return spinnerNode;
 };
@@ -11339,7 +11783,7 @@ var import_variant5 = __toESM(require_lib(), 1);
 
 // ../../node_modules/react-async-hook/dist/react-async-hook.esm.js
 init_esm_shims();
-var import_react39 = __toESM(require_react());
+var import_react40 = __toESM(require_react());
 function _extends() {
   _extends = Object.assign || function(target) {
     for (var i2 = 1; i2 < arguments.length; i2++) {
@@ -11356,13 +11800,13 @@ function _extends() {
 }
 var _iteratorSymbol = typeof Symbol !== "undefined" ? Symbol.iterator || (Symbol.iterator = Symbol("Symbol.iterator")) : "@@iterator";
 var _asyncIteratorSymbol = typeof Symbol !== "undefined" ? Symbol.asyncIterator || (Symbol.asyncIterator = Symbol("Symbol.asyncIterator")) : "@@asyncIterator";
-var useIsomorphicLayoutEffect = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined" ? import_react39.useLayoutEffect : import_react39.useEffect;
+var useIsomorphicLayoutEffect = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined" ? import_react40.useLayoutEffect : import_react40.useEffect;
 var useGetter = function useGetter2(t3) {
-  var ref = (0, import_react39.useRef)(t3);
+  var ref = (0, import_react40.useRef)(t3);
   useIsomorphicLayoutEffect(function() {
     ref.current = t3;
   });
-  return (0, import_react39.useCallback)(function() {
+  return (0, import_react40.useCallback)(function() {
     return ref.current;
   }, [ref]);
 };
@@ -11415,22 +11859,22 @@ var normalizeOptions = function normalizeOptions2(options) {
   return _extends({}, DefaultOptions, {}, options);
 };
 var useAsyncState = function useAsyncState2(options) {
-  var _useState = (0, import_react39.useState)(function() {
+  var _useState = (0, import_react40.useState)(function() {
     return options.initialState(options);
   }), value2 = _useState[0], setValue = _useState[1];
-  var reset = (0, import_react39.useCallback)(function() {
+  var reset = (0, import_react40.useCallback)(function() {
     return setValue(options.initialState(options));
   }, [setValue, options]);
-  var setLoading = (0, import_react39.useCallback)(function() {
+  var setLoading = (0, import_react40.useCallback)(function() {
     return setValue(options.setLoading(value2));
   }, [value2, setValue]);
-  var setResult = (0, import_react39.useCallback)(function(result) {
+  var setResult = (0, import_react40.useCallback)(function(result) {
     return setValue(options.setResult(result, value2));
   }, [value2, setValue]);
-  var setError = (0, import_react39.useCallback)(function(error) {
+  var setError = (0, import_react40.useCallback)(function(error) {
     return setValue(options.setError(error, value2));
   }, [value2, setValue]);
-  var merge = (0, import_react39.useCallback)(function(state) {
+  var merge = (0, import_react40.useCallback)(function(state) {
     return setValue(_extends({}, value2, {}, state));
   }, [value2, setValue]);
   return {
@@ -11444,8 +11888,8 @@ var useAsyncState = function useAsyncState2(options) {
   };
 };
 var useIsMounted = function useIsMounted2() {
-  var ref = (0, import_react39.useRef)(false);
-  (0, import_react39.useEffect)(function() {
+  var ref = (0, import_react40.useRef)(false);
+  (0, import_react40.useEffect)(function() {
     ref.current = true;
     return function() {
       ref.current = false;
@@ -11456,7 +11900,7 @@ var useIsMounted = function useIsMounted2() {
   };
 };
 var useCurrentPromise = function useCurrentPromise2() {
-  var ref = (0, import_react39.useRef)(null);
+  var ref = (0, import_react40.useRef)(null);
   return {
     set: function set(promise) {
       return ref.current = promise;
@@ -11472,7 +11916,7 @@ var useCurrentPromise = function useCurrentPromise2() {
 var useAsyncInternal = function useAsyncInternal2(asyncFunction, params, options) {
   !params && (params = []);
   var normalizedOptions = normalizeOptions(options);
-  var _useState2 = (0, import_react39.useState)(null), currentParams = _useState2[0], setCurrentParams = _useState2[1];
+  var _useState2 = (0, import_react40.useState)(null), currentParams = _useState2[0], setCurrentParams = _useState2[1];
   var AsyncState = useAsyncState(normalizedOptions);
   var isMounted = useIsMounted();
   var CurrentPromise = useCurrentPromise();
@@ -11515,11 +11959,11 @@ var useAsyncInternal = function useAsyncInternal2(asyncFunction, params, options
     return promise;
   };
   var getLatestExecuteAsyncOperation = useGetter(executeAsyncOperation);
-  var executeAsyncOperationMemo = (0, import_react39.useCallback)(function() {
+  var executeAsyncOperationMemo = (0, import_react40.useCallback)(function() {
     return getLatestExecuteAsyncOperation().apply(void 0, arguments);
   }, [getLatestExecuteAsyncOperation]);
   var isMounting = !isMounted();
-  (0, import_react39.useEffect)(function() {
+  (0, import_react40.useEffect)(function() {
     var execute = function execute2() {
       return getLatestExecuteAsyncOperation().apply(void 0, params);
     };
@@ -11552,14 +11996,14 @@ var useAsyncCallback = function useAsyncCallback2(asyncFunction, options) {
 };
 
 // ../cli-ui-kit/src/hooks/use-async.ts
-var import_react41 = __toESM(require_react(), 1);
+var import_react42 = __toESM(require_react(), 1);
 
 // ../cli-ui-kit/src/hooks/use-exit.ts
 init_esm_shims();
-var import_react40 = __toESM(require_react(), 1);
+var import_react41 = __toESM(require_react(), 1);
 function useExit() {
   const { exit } = use_app_default();
-  return (0, import_react40.useCallback)(
+  return (0, import_react41.useCallback)(
     (error) => {
       if (error instanceof Error) {
         exit(error);
@@ -11591,7 +12035,7 @@ var AsyncCallbackStatus = (0, import_variant5.variant)(
 );
 var useAsync2 = (fn, args, options) => {
   const exit = useExit();
-  const abortController = (0, import_react41.useMemo)(() => new AbortController(), []);
+  const abortController = (0, import_react42.useMemo)(() => new AbortController(), []);
   const { result, error, status, merge } = useAsync(
     fn.bind(null, { signal: abortController.signal }),
     args,
@@ -11600,7 +12044,7 @@ var useAsync2 = (fn, args, options) => {
       ...options ?? {}
     }
   );
-  (0, import_react41.useEffect)(() => {
+  (0, import_react42.useEffect)(() => {
     return () => {
       abortController.abort();
     };
@@ -11620,7 +12064,7 @@ var useAsync2 = (fn, args, options) => {
 };
 var useAsyncCallback3 = (fn, options) => {
   const exit = useExit();
-  const abortController = (0, import_react41.useMemo)(() => new AbortController(), []);
+  const abortController = (0, import_react42.useMemo)(() => new AbortController(), []);
   const { result, error, status, merge, execute } = useAsyncCallback(
     fn.bind(null, { signal: abortController.signal }),
     {
@@ -11628,7 +12072,7 @@ var useAsyncCallback3 = (fn, options) => {
       ...options ?? {}
     }
   );
-  (0, import_react41.useEffect)(() => {
+  (0, import_react42.useEffect)(() => {
     return () => {
       abortController.abort();
     };
@@ -11658,8 +12102,8 @@ var useAsyncCallback3 = (fn, options) => {
 
 // ../cli-ui-kit/src/renderer.tsx
 init_esm_shims();
-var import_react42 = __toESM(require_react(), 1);
-var ErrorBoundary = class extends import_react42.Component {
+var import_react43 = __toESM(require_react(), 1);
+var ErrorBoundary = class extends import_react43.Component {
   state = { hasError: false };
   static getDerivedStateFromError(_error) {
     return { hasError: true };
@@ -11685,18 +12129,18 @@ var ErrorBoundary = class extends import_react42.Component {
 };
 var ErrorBoundaryWrapper = ({ children }) => {
   const exit = useExit();
-  return /* @__PURE__ */ import_react42.default.createElement(ErrorBoundary, { onExit: exit }, children);
+  return /* @__PURE__ */ import_react43.default.createElement(ErrorBoundary, { onExit: exit }, children);
 };
 var FrameWrapper = ({
   children,
   wrap
 }) => {
-  return /* @__PURE__ */ import_react42.default.createElement(import_react42.default.Fragment, null, wrap && /* @__PURE__ */ import_react42.default.createElement(Text, null, "----RENDER-FRAME-START----"), children, wrap && /* @__PURE__ */ import_react42.default.createElement(Text, null, "----RENDER-FRAME-END----"));
+  return /* @__PURE__ */ import_react43.default.createElement(import_react43.default.Fragment, null, wrap && /* @__PURE__ */ import_react43.default.createElement(Text, null, "----RENDER-FRAME-START----"), children, wrap && /* @__PURE__ */ import_react43.default.createElement(Text, null, "----RENDER-FRAME-END----"));
 };
 async function render2(tree) {
   const debug = !!getTestOverrides().inkDebug;
   const { waitUntilExit, unmount } = render_default(
-    /* @__PURE__ */ import_react42.default.createElement(FrameWrapper, { wrap: debug }, /* @__PURE__ */ import_react42.default.createElement(ErrorBoundaryWrapper, null, tree)),
+    /* @__PURE__ */ import_react43.default.createElement(FrameWrapper, { wrap: debug }, /* @__PURE__ */ import_react43.default.createElement(ErrorBoundaryWrapper, null, tree)),
     { exitOnCtrlC: true, debug }
   );
   process.once("beforeExit", () => {
@@ -11710,7 +12154,7 @@ async function render2(tree) {
 function renderSyncInternal(tree, renderOptions) {
   const debug = !!getTestOverrides().inkDebug;
   const { unmount } = render_default(
-    /* @__PURE__ */ import_react42.default.createElement(FrameWrapper, { wrap: debug }, tree),
+    /* @__PURE__ */ import_react43.default.createElement(FrameWrapper, { wrap: debug }, tree),
     {
       debug,
       ...renderOptions
@@ -11735,22 +12179,22 @@ init_esm_shims();
 
 // ../cli-ui-kit/src/components/UnorderedList/UnorderedList.tsx
 init_esm_shims();
-var import_react46 = __toESM(require_react(), 1);
+var import_react47 = __toESM(require_react(), 1);
 
 // ../cli-ui-kit/src/components/UnorderedList/UnorderedListItem.tsx
 init_esm_shims();
-var import_react44 = __toESM(require_react(), 1);
+var import_react45 = __toESM(require_react(), 1);
 
 // ../cli-ui-kit/src/components/UnorderedList/UnorderedListItemContext.ts
 init_esm_shims();
-var import_react43 = __toESM(require_react(), 1);
+var import_react44 = __toESM(require_react(), 1);
 
 // ../cli-ui-kit/src/components/UnorderedList/DefaultMarker.ts
 init_esm_shims();
 var defaultMarker = isUnicodeSupported() ? "\u25CF" : "*";
 
 // ../cli-ui-kit/src/components/UnorderedList/UnorderedListItemContext.ts
-var UnorderedListItemContext = (0, import_react43.createContext)({
+var UnorderedListItemContext = (0, import_react44.createContext)({
   marker: defaultMarker
 });
 
@@ -11760,17 +12204,17 @@ function UnorderedListItem({
   marker: markerOverride,
   ...style
 }) {
-  let { marker } = (0, import_react44.useContext)(UnorderedListItemContext);
+  let { marker } = (0, import_react45.useContext)(UnorderedListItemContext);
   if (markerOverride !== void 0) {
     marker = markerOverride;
   }
-  return /* @__PURE__ */ import_react44.default.createElement(Box_default, { gap: 1 }, marker && /* @__PURE__ */ import_react44.default.createElement(Text, null, marker), /* @__PURE__ */ import_react44.default.createElement(Box_default, { flexDirection: "column", ...style }, children));
+  return /* @__PURE__ */ import_react45.default.createElement(Box_default, { gap: 1 }, marker && /* @__PURE__ */ import_react45.default.createElement(Text, null, marker), /* @__PURE__ */ import_react45.default.createElement(Box_default, { flexDirection: "column", ...style }, children));
 }
 
 // ../cli-ui-kit/src/components/UnorderedList/UnorderedListContext.ts
 init_esm_shims();
-var import_react45 = __toESM(require_react(), 1);
-var UnorderedListContext = (0, import_react45.createContext)({
+var import_react46 = __toESM(require_react(), 1);
+var UnorderedListContext = (0, import_react46.createContext)({
   depth: 0
 });
 
@@ -11780,15 +12224,15 @@ function UnorderedList({
   marker: markerOverride,
   ...style
 }) {
-  const { depth } = (0, import_react46.useContext)(UnorderedListContext);
-  const { marker } = (0, import_react46.useContext)(UnorderedListItemContext);
-  const listContext = (0, import_react46.useMemo)(
+  const { depth } = (0, import_react47.useContext)(UnorderedListContext);
+  const { marker } = (0, import_react47.useContext)(UnorderedListItemContext);
+  const listContext = (0, import_react47.useMemo)(
     () => ({
       depth: depth + 1
     }),
     [depth]
   );
-  const listItemContext = (0, import_react46.useMemo)(() => {
+  const listItemContext = (0, import_react47.useMemo)(() => {
     if (typeof markerOverride === "string") {
       return { marker: markerOverride };
     }
@@ -11797,21 +12241,531 @@ function UnorderedList({
     }
     return { marker: defaultMarker };
   }, [marker, markerOverride]);
-  return /* @__PURE__ */ import_react46.default.createElement(UnorderedListContext.Provider, { value: listContext }, /* @__PURE__ */ import_react46.default.createElement(UnorderedListItemContext.Provider, { value: listItemContext }, /* @__PURE__ */ import_react46.default.createElement(Box_default, { ...style, flexDirection: "column", marginLeft: depth * 2 }, children)));
+  return /* @__PURE__ */ import_react47.default.createElement(UnorderedListContext.Provider, { value: listContext }, /* @__PURE__ */ import_react47.default.createElement(UnorderedListItemContext.Provider, { value: listItemContext }, /* @__PURE__ */ import_react47.default.createElement(Box_default, { ...style, flexDirection: "column", marginLeft: depth * 2 }, children)));
 }
 UnorderedList.Item = UnorderedListItem;
 
+// ../cli-ui-kit/src/components/SelectInput/index.ts
+init_esm_shims();
+
+// ../cli-ui-kit/src/components/SelectInput/SelectInput.tsx
+init_esm_shims();
+var import_react54 = __toESM(require_react(), 1);
+var import_variant9 = __toESM(require_lib(), 1);
+
+// ../../node_modules/ink-select-input/build/index.js
+init_esm_shims();
+
+// ../../node_modules/ink-select-input/build/Indicator.js
+init_esm_shims();
+var import_react48 = __toESM(require_react(), 1);
+
+// ../../node_modules/figures/index.js
+init_esm_shims();
+import process13 from "node:process";
+
+// ../../node_modules/figures/node_modules/escape-string-regexp/index.js
+init_esm_shims();
+
+// ../../node_modules/figures/node_modules/is-unicode-supported/index.js
+init_esm_shims();
+import process12 from "node:process";
+function isUnicodeSupported2() {
+  if (process12.platform !== "win32") {
+    return process12.env.TERM !== "linux";
+  }
+  return Boolean(process12.env.CI) || Boolean(process12.env.WT_SESSION) || Boolean(process12.env.TERMINUS_SUBLIME) || process12.env.ConEmuTask === "{cmd::Cmder}" || process12.env.TERM_PROGRAM === "Terminus-Sublime" || process12.env.TERM_PROGRAM === "vscode" || process12.env.TERM === "xterm-256color" || process12.env.TERM === "alacritty" || process12.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+
+// ../../node_modules/figures/index.js
+var { platform } = process13;
+var common = {
+  square: "\u2588",
+  squareDarkShade: "\u2593",
+  squareMediumShade: "\u2592",
+  squareLightShade: "\u2591",
+  squareTop: "\u2580",
+  squareBottom: "\u2584",
+  squareLeft: "\u258C",
+  squareRight: "\u2590",
+  squareCenter: "\u25A0",
+  bullet: "\u25CF",
+  dot: "\u2024",
+  ellipsis: "\u2026",
+  pointerSmall: "\u203A",
+  triangleUp: "\u25B2",
+  triangleUpSmall: "\u25B4",
+  triangleDown: "\u25BC",
+  triangleDownSmall: "\u25BE",
+  triangleLeftSmall: "\u25C2",
+  triangleRightSmall: "\u25B8",
+  home: "\u2302",
+  heart: "\u2665",
+  musicNote: "\u266A",
+  musicNoteBeamed: "\u266B",
+  arrowUp: "\u2191",
+  arrowDown: "\u2193",
+  arrowLeft: "\u2190",
+  arrowRight: "\u2192",
+  arrowLeftRight: "\u2194",
+  arrowUpDown: "\u2195",
+  almostEqual: "\u2248",
+  notEqual: "\u2260",
+  lessOrEqual: "\u2264",
+  greaterOrEqual: "\u2265",
+  identical: "\u2261",
+  infinity: "\u221E",
+  subscriptZero: "\u2080",
+  subscriptOne: "\u2081",
+  subscriptTwo: "\u2082",
+  subscriptThree: "\u2083",
+  subscriptFour: "\u2084",
+  subscriptFive: "\u2085",
+  subscriptSix: "\u2086",
+  subscriptSeven: "\u2087",
+  subscriptEight: "\u2088",
+  subscriptNine: "\u2089",
+  oneHalf: "\xBD",
+  oneThird: "\u2153",
+  oneQuarter: "\xBC",
+  oneFifth: "\u2155",
+  oneSixth: "\u2159",
+  oneEighth: "\u215B",
+  twoThirds: "\u2154",
+  twoFifths: "\u2156",
+  threeQuarters: "\xBE",
+  threeFifths: "\u2157",
+  threeEighths: "\u215C",
+  fourFifths: "\u2158",
+  fiveSixths: "\u215A",
+  fiveEighths: "\u215D",
+  sevenEighths: "\u215E",
+  line: "\u2500",
+  lineBold: "\u2501",
+  lineDouble: "\u2550",
+  lineDashed0: "\u2504",
+  lineDashed1: "\u2505",
+  lineDashed2: "\u2508",
+  lineDashed3: "\u2509",
+  lineDashed4: "\u254C",
+  lineDashed5: "\u254D",
+  lineDashed6: "\u2574",
+  lineDashed7: "\u2576",
+  lineDashed8: "\u2578",
+  lineDashed9: "\u257A",
+  lineDashed10: "\u257C",
+  lineDashed11: "\u257E",
+  lineDashed12: "\u2212",
+  lineDashed13: "\u2013",
+  lineDashed14: "\u2010",
+  lineDashed15: "\u2043",
+  lineVertical: "\u2502",
+  lineVerticalBold: "\u2503",
+  lineVerticalDouble: "\u2551",
+  lineVerticalDashed0: "\u2506",
+  lineVerticalDashed1: "\u2507",
+  lineVerticalDashed2: "\u250A",
+  lineVerticalDashed3: "\u250B",
+  lineVerticalDashed4: "\u254E",
+  lineVerticalDashed5: "\u254F",
+  lineVerticalDashed6: "\u2575",
+  lineVerticalDashed7: "\u2577",
+  lineVerticalDashed8: "\u2579",
+  lineVerticalDashed9: "\u257B",
+  lineVerticalDashed10: "\u257D",
+  lineVerticalDashed11: "\u257F",
+  lineDownLeft: "\u2510",
+  lineDownLeftArc: "\u256E",
+  lineDownBoldLeftBold: "\u2513",
+  lineDownBoldLeft: "\u2512",
+  lineDownLeftBold: "\u2511",
+  lineDownDoubleLeftDouble: "\u2557",
+  lineDownDoubleLeft: "\u2556",
+  lineDownLeftDouble: "\u2555",
+  lineDownRight: "\u250C",
+  lineDownRightArc: "\u256D",
+  lineDownBoldRightBold: "\u250F",
+  lineDownBoldRight: "\u250E",
+  lineDownRightBold: "\u250D",
+  lineDownDoubleRightDouble: "\u2554",
+  lineDownDoubleRight: "\u2553",
+  lineDownRightDouble: "\u2552",
+  lineUpLeft: "\u2518",
+  lineUpLeftArc: "\u256F",
+  lineUpBoldLeftBold: "\u251B",
+  lineUpBoldLeft: "\u251A",
+  lineUpLeftBold: "\u2519",
+  lineUpDoubleLeftDouble: "\u255D",
+  lineUpDoubleLeft: "\u255C",
+  lineUpLeftDouble: "\u255B",
+  lineUpRight: "\u2514",
+  lineUpRightArc: "\u2570",
+  lineUpBoldRightBold: "\u2517",
+  lineUpBoldRight: "\u2516",
+  lineUpRightBold: "\u2515",
+  lineUpDoubleRightDouble: "\u255A",
+  lineUpDoubleRight: "\u2559",
+  lineUpRightDouble: "\u2558",
+  lineUpDownLeft: "\u2524",
+  lineUpBoldDownBoldLeftBold: "\u252B",
+  lineUpBoldDownBoldLeft: "\u2528",
+  lineUpDownLeftBold: "\u2525",
+  lineUpBoldDownLeftBold: "\u2529",
+  lineUpDownBoldLeftBold: "\u252A",
+  lineUpDownBoldLeft: "\u2527",
+  lineUpBoldDownLeft: "\u2526",
+  lineUpDoubleDownDoubleLeftDouble: "\u2563",
+  lineUpDoubleDownDoubleLeft: "\u2562",
+  lineUpDownLeftDouble: "\u2561",
+  lineUpDownRight: "\u251C",
+  lineUpBoldDownBoldRightBold: "\u2523",
+  lineUpBoldDownBoldRight: "\u2520",
+  lineUpDownRightBold: "\u251D",
+  lineUpBoldDownRightBold: "\u2521",
+  lineUpDownBoldRightBold: "\u2522",
+  lineUpDownBoldRight: "\u251F",
+  lineUpBoldDownRight: "\u251E",
+  lineUpDoubleDownDoubleRightDouble: "\u2560",
+  lineUpDoubleDownDoubleRight: "\u255F",
+  lineUpDownRightDouble: "\u255E",
+  lineDownLeftRight: "\u252C",
+  lineDownBoldLeftBoldRightBold: "\u2533",
+  lineDownLeftBoldRightBold: "\u252F",
+  lineDownBoldLeftRight: "\u2530",
+  lineDownBoldLeftBoldRight: "\u2531",
+  lineDownBoldLeftRightBold: "\u2532",
+  lineDownLeftRightBold: "\u252E",
+  lineDownLeftBoldRight: "\u252D",
+  lineDownDoubleLeftDoubleRightDouble: "\u2566",
+  lineDownDoubleLeftRight: "\u2565",
+  lineDownLeftDoubleRightDouble: "\u2564",
+  lineUpLeftRight: "\u2534",
+  lineUpBoldLeftBoldRightBold: "\u253B",
+  lineUpLeftBoldRightBold: "\u2537",
+  lineUpBoldLeftRight: "\u2538",
+  lineUpBoldLeftBoldRight: "\u2539",
+  lineUpBoldLeftRightBold: "\u253A",
+  lineUpLeftRightBold: "\u2536",
+  lineUpLeftBoldRight: "\u2535",
+  lineUpDoubleLeftDoubleRightDouble: "\u2569",
+  lineUpDoubleLeftRight: "\u2568",
+  lineUpLeftDoubleRightDouble: "\u2567",
+  lineUpDownLeftRight: "\u253C",
+  lineUpBoldDownBoldLeftBoldRightBold: "\u254B",
+  lineUpDownBoldLeftBoldRightBold: "\u2548",
+  lineUpBoldDownLeftBoldRightBold: "\u2547",
+  lineUpBoldDownBoldLeftRightBold: "\u254A",
+  lineUpBoldDownBoldLeftBoldRight: "\u2549",
+  lineUpBoldDownLeftRight: "\u2540",
+  lineUpDownBoldLeftRight: "\u2541",
+  lineUpDownLeftBoldRight: "\u253D",
+  lineUpDownLeftRightBold: "\u253E",
+  lineUpBoldDownBoldLeftRight: "\u2542",
+  lineUpDownLeftBoldRightBold: "\u253F",
+  lineUpBoldDownLeftBoldRight: "\u2543",
+  lineUpBoldDownLeftRightBold: "\u2544",
+  lineUpDownBoldLeftBoldRight: "\u2545",
+  lineUpDownBoldLeftRightBold: "\u2546",
+  lineUpDoubleDownDoubleLeftDoubleRightDouble: "\u256C",
+  lineUpDoubleDownDoubleLeftRight: "\u256B",
+  lineUpDownLeftDoubleRightDouble: "\u256A",
+  lineCross: "\u2573",
+  lineBackslash: "\u2572",
+  lineSlash: "\u2571"
+};
+var mainSymbols = {
+  ...common,
+  // The main symbols for those do not look that good on Ubuntu.
+  ...platform === "linux" ? {
+    circleQuestionMark: "?\u20DD",
+    questionMarkPrefix: "?\u20DD"
+  } : {
+    circleQuestionMark: "?",
+    questionMarkPrefix: "?"
+  },
+  tick: "\u2714",
+  info: "\u2139",
+  warning: "\u26A0",
+  cross: "\u2718",
+  squareSmall: "\u25FB",
+  squareSmallFilled: "\u25FC",
+  circle: "\u25EF",
+  circleFilled: "\u25C9",
+  circleDotted: "\u25CC",
+  circleDouble: "\u25CE",
+  circleCircle: "\u24DE",
+  circleCross: "\u24E7",
+  circlePipe: "\u24BE",
+  radioOn: "\u25C9",
+  radioOff: "\u25EF",
+  checkboxOn: "\u2612",
+  checkboxOff: "\u2610",
+  checkboxCircleOn: "\u24E7",
+  checkboxCircleOff: "\u24BE",
+  pointer: "\u276F",
+  triangleUpOutline: "\u25B3",
+  triangleLeft: "\u25C0",
+  triangleRight: "\u25B6",
+  lozenge: "\u25C6",
+  lozengeOutline: "\u25C7",
+  hamburger: "\u2630",
+  smiley: "\u32E1",
+  mustache: "\u0DF4",
+  star: "\u2605",
+  play: "\u25B6",
+  nodejs: "\u2B22",
+  oneSeventh: "\u2150",
+  oneNinth: "\u2151",
+  oneTenth: "\u2152"
+};
+var fallbackSymbols = {
+  ...common,
+  tick: "\u221A",
+  info: "i",
+  warning: "\u203C",
+  cross: "\xD7",
+  squareSmall: "\u25A1",
+  squareSmallFilled: "\u25A0",
+  circle: "( )",
+  circleFilled: "(*)",
+  circleDotted: "( )",
+  circleDouble: "( )",
+  circleCircle: "(\u25CB)",
+  circleCross: "(\xD7)",
+  circlePipe: "(\u2502)",
+  circleQuestionMark: "(?)",
+  radioOn: "(*)",
+  radioOff: "( )",
+  checkboxOn: "[\xD7]",
+  checkboxOff: "[ ]",
+  checkboxCircleOn: "(\xD7)",
+  checkboxCircleOff: "( )",
+  questionMarkPrefix: "\uFF1F",
+  pointer: ">",
+  triangleUpOutline: "\u2206",
+  triangleLeft: "\u25C4",
+  triangleRight: "\u25BA",
+  lozenge: "\u2666",
+  lozengeOutline: "\u25CA",
+  hamburger: "\u2261",
+  smiley: "\u263A",
+  mustache: "\u250C\u2500\u2510",
+  star: "\u2736",
+  play: "\u25BA",
+  nodejs: "\u2666",
+  oneSeventh: "1/7",
+  oneNinth: "1/9",
+  oneTenth: "1/10"
+};
+var shouldUseMain = isUnicodeSupported2();
+var figures = shouldUseMain ? mainSymbols : fallbackSymbols;
+var figures_default = figures;
+
+// ../../node_modules/ink-select-input/build/Indicator.js
+function Indicator({ isSelected = false }) {
+  return import_react48.default.createElement(Box_default, { marginRight: 1 }, isSelected ? import_react48.default.createElement(Text, { color: "blue" }, figures_default.pointer) : import_react48.default.createElement(Text, null, " "));
+}
+var Indicator_default = Indicator;
+
+// ../../node_modules/ink-select-input/build/Item.js
+init_esm_shims();
+var React32 = __toESM(require_react(), 1);
+function Item({ isSelected = false, label }) {
+  return React32.createElement(Text, { color: isSelected ? "blue" : void 0 }, label);
+}
+var Item_default = Item;
+
+// ../../node_modules/ink-select-input/build/SelectInput.js
+init_esm_shims();
+var import_react49 = __toESM(require_react(), 1);
+var import_react50 = __toESM(require_react(), 1);
+var import_lodash = __toESM(require_lodash(), 1);
+var import_arr_rotate = __toESM(require_arr_rotate(), 1);
+function SelectInput({ items = [], isFocused = true, initialIndex = 0, indicatorComponent = Indicator_default, itemComponent = Item_default, limit: customLimit, onSelect, onHighlight }) {
+  const hasLimit = typeof customLimit === "number" && items.length > customLimit;
+  const limit = hasLimit ? Math.min(customLimit, items.length) : items.length;
+  const lastIndex = limit - 1;
+  const [rotateIndex, setRotateIndex] = (0, import_react50.useState)(initialIndex > lastIndex ? lastIndex - initialIndex : 0);
+  const [selectedIndex, setSelectedIndex] = (0, import_react50.useState)(initialIndex ? initialIndex > lastIndex ? lastIndex : initialIndex : 0);
+  const previousItems = (0, import_react50.useRef)(items);
+  (0, import_react50.useEffect)(() => {
+    if (!(0, import_lodash.default)(previousItems.current.map((item) => item.value), items.map((item) => item.value))) {
+      setRotateIndex(0);
+      setSelectedIndex(0);
+    }
+    previousItems.current = items;
+  }, [items]);
+  use_input_default((0, import_react50.useCallback)((input, key) => {
+    if (input === "k" || key.upArrow) {
+      const lastIndex2 = (hasLimit ? limit : items.length) - 1;
+      const atFirstIndex = selectedIndex === 0;
+      const nextIndex = hasLimit ? selectedIndex : lastIndex2;
+      const nextRotateIndex = atFirstIndex ? rotateIndex + 1 : rotateIndex;
+      const nextSelectedIndex = atFirstIndex ? nextIndex : selectedIndex - 1;
+      setRotateIndex(nextRotateIndex);
+      setSelectedIndex(nextSelectedIndex);
+      const slicedItems2 = hasLimit ? (0, import_arr_rotate.default)(items, nextRotateIndex).slice(0, limit) : items;
+      if (typeof onHighlight === "function") {
+        onHighlight(slicedItems2[nextSelectedIndex]);
+      }
+    }
+    if (input === "j" || key.downArrow) {
+      const atLastIndex = selectedIndex === (hasLimit ? limit : items.length) - 1;
+      const nextIndex = hasLimit ? selectedIndex : 0;
+      const nextRotateIndex = atLastIndex ? rotateIndex - 1 : rotateIndex;
+      const nextSelectedIndex = atLastIndex ? nextIndex : selectedIndex + 1;
+      setRotateIndex(nextRotateIndex);
+      setSelectedIndex(nextSelectedIndex);
+      const slicedItems2 = hasLimit ? (0, import_arr_rotate.default)(items, nextRotateIndex).slice(0, limit) : items;
+      if (typeof onHighlight === "function") {
+        onHighlight(slicedItems2[nextSelectedIndex]);
+      }
+    }
+    if (key.return) {
+      const slicedItems2 = hasLimit ? (0, import_arr_rotate.default)(items, rotateIndex).slice(0, limit) : items;
+      if (typeof onSelect === "function") {
+        onSelect(slicedItems2[selectedIndex]);
+      }
+    }
+  }, [
+    hasLimit,
+    limit,
+    rotateIndex,
+    selectedIndex,
+    items,
+    onSelect,
+    onHighlight
+  ]), { isActive: isFocused });
+  const slicedItems = hasLimit ? (0, import_arr_rotate.default)(items, rotateIndex).slice(0, limit) : items;
+  return import_react49.default.createElement(Box_default, { flexDirection: "column" }, slicedItems.map((item, index) => {
+    const isSelected = index === selectedIndex;
+    return (
+      // @ts-expect-error - `key` can't be optional but `item.value` is generic T
+      import_react49.default.createElement(
+        Box_default,
+        { key: item.key ?? item.value },
+        import_react49.default.createElement(indicatorComponent, { isSelected }),
+        import_react49.default.createElement(itemComponent, { ...item, isSelected })
+      )
+    );
+  }));
+}
+var SelectInput_default = SelectInput;
+
+// ../cli-ui-kit/src/components/SelectInput/Indicator.tsx
+init_esm_shims();
+var import_react51 = __toESM(require_react(), 1);
+var Indicator2 = ({ isSelected }) => {
+  return /* @__PURE__ */ import_react51.default.createElement(Box_default, { width: 2 }, /* @__PURE__ */ import_react51.default.createElement(Text2, { skin: "info" }, /* @__PURE__ */ import_react51.default.createElement(RadioIcon, { selected: isSelected })));
+};
+
+// ../cli-ui-kit/src/components/SelectInput/Item.tsx
+init_esm_shims();
+var import_react52 = __toESM(require_react(), 1);
+var import_variant7 = __toESM(require_lib(), 1);
+
+// ../cli-ui-kit/src/components/SelectInput/types.ts
+init_esm_shims();
+var import_variant6 = __toESM(require_lib(), 1);
+var SelectOptionAvailability = (0, import_variant6.variant)({
+  Enabled: {},
+  Disabled: (0, import_variant6.fields)()
+});
+
+// ../cli-ui-kit/src/components/SelectInput/Item.tsx
+function Item2({
+  isSelected,
+  label,
+  value: { description, availability = SelectOptionAvailability.Enabled() }
+}) {
+  const isDisabled = (0, import_variant7.isType)(availability, SelectOptionAvailability.Disabled);
+  return /* @__PURE__ */ import_react52.default.createElement(Box_default, null, /* @__PURE__ */ import_react52.default.createElement(
+    Text2,
+    {
+      skin: isDisabled ? "secondary" : isSelected ? "info" : "standard",
+      strikethrough: !isSelected && isDisabled
+    },
+    label
+  ), isSelected && (0, import_variant7.match)(availability, {
+    Disabled: ({ reason }) => /* @__PURE__ */ import_react52.default.createElement(Box_default, { marginLeft: 1 }, reason ? /* @__PURE__ */ import_react52.default.createElement(Text2, { skin: "warning" }, "- disabled (", reason, ")") : /* @__PURE__ */ import_react52.default.createElement(Text2, { skin: "warning" }, "- disabled")),
+    Enabled: () => description && /* @__PURE__ */ import_react52.default.createElement(Box_default, { marginLeft: 1 }, /* @__PURE__ */ import_react52.default.createElement(Text2, { skin: "secondary" }, "- ", description))
+  }));
+}
+
+// ../cli-ui-kit/src/components/SelectInput/Placeholder.tsx
+init_esm_shims();
+var import_react53 = __toESM(require_react(), 1);
+var import_variant8 = __toESM(require_lib(), 1);
+function Placeholder2({ inputState }) {
+  return (0, import_variant8.match)(inputState, {
+    NotSubmitted: () => null,
+    Submitted: ({ value: value2 }) => /* @__PURE__ */ import_react53.default.createElement(Box_default, { marginBottom: 1 }, /* @__PURE__ */ import_react53.default.createElement(Text2, { skin: "secondary" }, /* @__PURE__ */ import_react53.default.createElement(SuccessIcon, null), " ", value2.title))
+  });
+}
+
+// ../cli-ui-kit/src/components/SelectInput/SelectInput.tsx
+function SelectInput2({
+  label,
+  info,
+  options,
+  onSubmit,
+  limit = 10,
+  initialIndex
+}) {
+  if (!options.length) {
+    throw new Error("SelectInput: options cannot be empty");
+  }
+  const [inputState, setInputState] = (0, import_react54.useState)(
+    () => InputState.NotSubmitted()
+  );
+  const handleHighlight = (0, import_react54.useCallback)(
+    ({ value: value2 }) => {
+      setInputState(InputState.NotSubmitted(value2));
+    },
+    []
+  );
+  const handleSelect = (0, import_react54.useCallback)(
+    ({ value: value2 }) => {
+      if (!(0, import_variant9.isType)(value2.availability, SelectOptionAvailability.Disabled)) {
+        setInputState(InputState.Submitted(value2));
+        onSubmit(value2);
+      }
+    },
+    [onSubmit]
+  );
+  const items = (0, import_react54.useMemo)(
+    () => options.map((option) => ({
+      key: typeof option.value === "string" ? option.value : option.key,
+      label: option.title,
+      value: option
+    })),
+    [options]
+  );
+  return /* @__PURE__ */ import_react54.default.createElement(import_react54.default.Fragment, null, /* @__PURE__ */ import_react54.default.createElement(Box_default, { marginLeft: -2, marginBottom: 1 }, /* @__PURE__ */ import_react54.default.createElement(Text2, null, /* @__PURE__ */ import_react54.default.createElement(InputLabel, null, label), " ", info && (0, import_variant9.isType)(inputState, InputState.NotSubmitted) && /* @__PURE__ */ import_react54.default.createElement(Text2, { skin: "secondary" }, info))), /* @__PURE__ */ import_react54.default.createElement(Placeholder2, { inputState }), (0, import_variant9.isType)(inputState, InputState.NotSubmitted) && /* @__PURE__ */ import_react54.default.createElement(Box_default, null, /* @__PURE__ */ import_react54.default.createElement(
+    SelectInput_default,
+    {
+      items,
+      limit,
+      itemComponent: Item2,
+      indicatorComponent: Indicator2,
+      onSelect: handleSelect,
+      onHighlight: handleHighlight,
+      initialIndex
+    }
+  )));
+}
+
 // ../cli-ui-kit/src/components/TextInput/Input.tsx
 init_esm_shims();
-var import_react47 = __toESM(require_react(), 1);
+var import_react55 = __toESM(require_react(), 1);
 var Input2 = ({
   onSubmit,
   onChange,
   placeholder,
   showCursor
 }) => {
-  const [currentValue, setCurrentValue] = (0, import_react47.useState)("");
-  return /* @__PURE__ */ import_react47.default.createElement(
+  const [currentValue, setCurrentValue] = (0, import_react55.useState)("");
+  return /* @__PURE__ */ import_react55.default.createElement(
     build_default,
     {
       showCursor,
@@ -11837,8 +12791,8 @@ init_esm_shims();
 
 // ../cli-ui-kit/src/components/TextInput/TextInput.tsx
 init_esm_shims();
-var import_react48 = __toESM(require_react(), 1);
-var import_variant6 = __toESM(require_lib(), 1);
+var import_react56 = __toESM(require_react(), 1);
+var import_variant10 = __toESM(require_lib(), 1);
 var TextInput2 = ({
   label,
   placeholder,
@@ -11846,12 +12800,12 @@ var TextInput2 = ({
   validate = () => true,
   inCreateFlow = false
 }) => {
-  const [inputState, setInputState] = (0, import_react48.useState)(
+  const [inputState, setInputState] = (0, import_react56.useState)(
     () => InputState.NotSubmitted(placeholder)
   );
-  const [isDirty, setIsDirty] = (0, import_react48.useState)(false);
-  const [validationError, setValidationError] = (0, import_react48.useState)();
-  const handleSubmit = (0, import_react48.useCallback)(
+  const [isDirty, setIsDirty] = (0, import_react56.useState)(false);
+  const [validationError, setValidationError] = (0, import_react56.useState)();
+  const handleSubmit = (0, import_react56.useCallback)(
     async (value2) => {
       setIsDirty(false);
       const validationResult = await validate(value2);
@@ -11866,13 +12820,13 @@ var TextInput2 = ({
     [onSubmit, validate]
   );
   const afterValidationError = Boolean(validationError && !isDirty);
-  return /* @__PURE__ */ import_react48.default.createElement(import_react48.default.Fragment, null, /* @__PURE__ */ import_react48.default.createElement(Box_default, { marginBottom: 1, marginLeft: inCreateFlow ? -2 : 0 }, /* @__PURE__ */ import_react48.default.createElement(Text2, null, /* @__PURE__ */ import_react48.default.createElement(
+  return /* @__PURE__ */ import_react56.default.createElement(import_react56.default.Fragment, null, /* @__PURE__ */ import_react56.default.createElement(Box_default, { marginBottom: 1, marginLeft: inCreateFlow ? -2 : 0 }, /* @__PURE__ */ import_react56.default.createElement(Text2, null, /* @__PURE__ */ import_react56.default.createElement(
     InputLabel,
     {
-      icon: /* @__PURE__ */ import_react48.default.createElement(Text2, { skin: "question" }, /* @__PURE__ */ import_react48.default.createElement(PointerIcon, { appearance: "triangle" }))
+      icon: /* @__PURE__ */ import_react56.default.createElement(Text2, { skin: "question" }, /* @__PURE__ */ import_react56.default.createElement(PointerIcon, { appearance: "triangle" }))
     },
     label
-  ), (0, import_variant6.isType)(inputState, InputState.NotSubmitted) && /* @__PURE__ */ import_react48.default.createElement(import_react48.default.Fragment, null, " ", /* @__PURE__ */ import_react48.default.createElement(Text2, { skin: afterValidationError ? "error" : "standard" }, /* @__PURE__ */ import_react48.default.createElement(
+  ), (0, import_variant10.isType)(inputState, InputState.NotSubmitted) && /* @__PURE__ */ import_react56.default.createElement(import_react56.default.Fragment, null, " ", /* @__PURE__ */ import_react56.default.createElement(Text2, { skin: afterValidationError ? "error" : "standard" }, /* @__PURE__ */ import_react56.default.createElement(
     Input2,
     {
       placeholder: inputState.value,
@@ -11880,33 +12834,33 @@ var TextInput2 = ({
       onChange: () => setIsDirty(true),
       showCursor: afterValidationError
     }
-  ))))), (0, import_variant6.isType)(inputState, InputState.Submitted) && /* @__PURE__ */ import_react48.default.createElement(Box_default, { marginBottom: 1 }, /* @__PURE__ */ import_react48.default.createElement(Text2, { skin: "secondary" }, /* @__PURE__ */ import_react48.default.createElement(SuccessIcon, null), " ", inputState.value)), validationError && /* @__PURE__ */ import_react48.default.createElement(Box_default, { columnGap: 1 }, /* @__PURE__ */ import_react48.default.createElement(Text2, { skin: "error" }, /* @__PURE__ */ import_react48.default.createElement(PointerIcon, { appearance: "exclamation" })), /* @__PURE__ */ import_react48.default.createElement(Text2, { skin: "error" }, validationError)));
+  ))))), (0, import_variant10.isType)(inputState, InputState.Submitted) && /* @__PURE__ */ import_react56.default.createElement(Box_default, { marginBottom: 1 }, /* @__PURE__ */ import_react56.default.createElement(Text2, { skin: "secondary" }, /* @__PURE__ */ import_react56.default.createElement(SuccessIcon, null), " ", inputState.value)), validationError && /* @__PURE__ */ import_react56.default.createElement(Box_default, { columnGap: 1 }, /* @__PURE__ */ import_react56.default.createElement(Text2, { skin: "error" }, /* @__PURE__ */ import_react56.default.createElement(PointerIcon, { appearance: "exclamation" })), /* @__PURE__ */ import_react56.default.createElement(Text2, { skin: "error" }, validationError)));
 };
 
 // ../cli-ui-kit/src/components/Key.tsx
 init_esm_shims();
-var import_react49 = __toESM(require_react(), 1);
+var import_react57 = __toESM(require_react(), 1);
 var Key = ({ value: value2, skin }) => {
   if (skin === "secondary") {
-    return /* @__PURE__ */ import_react49.default.createElement(Text, null, /* @__PURE__ */ import_react49.default.createElement(Text, { inverse: true }, " ", value2, " "), /* @__PURE__ */ import_react49.default.createElement(Text, null, "\u2591"));
+    return /* @__PURE__ */ import_react57.default.createElement(Text, null, /* @__PURE__ */ import_react57.default.createElement(Text, { inverse: true }, " ", value2, " "), /* @__PURE__ */ import_react57.default.createElement(Text, null, "\u2591"));
   }
-  return /* @__PURE__ */ import_react49.default.createElement(Text, null, /* @__PURE__ */ import_react49.default.createElement(Text, { backgroundColor: "blueBright" }, " ", value2, " "), /* @__PURE__ */ import_react49.default.createElement(Text, { color: "blueBright" }, "\u2591"));
+  return /* @__PURE__ */ import_react57.default.createElement(Text, null, /* @__PURE__ */ import_react57.default.createElement(Text, { backgroundColor: "blueBright" }, " ", value2, " "), /* @__PURE__ */ import_react57.default.createElement(Text, { color: "blueBright" }, "\u2591"));
 };
 
 // ../cli-ui-kit/src/components/ErrorDetails.tsx
 init_esm_shims();
-var import_react50 = __toESM(require_react(), 1);
+var import_react58 = __toESM(require_react(), 1);
 var ErrorDetails = ({
   message,
   explanation,
   hint
-}) => /* @__PURE__ */ import_react50.default.createElement(Box_default, { flexDirection: "column" }, /* @__PURE__ */ import_react50.default.createElement(Alert, { type: "error" }, message), explanation && /* @__PURE__ */ import_react50.default.createElement(Alert, { type: "warning" }, explanation), hint && /* @__PURE__ */ import_react50.default.createElement(Box_default, { paddingTop: 1 }, /* @__PURE__ */ import_react50.default.createElement(Alert, { type: "insight" }, hint)));
+}) => /* @__PURE__ */ import_react58.default.createElement(Box_default, { flexDirection: "column" }, /* @__PURE__ */ import_react58.default.createElement(Alert, { type: "error" }, message), explanation && /* @__PURE__ */ import_react58.default.createElement(Alert, { type: "warning" }, explanation), hint && /* @__PURE__ */ import_react58.default.createElement(Box_default, { paddingTop: 1 }, /* @__PURE__ */ import_react58.default.createElement(Alert, { type: "insight" }, hint)));
 
 // ../cli-ui-kit/src/components/Notification.tsx
 init_esm_shims();
-var import_react51 = __toESM(require_react(), 1);
+var import_react59 = __toESM(require_react(), 1);
 var Notification = ({ children }) => {
-  return /* @__PURE__ */ import_react51.default.createElement(Box_default, null, /* @__PURE__ */ import_react51.default.createElement(
+  return /* @__PURE__ */ import_react59.default.createElement(Box_default, null, /* @__PURE__ */ import_react59.default.createElement(
     Box_default,
     {
       padding: 1,
@@ -11921,11 +12875,11 @@ var Notification = ({ children }) => {
 
 // ../../node_modules/react-i18next/dist/es/Trans.js
 init_esm_shims();
-var import_react54 = __toESM(require_react(), 1);
+var import_react62 = __toESM(require_react(), 1);
 
 // ../../node_modules/react-i18next/dist/es/TransWithoutContext.js
 init_esm_shims();
-var import_react52 = __toESM(require_react(), 1);
+var import_react60 = __toESM(require_react(), 1);
 
 // ../../node_modules/html-parse-stringify/dist/html-parse-stringify.module.js
 init_esm_shims();
@@ -12124,7 +13078,7 @@ var getChildren = (node) => {
   const children = node.props?.children ?? node.children;
   return node.props?.i18nIsDynamicList ? getAsArray(children) : children;
 };
-var hasValidReactChildren = (children) => Array.isArray(children) && children.every(import_react52.isValidElement);
+var hasValidReactChildren = (children) => Array.isArray(children) && children.every(import_react60.isValidElement);
 var getAsArray = (data) => Array.isArray(data) ? data : [data];
 var mergeProps = (source, target) => {
   const newTarget = {
@@ -12143,7 +13097,7 @@ var nodesToString = (children, i18nOptions, i18n, i18nKey) => {
       stringNode += `${child}`;
       return;
     }
-    if ((0, import_react52.isValidElement)(child)) {
+    if ((0, import_react60.isValidElement)(child)) {
       const {
         props,
         type
@@ -12208,7 +13162,7 @@ var renderNodes = (children, targetString, i18n, i18nOptions, combinedTOpts, sho
     childrenArray.forEach((child) => {
       if (isString(child)) return;
       if (hasChildren(child)) getData(getChildren(child));
-      else if (isObject(child) && !(0, import_react52.isValidElement)(child)) Object.assign(data, child);
+      else if (isObject(child) && !(0, import_react60.isValidElement)(child)) Object.assign(data, child);
     });
   };
   getData(children);
@@ -12225,16 +13179,16 @@ var renderNodes = (children, targetString, i18n, i18nOptions, combinedTOpts, sho
   const pushTranslatedJSX = (child, inner, mem, i2, isVoid) => {
     if (child.dummy) {
       child.children = inner;
-      mem.push((0, import_react52.cloneElement)(child, {
+      mem.push((0, import_react60.cloneElement)(child, {
         key: i2
       }, isVoid ? void 0 : inner));
     } else {
-      mem.push(...import_react52.Children.map([child], (c2) => {
+      mem.push(...import_react60.Children.map([child], (c2) => {
         const props = {
           ...c2.props
         };
         delete props.i18nIsDynamicList;
-        return (0, import_react52.createElement)(c2.type, {
+        return (0, import_react60.createElement)(c2.type, {
           ...props,
           key: i2,
           ref: c2.ref
@@ -12254,7 +13208,7 @@ var renderNodes = (children, targetString, i18n, i18nOptions, combinedTOpts, sho
         const child = Object.keys(node.attrs).length !== 0 ? mergeProps({
           props: node.attrs
         }, tmp) : tmp;
-        const isElement = (0, import_react52.isValidElement)(child);
+        const isElement = (0, import_react60.isValidElement)(child);
         const isValidTranslationWithChildren = isElement && hasChildren(node, true) && !node.voidElement;
         const isEmptyTransWithHTML = emptyChildrenButNeedsHandling && isObject(child) && child.dummy && !isElement;
         const isKnownComponent = isObject(children) && Object.hasOwnProperty.call(children, node.name);
@@ -12273,12 +13227,12 @@ var renderNodes = (children, targetString, i18n, i18nOptions, combinedTOpts, sho
             pushTranslatedJSX(child, inner, mem, i2, node.voidElement);
           } else if (i18nOptions.transSupportBasicHtmlNodes && keepArray.indexOf(node.name) > -1) {
             if (node.voidElement) {
-              mem.push((0, import_react52.createElement)(node.name, {
+              mem.push((0, import_react60.createElement)(node.name, {
                 key: `${node.name}-${i2}`
               }));
             } else {
               const inner = mapAST(reactNodes, node.children, rootReactNode);
-              mem.push((0, import_react52.createElement)(node.name, {
+              mem.push((0, import_react60.createElement)(node.name, {
                 key: `${node.name}-${i2}`
               }, inner));
             }
@@ -12298,7 +13252,7 @@ var renderNodes = (children, targetString, i18n, i18nOptions, combinedTOpts, sho
         const wrapTextNodes = i18nOptions.transWrapTextNodes;
         const content = shouldUnescape ? i18nOptions.unescape(i18n.services.interpolator.interpolate(node.content, opts, i18n.language)) : i18n.services.interpolator.interpolate(node.content, opts, i18n.language);
         if (wrapTextNodes) {
-          mem.push((0, import_react52.createElement)(wrapTextNodes, {
+          mem.push((0, import_react60.createElement)(wrapTextNodes, {
             key: `${node.name}-${i2}`
           }, content));
         } else {
@@ -12316,16 +13270,16 @@ var renderNodes = (children, targetString, i18n, i18nOptions, combinedTOpts, sho
 };
 var fixComponentProps = (component, index, translation) => {
   const componentKey = component.key || index;
-  const comp = (0, import_react52.cloneElement)(component, {
+  const comp = (0, import_react60.cloneElement)(component, {
     key: componentKey
   });
   if (!comp.props || !comp.props.children || translation.indexOf(`${index}/>`) < 0 && translation.indexOf(`${index} />`) < 0) {
     return comp;
   }
   function Componentized() {
-    return (0, import_react52.createElement)(import_react52.Fragment, null, comp);
+    return (0, import_react60.createElement)(import_react60.Fragment, null, comp);
   }
-  return (0, import_react52.createElement)(Componentized);
+  return (0, import_react60.createElement)(Componentized);
 };
 var generateArrayComponents = (components, translation) => components.map((c2, index) => fixComponentProps(c2, index, translation));
 var generateObjectComponents = (components, translation) => {
@@ -12414,12 +13368,12 @@ function Trans({
   const generatedComponents = generateComponents(components, translation, i18n, i18nKey);
   const content = renderNodes(generatedComponents || children, translation, i18n, reactI18nextOptions, combinedTOpts, shouldUnescape);
   const useAsParent = parent ?? reactI18nextOptions.defaultTransParent;
-  return useAsParent ? (0, import_react52.createElement)(useAsParent, additionalProps, content) : content;
+  return useAsParent ? (0, import_react60.createElement)(useAsParent, additionalProps, content) : content;
 }
 
 // ../../node_modules/react-i18next/dist/es/context.js
 init_esm_shims();
-var import_react53 = __toESM(require_react(), 1);
+var import_react61 = __toESM(require_react(), 1);
 
 // ../../node_modules/react-i18next/dist/es/initReactI18next.js
 init_esm_shims();
@@ -12432,7 +13386,7 @@ var initReactI18next = {
 };
 
 // ../../node_modules/react-i18next/dist/es/context.js
-var I18nContext = (0, import_react53.createContext)();
+var I18nContext = (0, import_react61.createContext)();
 var ReportNamespaces = class {
   constructor() {
     this.usedNamespaces = {};
@@ -12467,7 +13421,7 @@ function Trans2({
   const {
     i18n: i18nFromContext,
     defaultNS: defaultNSFromContext
-  } = (0, import_react54.useContext)(I18nContext) || {};
+  } = (0, import_react62.useContext)(I18nContext) || {};
   const i18n = i18nFromProps || i18nFromContext || getI18n();
   const t3 = tFromProps || i18n?.t.bind(i18n);
   return Trans({
@@ -12490,16 +13444,16 @@ function Trans2({
 
 // ../../node_modules/react-i18next/dist/es/useTranslation.js
 init_esm_shims();
-var import_react55 = __toESM(require_react(), 1);
+var import_react63 = __toESM(require_react(), 1);
 var usePrevious = (value2, ignore) => {
-  const ref = (0, import_react55.useRef)();
-  (0, import_react55.useEffect)(() => {
+  const ref = (0, import_react63.useRef)();
+  (0, import_react63.useEffect)(() => {
     ref.current = ignore ? ref.current : value2;
   }, [value2, ignore]);
   return ref.current;
 };
 var alwaysNewT = (i18n, language, namespace, keyPrefix) => i18n.getFixedT(language, namespace, keyPrefix);
-var useMemoizedT = (i18n, language, namespace, keyPrefix) => (0, import_react55.useCallback)(alwaysNewT(i18n, language, namespace, keyPrefix), [i18n, language, namespace, keyPrefix]);
+var useMemoizedT = (i18n, language, namespace, keyPrefix) => (0, import_react63.useCallback)(alwaysNewT(i18n, language, namespace, keyPrefix), [i18n, language, namespace, keyPrefix]);
 var useTranslation = (ns, props = {}) => {
   const {
     i18n: i18nFromProps
@@ -12507,7 +13461,7 @@ var useTranslation = (ns, props = {}) => {
   const {
     i18n: i18nFromContext,
     defaultNS: defaultNSFromContext
-  } = (0, import_react55.useContext)(I18nContext) || {};
+  } = (0, import_react63.useContext)(I18nContext) || {};
   const i18n = i18nFromProps || i18nFromContext || getI18n();
   if (i18n && !i18n.reportNamespaces) i18n.reportNamespaces = new ReportNamespaces();
   if (!i18n) {
@@ -12540,12 +13494,12 @@ var useTranslation = (ns, props = {}) => {
   const memoGetT = useMemoizedT(i18n, props.lng || null, i18nOptions.nsMode === "fallback" ? namespaces : namespaces[0], keyPrefix);
   const getT = () => memoGetT;
   const getNewT = () => alwaysNewT(i18n, props.lng || null, i18nOptions.nsMode === "fallback" ? namespaces : namespaces[0], keyPrefix);
-  const [t3, setT] = (0, import_react55.useState)(getT);
+  const [t3, setT] = (0, import_react63.useState)(getT);
   let joinedNS = namespaces.join();
   if (props.lng) joinedNS = `${props.lng}${joinedNS}`;
   const previousJoinedNS = usePrevious(joinedNS);
-  const isMounted = (0, import_react55.useRef)(true);
-  (0, import_react55.useEffect)(() => {
+  const isMounted = (0, import_react63.useRef)(true);
+  (0, import_react63.useEffect)(() => {
     const {
       bindI18n,
       bindI18nStore
@@ -12576,7 +13530,7 @@ var useTranslation = (ns, props = {}) => {
       if (bindI18nStore && i18n) bindI18nStore.split(" ").forEach((e2) => i18n.store.off(e2, boundReset));
     };
   }, [i18n, joinedNS]);
-  (0, import_react55.useEffect)(() => {
+  (0, import_react63.useEffect)(() => {
     if (isMounted.current && ready) {
       setT(getT);
     }
@@ -12601,39 +13555,39 @@ init_esm_shims();
 
 // ../../node_modules/react-i18next/dist/es/withTranslation.js
 init_esm_shims();
-var import_react56 = __toESM(require_react(), 1);
+var import_react64 = __toESM(require_react(), 1);
 
 // ../../node_modules/react-i18next/dist/es/Translation.js
 init_esm_shims();
 
 // ../../node_modules/react-i18next/dist/es/I18nextProvider.js
 init_esm_shims();
-var import_react57 = __toESM(require_react(), 1);
+var import_react65 = __toESM(require_react(), 1);
 function I18nextProvider({
   i18n,
   defaultNS,
   children
 }) {
-  const value2 = (0, import_react57.useMemo)(() => ({
+  const value2 = (0, import_react65.useMemo)(() => ({
     i18n,
     defaultNS
   }), [i18n, defaultNS]);
-  return (0, import_react57.createElement)(I18nContext.Provider, {
+  return (0, import_react65.createElement)(I18nContext.Provider, {
     value: value2
   }, children);
 }
 
 // ../../node_modules/react-i18next/dist/es/withSSR.js
 init_esm_shims();
-var import_react59 = __toESM(require_react(), 1);
+var import_react67 = __toESM(require_react(), 1);
 
 // ../../node_modules/react-i18next/dist/es/useSSR.js
 init_esm_shims();
-var import_react58 = __toESM(require_react(), 1);
+var import_react66 = __toESM(require_react(), 1);
 
 // ../cli-i18n/src/I18nProvider.tsx
 init_esm_shims();
-var import_react60 = __toESM(require_react(), 1);
+var import_react68 = __toESM(require_react(), 1);
 
 // ../cli-i18n/src/create-i18n.ts
 init_esm_shims();
@@ -12872,9 +13826,9 @@ init_esm_shims();
 var DATE_TIME_REGEX = /(?:[Eec]{1,6}|G{1,5}|[Qq]{1,5}|(?:[yYur]+|U{1,5})|[ML]{1,5}|d{1,2}|D{1,3}|F{1}|[abB]{1,5}|[hkHK]{1,2}|w{1,2}|W{1}|m{1,2}|s{1,2}|[zZOvVxX]{1,4})(?=([^']*'[^']*')*[^']*$)/g;
 function parseDateTimeSkeleton(skeleton) {
   var result = {};
-  skeleton.replace(DATE_TIME_REGEX, function(match4) {
-    var len = match4.length;
-    switch (match4[0]) {
+  skeleton.replace(DATE_TIME_REGEX, function(match6) {
+    var len = match6.length;
+    switch (match6[0]) {
       case "G":
         result.era = len === 4 ? "long" : len === 5 ? "narrow" : "short";
         break;
@@ -14865,21 +15819,21 @@ if (REGEX_SUPPORTS_U_AND_Y) {
   matchIdentifierAtIndex = function matchIdentifierAtIndex2(s2, index) {
     var _a2;
     IDENTIFIER_PREFIX_RE_1.lastIndex = index;
-    var match4 = IDENTIFIER_PREFIX_RE_1.exec(s2);
-    return (_a2 = match4[1]) !== null && _a2 !== void 0 ? _a2 : "";
+    var match6 = IDENTIFIER_PREFIX_RE_1.exec(s2);
+    return (_a2 = match6[1]) !== null && _a2 !== void 0 ? _a2 : "";
   };
 } else {
   matchIdentifierAtIndex = function matchIdentifierAtIndex2(s2, index) {
-    var match4 = [];
+    var match6 = [];
     while (true) {
       var c2 = codePointAt(s2, index);
       if (c2 === void 0 || _isWhiteSpace(c2) || _isPatternSyntax(c2)) {
         break;
       }
-      match4.push(c2);
+      match6.push(c2);
       index += c2 >= 65536 ? 2 : 1;
     }
-    return fromCodePoint.apply(void 0, match4);
+    return fromCodePoint.apply(void 0, match6);
   };
 }
 var IDENTIFIER_PREFIX_RE_1;
@@ -16617,6 +17571,7 @@ var postProcessor = {
   }
 };
 var checkedLoadedFor = {};
+var shouldHandleAsObject = (res) => !isString2(res) && typeof res !== "boolean" && typeof res !== "number";
 var Translator = class _Translator extends EventEmitter {
   constructor(services) {
     let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
@@ -16715,17 +17670,29 @@ var Translator = class _Translator extends EventEmitter {
     let res = resolved?.res;
     const resUsedKey = resolved?.usedKey || key;
     const resExactUsedKey = resolved?.exactUsedKey || key;
-    const resType = Object.prototype.toString.apply(res);
     const noObject = ["[object Number]", "[object Function]", "[object RegExp]"];
     const joinArrays = options.joinArrays !== void 0 ? options.joinArrays : this.options.joinArrays;
     const handleAsObjectInI18nFormat = !this.i18nFormat || this.i18nFormat.handleAsObject;
-    const handleAsObject = !isString2(res) && typeof res !== "boolean" && typeof res !== "number";
-    if (handleAsObjectInI18nFormat && res && handleAsObject && noObject.indexOf(resType) < 0 && !(isString2(joinArrays) && Array.isArray(res))) {
+    const needsPluralHandling = options.count !== void 0 && !isString2(options.count);
+    const hasDefaultValue = _Translator.hasDefaultValue(options);
+    const defaultValueSuffix = needsPluralHandling ? this.pluralResolver.getSuffix(lng, options.count, options) : "";
+    const defaultValueSuffixOrdinalFallback = options.ordinal && needsPluralHandling ? this.pluralResolver.getSuffix(lng, options.count, {
+      ordinal: false
+    }) : "";
+    const needsZeroSuffixLookup = needsPluralHandling && !options.ordinal && options.count === 0;
+    const defaultValue = needsZeroSuffixLookup && options[`defaultValue${this.options.pluralSeparator}zero`] || options[`defaultValue${defaultValueSuffix}`] || options[`defaultValue${defaultValueSuffixOrdinalFallback}`] || options.defaultValue;
+    let resForObjHndl = res;
+    if (handleAsObjectInI18nFormat && !res && hasDefaultValue) {
+      resForObjHndl = defaultValue;
+    }
+    const handleAsObject = shouldHandleAsObject(resForObjHndl);
+    const resType = Object.prototype.toString.apply(resForObjHndl);
+    if (handleAsObjectInI18nFormat && resForObjHndl && handleAsObject && noObject.indexOf(resType) < 0 && !(isString2(joinArrays) && Array.isArray(resForObjHndl))) {
       if (!options.returnObjects && !this.options.returnObjects) {
         if (!this.options.returnedObjectHandler) {
           this.logger.warn("accessing an object - but returnObjects options is not enabled!");
         }
-        const r2 = this.options.returnedObjectHandler ? this.options.returnedObjectHandler(resUsedKey, res, {
+        const r2 = this.options.returnedObjectHandler ? this.options.returnedObjectHandler(resUsedKey, resForObjHndl, {
           ...options,
           ns: namespaces
         }) : `key '${key} (${this.language})' returned an object instead of string.`;
@@ -16737,20 +17704,31 @@ var Translator = class _Translator extends EventEmitter {
         return r2;
       }
       if (keySeparator) {
-        const resTypeIsArray = Array.isArray(res);
+        const resTypeIsArray = Array.isArray(resForObjHndl);
         const copy2 = resTypeIsArray ? [] : {};
         const newKeyToUse = resTypeIsArray ? resExactUsedKey : resUsedKey;
-        for (const m in res) {
-          if (Object.prototype.hasOwnProperty.call(res, m)) {
+        for (const m in resForObjHndl) {
+          if (Object.prototype.hasOwnProperty.call(resForObjHndl, m)) {
             const deepKey = `${newKeyToUse}${keySeparator}${m}`;
-            copy2[m] = this.translate(deepKey, {
-              ...options,
-              ...{
-                joinArrays: false,
-                ns: namespaces
-              }
-            });
-            if (copy2[m] === deepKey) copy2[m] = res[m];
+            if (hasDefaultValue && !res) {
+              copy2[m] = this.translate(deepKey, {
+                ...options,
+                defaultValue: shouldHandleAsObject(defaultValue) ? defaultValue[m] : void 0,
+                ...{
+                  joinArrays: false,
+                  ns: namespaces
+                }
+              });
+            } else {
+              copy2[m] = this.translate(deepKey, {
+                ...options,
+                ...{
+                  joinArrays: false,
+                  ns: namespaces
+                }
+              });
+            }
+            if (copy2[m] === deepKey) copy2[m] = resForObjHndl[m];
           }
         }
         res = copy2;
@@ -16761,14 +17739,6 @@ var Translator = class _Translator extends EventEmitter {
     } else {
       let usedDefault = false;
       let usedKey = false;
-      const needsPluralHandling = options.count !== void 0 && !isString2(options.count);
-      const hasDefaultValue = _Translator.hasDefaultValue(options);
-      const defaultValueSuffix = needsPluralHandling ? this.pluralResolver.getSuffix(lng, options.count, options) : "";
-      const defaultValueSuffixOrdinalFallback = options.ordinal && needsPluralHandling ? this.pluralResolver.getSuffix(lng, options.count, {
-        ordinal: false
-      }) : "";
-      const needsZeroSuffixLookup = needsPluralHandling && !options.ordinal && options.count === 0;
-      const defaultValue = needsZeroSuffixLookup && options[`defaultValue${this.options.pluralSeparator}zero`] || options[`defaultValue${defaultValueSuffix}`] || options[`defaultValue${defaultValueSuffixOrdinalFallback}`] || options.defaultValue;
       if (!this.isValidLookup(res) && hasDefaultValue) {
         usedDefault = true;
         res = defaultValue;
@@ -17283,7 +18253,7 @@ var Interpolator = class {
     this.nestingRegexp = getOrResetRegExp(this.nestingRegexp, `${this.nestingPrefix}(.+?)${this.nestingSuffix}`);
   }
   interpolate(str, data, lng, options) {
-    let match4;
+    let match6;
     let value2;
     let replaces;
     const defaultData = this.options && this.options.interpolation && this.options.interpolation.defaultVariables || {};
@@ -17317,17 +18287,17 @@ var Interpolator = class {
     }];
     todos.forEach((todo) => {
       replaces = 0;
-      while (match4 = todo.regex.exec(str)) {
-        const matchedVar = match4[1].trim();
+      while (match6 = todo.regex.exec(str)) {
+        const matchedVar = match6[1].trim();
         value2 = handleFormat(matchedVar);
         if (value2 === void 0) {
           if (typeof missingInterpolationHandler === "function") {
-            const temp = missingInterpolationHandler(str, match4, options);
+            const temp = missingInterpolationHandler(str, match6, options);
             value2 = isString2(temp) ? temp : "";
           } else if (options && Object.prototype.hasOwnProperty.call(options, matchedVar)) {
             value2 = "";
           } else if (skipOnVariables) {
-            value2 = match4[0];
+            value2 = match6[0];
             continue;
           } else {
             this.logger.warn(`missed to pass in variable ${matchedVar} for interpolating ${str}`);
@@ -17337,10 +18307,10 @@ var Interpolator = class {
           value2 = makeString(value2);
         }
         const safeValue = todo.safeValue(value2);
-        str = str.replace(match4[0], safeValue);
+        str = str.replace(match6[0], safeValue);
         if (skipOnVariables) {
           todo.regex.lastIndex += value2.length;
-          todo.regex.lastIndex -= match4[0].length;
+          todo.regex.lastIndex -= match6[0].length;
         } else {
           todo.regex.lastIndex = 0;
         }
@@ -17354,7 +18324,7 @@ var Interpolator = class {
   }
   nest(str, fc) {
     let options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-    let match4;
+    let match6;
     let value2;
     let clonedOptions;
     const handleHasOptions = (key, inheritedOptions) => {
@@ -17382,7 +18352,7 @@ var Interpolator = class {
       if (clonedOptions.defaultValue && clonedOptions.defaultValue.indexOf(this.prefix) > -1) delete clonedOptions.defaultValue;
       return key;
     };
-    while (match4 = this.nestingRegexp.exec(str)) {
+    while (match6 = this.nestingRegexp.exec(str)) {
       let formatters = [];
       clonedOptions = {
         ...options
@@ -17391,26 +18361,26 @@ var Interpolator = class {
       clonedOptions.applyPostProcessor = false;
       delete clonedOptions.defaultValue;
       let doReduce = false;
-      if (match4[0].indexOf(this.formatSeparator) !== -1 && !/{.*}/.test(match4[1])) {
-        const r2 = match4[1].split(this.formatSeparator).map((elem) => elem.trim());
-        match4[1] = r2.shift();
+      if (match6[0].indexOf(this.formatSeparator) !== -1 && !/{.*}/.test(match6[1])) {
+        const r2 = match6[1].split(this.formatSeparator).map((elem) => elem.trim());
+        match6[1] = r2.shift();
         formatters = r2;
         doReduce = true;
       }
-      value2 = fc(handleHasOptions.call(this, match4[1].trim(), clonedOptions), clonedOptions);
-      if (value2 && match4[0] === str && !isString2(value2)) return value2;
+      value2 = fc(handleHasOptions.call(this, match6[1].trim(), clonedOptions), clonedOptions);
+      if (value2 && match6[0] === str && !isString2(value2)) return value2;
       if (!isString2(value2)) value2 = makeString(value2);
       if (!value2) {
-        this.logger.warn(`missed to resolve ${match4[1]} for nesting ${str}`);
+        this.logger.warn(`missed to resolve ${match6[1]} for nesting ${str}`);
         value2 = "";
       }
       if (doReduce) {
         value2 = formatters.reduce((v, f) => this.format(v, f, options.lng, {
           ...options,
-          interpolationkey: match4[1].trim()
+          interpolationkey: match6[1].trim()
         }), value2.trim());
       }
-      str = str.replace(match4[0], value2);
+      str = str.replace(match6[0], value2);
       this.regexp.lastIndex = 0;
     }
     return str;
@@ -18390,21 +19360,21 @@ var I18nProvider = ({
   messages,
   i18n: initialI18n
 }) => {
-  const [i18n] = (0, import_react60.useState)(() => initialI18n ?? createI18n(messages));
-  return /* @__PURE__ */ import_react60.default.createElement(I18nextProvider, { i18n }, children);
+  const [i18n] = (0, import_react68.useState)(() => initialI18n ?? createI18n(messages));
+  return /* @__PURE__ */ import_react68.default.createElement(I18nextProvider, { i18n }, children);
 };
 
 // ../cli-i18n/src/index.ts
 init_esm_shims();
 
 export {
-  require_react,
   Box_default,
   Newline,
   use_input_default,
   UnorderedList,
   Text2 as Text,
   ConfirmInput,
+  SelectInput2 as SelectInput,
   TextInput2 as TextInput,
   Alert,
   Badge,
@@ -18427,17 +19397,6 @@ export {
 };
 /*! Bundled license information:
 
-react/cjs/react.production.min.js:
-  (**
-   * @license React
-   * react.production.min.js
-   *
-   * Copyright (c) Facebook, Inc. and its affiliates.
-   *
-   * This source code is licensed under the MIT license found in the
-   * LICENSE file in the root directory of this source tree.
-   *)
-
 scheduler/cjs/scheduler.production.min.js:
   (**
    * @license React
@@ -18471,4 +19430,4 @@ react-reconciler/cjs/react-reconciler-constants.production.min.js:
    * LICENSE file in the root directory of this source tree.
    *)
 */
-//# sourceMappingURL=chunk-XP2YHRIC.js.map
+//# sourceMappingURL=chunk-CIEBMSKA.js.map