citadel_cli 1.0.0

package/dist/citadel.es.js

@@ -0,0 +1,3039 @@
+var Wn = Object.defineProperty;
+var Vn = (r, n, t) => n in r ? Wn(r, n, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[n] = t;
+var A = (r, n, t) => Vn(r, typeof n != "symbol" ? n + "" : n, t);
+import fe, { useEffect as $, useMemo as ie, createContext as Kn, useContext as Re, useState as Y, useCallback as j, useRef as J } from "react";
+import Bn from "react-dom";
+var Se = { exports: {} }, re = {};
+/**
+ * @license React
+ * react-jsx-runtime.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.
+ */
+var Ze;
+function qn() {
+  if (Ze) return re;
+  Ze = 1;
+  var r = fe, n = Symbol.for("react.element"), t = Symbol.for("react.fragment"), o = Object.prototype.hasOwnProperty, i = r.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, a = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function l(d, h, w) {
+    var m, p = {}, u = null, y = null;
+    w !== void 0 && (u = "" + w), h.key !== void 0 && (u = "" + h.key), h.ref !== void 0 && (y = h.ref);
+    for (m in h) o.call(h, m) && !a.hasOwnProperty(m) && (p[m] = h[m]);
+    if (d && d.defaultProps) for (m in h = d.defaultProps, h) p[m] === void 0 && (p[m] = h[m]);
+    return { $$typeof: n, type: d, key: u, ref: y, props: p, _owner: i.current };
+  }
+  return re.Fragment = t, re.jsx = l, re.jsxs = l, re;
+}
+var oe = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.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.
+ */
+var Qe;
+function Jn() {
+  return Qe || (Qe = 1, process.env.NODE_ENV !== "production" && function() {
+    var r = fe, n = Symbol.for("react.element"), t = Symbol.for("react.portal"), o = Symbol.for("react.fragment"), i = Symbol.for("react.strict_mode"), a = Symbol.for("react.profiler"), l = Symbol.for("react.provider"), d = Symbol.for("react.context"), h = Symbol.for("react.forward_ref"), w = Symbol.for("react.suspense"), m = Symbol.for("react.suspense_list"), p = Symbol.for("react.memo"), u = Symbol.for("react.lazy"), y = Symbol.for("react.offscreen"), v = Symbol.iterator, b = "@@iterator";
+    function C(e) {
+      if (e === null || typeof e != "object")
+        return null;
+      var s = v && e[v] || e[b];
+      return typeof s == "function" ? s : null;
+    }
+    var f = r.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function _(e) {
+      {
+        for (var s = arguments.length, c = new Array(s > 1 ? s - 1 : 0), x = 1; x < s; x++)
+          c[x - 1] = arguments[x];
+        S("error", e, c);
+      }
+    }
+    function S(e, s, c) {
+      {
+        var x = f.ReactDebugCurrentFrame, R = x.getStackAddendum();
+        R !== "" && (s += "%s", c = c.concat([R]));
+        var N = c.map(function(E) {
+          return String(E);
+        });
+        N.unshift("Warning: " + s), Function.prototype.apply.call(console[e], console, N);
+      }
+    }
+    var I = !1, T = !1, D = !1, U = !1, Z = !1, Q;
+    Q = Symbol.for("react.module.reference");
+    function pn(e) {
+      return !!(typeof e == "string" || typeof e == "function" || e === o || e === a || Z || e === i || e === w || e === m || U || e === y || I || T || D || typeof e == "object" && e !== null && (e.$$typeof === u || e.$$typeof === p || e.$$typeof === l || e.$$typeof === d || e.$$typeof === h || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      e.$$typeof === Q || e.getModuleId !== void 0));
+    }
+    function gn(e, s, c) {
+      var x = e.displayName;
+      if (x)
+        return x;
+      var R = s.displayName || s.name || "";
+      return R !== "" ? c + "(" + R + ")" : c;
+    }
+    function Te(e) {
+      return e.displayName || "Context";
+    }
+    function M(e) {
+      if (e == null)
+        return null;
+      if (typeof e.tag == "number" && _("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof e == "function")
+        return e.displayName || e.name || null;
+      if (typeof e == "string")
+        return e;
+      switch (e) {
+        case o:
+          return "Fragment";
+        case t:
+          return "Portal";
+        case a:
+          return "Profiler";
+        case i:
+          return "StrictMode";
+        case w:
+          return "Suspense";
+        case m:
+          return "SuspenseList";
+      }
+      if (typeof e == "object")
+        switch (e.$$typeof) {
+          case d:
+            var s = e;
+            return Te(s) + ".Consumer";
+          case l:
+            var c = e;
+            return Te(c._context) + ".Provider";
+          case h:
+            return gn(e, e.render, "ForwardRef");
+          case p:
+            var x = e.displayName || null;
+            return x !== null ? x : M(e.type) || "Memo";
+          case u: {
+            var R = e, N = R._payload, E = R._init;
+            try {
+              return M(E(N));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var W = Object.assign, ee = 0, Ne, Ie, Ae, Pe, Oe, De, ze;
+    function Le() {
+    }
+    Le.__reactDisabledLog = !0;
+    function wn() {
+      {
+        if (ee === 0) {
+          Ne = console.log, Ie = console.info, Ae = console.warn, Pe = console.error, Oe = console.group, De = console.groupCollapsed, ze = console.groupEnd;
+          var e = {
+            configurable: !0,
+            enumerable: !0,
+            value: Le,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: e,
+            log: e,
+            warn: e,
+            error: e,
+            group: e,
+            groupCollapsed: e,
+            groupEnd: e
+          });
+        }
+        ee++;
+      }
+    }
+    function bn() {
+      {
+        if (ee--, ee === 0) {
+          var e = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: W({}, e, {
+              value: Ne
+            }),
+            info: W({}, e, {
+              value: Ie
+            }),
+            warn: W({}, e, {
+              value: Ae
+            }),
+            error: W({}, e, {
+              value: Pe
+            }),
+            group: W({}, e, {
+              value: Oe
+            }),
+            groupCollapsed: W({}, e, {
+              value: De
+            }),
+            groupEnd: W({}, e, {
+              value: ze
+            })
+          });
+        }
+        ee < 0 && _("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var pe = f.ReactCurrentDispatcher, ge;
+    function se(e, s, c) {
+      {
+        if (ge === void 0)
+          try {
+            throw Error();
+          } catch (R) {
+            var x = R.stack.trim().match(/\n( *(at )?)/);
+            ge = x && x[1] || "";
+          }
+        return `
+` + ge + e;
+      }
+    }
+    var we = !1, le;
+    {
+      var vn = typeof WeakMap == "function" ? WeakMap : Map;
+      le = new vn();
+    }
+    function Fe(e, s) {
+      if (!e || we)
+        return "";
+      {
+        var c = le.get(e);
+        if (c !== void 0)
+          return c;
+      }
+      var x;
+      we = !0;
+      var R = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var N;
+      N = pe.current, pe.current = null, wn();
+      try {
+        if (s) {
+          var E = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(E.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(E, []);
+            } catch (L) {
+              x = L;
+            }
+            Reflect.construct(e, [], E);
+          } else {
+            try {
+              E.call();
+            } catch (L) {
+              x = L;
+            }
+            e.call(E.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (L) {
+            x = L;
+          }
+          e();
+        }
+      } catch (L) {
+        if (L && x && typeof L.stack == "string") {
+          for (var k = L.stack.split(`
+`), z = x.stack.split(`
+`), P = k.length - 1, O = z.length - 1; P >= 1 && O >= 0 && k[P] !== z[O]; )
+            O--;
+          for (; P >= 1 && O >= 0; P--, O--)
+            if (k[P] !== z[O]) {
+              if (P !== 1 || O !== 1)
+                do
+                  if (P--, O--, O < 0 || k[P] !== z[O]) {
+                    var H = `
+` + k[P].replace(" at new ", " at ");
+                    return e.displayName && H.includes("<anonymous>") && (H = H.replace("<anonymous>", e.displayName)), typeof e == "function" && le.set(e, H), H;
+                  }
+                while (P >= 1 && O >= 0);
+              break;
+            }
+        }
+      } finally {
+        we = !1, pe.current = N, bn(), Error.prepareStackTrace = R;
+      }
+      var q = e ? e.displayName || e.name : "", V = q ? se(q) : "";
+      return typeof e == "function" && le.set(e, V), V;
+    }
+    function yn(e, s, c) {
+      return Fe(e, !1);
+    }
+    function xn(e) {
+      var s = e.prototype;
+      return !!(s && s.isReactComponent);
+    }
+    function ce(e, s, c) {
+      if (e == null)
+        return "";
+      if (typeof e == "function")
+        return Fe(e, xn(e));
+      if (typeof e == "string")
+        return se(e);
+      switch (e) {
+        case w:
+          return se("Suspense");
+        case m:
+          return se("SuspenseList");
+      }
+      if (typeof e == "object")
+        switch (e.$$typeof) {
+          case h:
+            return yn(e.render);
+          case p:
+            return ce(e.type, s, c);
+          case u: {
+            var x = e, R = x._payload, N = x._init;
+            try {
+              return ce(N(R), s, c);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var ne = Object.prototype.hasOwnProperty, $e = {}, Ue = f.ReactDebugCurrentFrame;
+    function de(e) {
+      if (e) {
+        var s = e._owner, c = ce(e.type, e._source, s ? s.type : null);
+        Ue.setExtraStackFrame(c);
+      } else
+        Ue.setExtraStackFrame(null);
+    }
+    function Cn(e, s, c, x, R) {
+      {
+        var N = Function.call.bind(ne);
+        for (var E in e)
+          if (N(e, E)) {
+            var k = void 0;
+            try {
+              if (typeof e[E] != "function") {
+                var z = Error((x || "React class") + ": " + c + " type `" + E + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof e[E] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw z.name = "Invariant Violation", z;
+              }
+              k = e[E](s, E, x, c, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (P) {
+              k = P;
+            }
+            k && !(k instanceof Error) && (de(R), _("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", x || "React class", c, E, typeof k), de(null)), k instanceof Error && !(k.message in $e) && ($e[k.message] = !0, de(R), _("Failed %s type: %s", c, k.message), de(null));
+          }
+      }
+    }
+    var _n = Array.isArray;
+    function be(e) {
+      return _n(e);
+    }
+    function Sn(e) {
+      {
+        var s = typeof Symbol == "function" && Symbol.toStringTag, c = s && e[Symbol.toStringTag] || e.constructor.name || "Object";
+        return c;
+      }
+    }
+    function kn(e) {
+      try {
+        return He(e), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function He(e) {
+      return "" + e;
+    }
+    function Me(e) {
+      if (kn(e))
+        return _("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Sn(e)), He(e);
+    }
+    var te = f.ReactCurrentOwner, En = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, Ye, We, ve;
+    ve = {};
+    function Rn(e) {
+      if (ne.call(e, "ref")) {
+        var s = Object.getOwnPropertyDescriptor(e, "ref").get;
+        if (s && s.isReactWarning)
+          return !1;
+      }
+      return e.ref !== void 0;
+    }
+    function jn(e) {
+      if (ne.call(e, "key")) {
+        var s = Object.getOwnPropertyDescriptor(e, "key").get;
+        if (s && s.isReactWarning)
+          return !1;
+      }
+      return e.key !== void 0;
+    }
+    function Tn(e, s) {
+      if (typeof e.ref == "string" && te.current && s && te.current.stateNode !== s) {
+        var c = M(te.current.type);
+        ve[c] || (_('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', M(te.current.type), e.ref), ve[c] = !0);
+      }
+    }
+    function Nn(e, s) {
+      {
+        var c = function() {
+          Ye || (Ye = !0, _("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", s));
+        };
+        c.isReactWarning = !0, Object.defineProperty(e, "key", {
+          get: c,
+          configurable: !0
+        });
+      }
+    }
+    function In(e, s) {
+      {
+        var c = function() {
+          We || (We = !0, _("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", s));
+        };
+        c.isReactWarning = !0, Object.defineProperty(e, "ref", {
+          get: c,
+          configurable: !0
+        });
+      }
+    }
+    var An = function(e, s, c, x, R, N, E) {
+      var k = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: n,
+        // Built-in properties that belong on the element
+        type: e,
+        key: s,
+        ref: c,
+        props: E,
+        // Record the component responsible for creating this element.
+        _owner: N
+      };
+      return k._store = {}, Object.defineProperty(k._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(k, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: x
+      }), Object.defineProperty(k, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: R
+      }), Object.freeze && (Object.freeze(k.props), Object.freeze(k)), k;
+    };
+    function Pn(e, s, c, x, R) {
+      {
+        var N, E = {}, k = null, z = null;
+        c !== void 0 && (Me(c), k = "" + c), jn(s) && (Me(s.key), k = "" + s.key), Rn(s) && (z = s.ref, Tn(s, R));
+        for (N in s)
+          ne.call(s, N) && !En.hasOwnProperty(N) && (E[N] = s[N]);
+        if (e && e.defaultProps) {
+          var P = e.defaultProps;
+          for (N in P)
+            E[N] === void 0 && (E[N] = P[N]);
+        }
+        if (k || z) {
+          var O = typeof e == "function" ? e.displayName || e.name || "Unknown" : e;
+          k && Nn(E, O), z && In(E, O);
+        }
+        return An(e, k, z, R, x, te.current, E);
+      }
+    }
+    var ye = f.ReactCurrentOwner, Ve = f.ReactDebugCurrentFrame;
+    function B(e) {
+      if (e) {
+        var s = e._owner, c = ce(e.type, e._source, s ? s.type : null);
+        Ve.setExtraStackFrame(c);
+      } else
+        Ve.setExtraStackFrame(null);
+    }
+    var xe;
+    xe = !1;
+    function Ce(e) {
+      return typeof e == "object" && e !== null && e.$$typeof === n;
+    }
+    function Ke() {
+      {
+        if (ye.current) {
+          var e = M(ye.current.type);
+          if (e)
+            return `
+
+Check the render method of \`` + e + "`.";
+        }
+        return "";
+      }
+    }
+    function On(e) {
+      return "";
+    }
+    var Be = {};
+    function Dn(e) {
+      {
+        var s = Ke();
+        if (!s) {
+          var c = typeof e == "string" ? e : e.displayName || e.name;
+          c && (s = `
+
+Check the top-level render call using <` + c + ">.");
+        }
+        return s;
+      }
+    }
+    function qe(e, s) {
+      {
+        if (!e._store || e._store.validated || e.key != null)
+          return;
+        e._store.validated = !0;
+        var c = Dn(s);
+        if (Be[c])
+          return;
+        Be[c] = !0;
+        var x = "";
+        e && e._owner && e._owner !== ye.current && (x = " It was passed a child from " + M(e._owner.type) + "."), B(e), _('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', c, x), B(null);
+      }
+    }
+    function Je(e, s) {
+      {
+        if (typeof e != "object")
+          return;
+        if (be(e))
+          for (var c = 0; c < e.length; c++) {
+            var x = e[c];
+            Ce(x) && qe(x, s);
+          }
+        else if (Ce(e))
+          e._store && (e._store.validated = !0);
+        else if (e) {
+          var R = C(e);
+          if (typeof R == "function" && R !== e.entries)
+            for (var N = R.call(e), E; !(E = N.next()).done; )
+              Ce(E.value) && qe(E.value, s);
+        }
+      }
+    }
+    function zn(e) {
+      {
+        var s = e.type;
+        if (s == null || typeof s == "string")
+          return;
+        var c;
+        if (typeof s == "function")
+          c = s.propTypes;
+        else if (typeof s == "object" && (s.$$typeof === h || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        s.$$typeof === p))
+          c = s.propTypes;
+        else
+          return;
+        if (c) {
+          var x = M(s);
+          Cn(c, e.props, "prop", x, e);
+        } else if (s.PropTypes !== void 0 && !xe) {
+          xe = !0;
+          var R = M(s);
+          _("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", R || "Unknown");
+        }
+        typeof s.getDefaultProps == "function" && !s.getDefaultProps.isReactClassApproved && _("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function Ln(e) {
+      {
+        for (var s = Object.keys(e.props), c = 0; c < s.length; c++) {
+          var x = s[c];
+          if (x !== "children" && x !== "key") {
+            B(e), _("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", x), B(null);
+            break;
+          }
+        }
+        e.ref !== null && (B(e), _("Invalid attribute `ref` supplied to `React.Fragment`."), B(null));
+      }
+    }
+    var Ge = {};
+    function Xe(e, s, c, x, R, N) {
+      {
+        var E = pn(e);
+        if (!E) {
+          var k = "";
+          (e === void 0 || typeof e == "object" && e !== null && Object.keys(e).length === 0) && (k += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var z = On();
+          z ? k += z : k += Ke();
+          var P;
+          e === null ? P = "null" : be(e) ? P = "array" : e !== void 0 && e.$$typeof === n ? (P = "<" + (M(e.type) || "Unknown") + " />", k = " Did you accidentally export a JSX literal instead of a component?") : P = typeof e, _("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", P, k);
+        }
+        var O = Pn(e, s, c, R, N);
+        if (O == null)
+          return O;
+        if (E) {
+          var H = s.children;
+          if (H !== void 0)
+            if (x)
+              if (be(H)) {
+                for (var q = 0; q < H.length; q++)
+                  Je(H[q], e);
+                Object.freeze && Object.freeze(H);
+              } else
+                _("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+            else
+              Je(H, e);
+        }
+        if (ne.call(s, "key")) {
+          var V = M(e), L = Object.keys(s).filter(function(Yn) {
+            return Yn !== "key";
+          }), _e = L.length > 0 ? "{key: someKey, " + L.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!Ge[V + _e]) {
+            var Mn = L.length > 0 ? "{" + L.join(": ..., ") + ": ...}" : "{}";
+            _(`A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`, _e, V, Mn, V), Ge[V + _e] = !0;
+          }
+        }
+        return e === o ? Ln(O) : zn(O), O;
+      }
+    }
+    function Fn(e, s, c) {
+      return Xe(e, s, c, !0);
+    }
+    function $n(e, s, c) {
+      return Xe(e, s, c, !1);
+    }
+    var Un = $n, Hn = Fn;
+    oe.Fragment = o, oe.jsx = Un, oe.jsxs = Hn;
+  }()), oe;
+}
+process.env.NODE_ENV === "production" ? Se.exports = qn() : Se.exports = Jn();
+var g = Se.exports, ke, ue = Bn;
+if (process.env.NODE_ENV === "production")
+  ke = ue.createRoot, ue.hydrateRoot;
+else {
+  var en = ue.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+  ke = function(r, n) {
+    en.usingClientEntryPoint = !0;
+    try {
+      return ue.createRoot(r, n);
+    } finally {
+      en.usingClientEntryPoint = !1;
+    }
+  };
+}
+const Gn = ({ onOpen: r, onClose: n, isVisible: t, showCitadelKey: o }) => {
+  $(() => {
+    const i = (a) => {
+      var l, d;
+      !t && a.key === o && !["input", "textarea"].includes(((d = (l = a.target) == null ? void 0 : l.tagName) == null ? void 0 : d.toLowerCase()) || "") && (a.preventDefault(), r()), t && a.key === "Escape" && (a.preventDefault(), n());
+    };
+    return document.addEventListener("keydown", i), () => document.removeEventListener("keydown", i);
+  }, [r, n, t, o]);
+}, Xn = "_container_141sr_3", Zn = "_innerContainer_141sr_19", Qn = "_inputSection_141sr_28", et = "_resizeHandle_141sr_35", nt = "_citadel_slideUp_141sr_64", tt = "_citadel_slideDown_141sr_68", nn = {
+  container: Xn,
+  innerContainer: Zn,
+  inputSection: Qn,
+  resizeHandle: et,
+  citadel_slideUp: nt,
+  citadel_slideDown: tt
+}, rt = (r) => {
+  const { isVisible: n, isClosing: t, onAnimationComplete: o } = r, i = ie(() => n ? t ? nn.slideDown : nn.slideUp : "", [n, t]);
+  return $(() => {
+    if (o) {
+      const l = setTimeout(() => {
+        o();
+      }, 200);
+      return () => clearTimeout(l);
+    }
+  }, [t, o]), {
+    style: ie(() => ({
+      opacity: n ? 1 : 0,
+      transform: n ? "translateY(0)" : t ? "translateY(100%)" : "translateY(-100%)",
+      transition: "opacity 200ms ease-in-out, transform 200ms ease-in-out"
+    }), [n, t]),
+    animationClass: i
+  };
+}, F = {
+  commandTimeoutMs: 1e4,
+  includeHelpCommand: !0,
+  maxHeight: "80vh",
+  minHeight: "200",
+  outputFontSize: "text-xs",
+  resetStateOnHide: !1,
+  showCitadelKey: ".",
+  cursorType: "bbs",
+  cursorColor: "var(--cursor-color, #fff)",
+  cursorSpeed: 530,
+  storage: {
+    type: "localStorage",
+    maxCommands: 100
+  }
+};
+class ln {
+  constructor(n) {
+    A(this, "config");
+    this.config = {
+      type: "localStorage",
+      maxCommands: 100,
+      ...n
+    };
+  }
+  /**
+   * Add a command to history, enforcing storage limits
+   */
+  async addCommand(n) {
+    const t = await this.getCommands();
+    for (t.push(n); t.length > this.config.maxCommands; )
+      t.shift();
+    await this.saveCommands(t);
+  }
+}
+class ot extends ln {
+  constructor(t) {
+    super(t);
+    A(this, "storageKey", "citadel_command_history");
+  }
+  async getCommands() {
+    try {
+      const t = window.localStorage.getItem(this.storageKey);
+      return t ? JSON.parse(t) : [];
+    } catch (t) {
+      return console.warn("Failed to load commands from localStorage:", t), [];
+    }
+  }
+  async clear() {
+    try {
+      window.localStorage.removeItem(this.storageKey);
+    } catch (t) {
+      console.warn("Failed to clear localStorage:", t);
+    }
+  }
+  async saveCommands(t) {
+    try {
+      const o = t.map((i) => ({
+        inputs: Array.isArray(i.inputs) ? [...i.inputs] : [],
+        timestamp: i.timestamp
+      }));
+      window.localStorage.setItem(this.storageKey, JSON.stringify(o));
+    } catch (o) {
+      throw console.warn("Failed to save commands to localStorage:", o), o;
+    }
+  }
+}
+class at extends ln {
+  constructor(t) {
+    super(t);
+    A(this, "commands", []);
+  }
+  async getCommands() {
+    return this.commands.map((t) => ({
+      inputs: Array.isArray(t.inputs) ? [...t.inputs] : [],
+      timestamp: t.timestamp
+    }));
+  }
+  async clear() {
+    this.commands = [];
+  }
+  async saveCommands(t) {
+    this.commands = t.map((o) => ({
+      inputs: Array.isArray(o.inputs) ? [...o.inputs] : [],
+      timestamp: o.timestamp
+    }));
+  }
+}
+const K = class K {
+  constructor() {
+    A(this, "currentStorage");
+  }
+  static getInstance() {
+    return K.instance || (K.instance = new K()), K.instance;
+  }
+  initializeStorage(n) {
+    if (!this.currentStorage)
+      try {
+        this.currentStorage = new ot(n);
+      } catch (t) {
+        console.warn("Failed to create storage, falling back to memory storage:", t), this.currentStorage = new at(n);
+      }
+  }
+  getStorage() {
+    if (!this.currentStorage)
+      throw new Error("Storage not initialized. Call initializeStorage first.");
+    return this.currentStorage;
+  }
+};
+A(K, "instance");
+let me = K;
+function cn(r, n = []) {
+  const t = {};
+  for (const [o, i] of Object.entries(r)) {
+    const a = [...n, o], l = a.join("."), d = {
+      description: i.description,
+      handler: i.handler,
+      argument: i.argument
+    };
+    (d.handler || d.argument || d.description) && (t[l] = {
+      description: d.description || `${l} command`,
+      ...d.handler && { handler: d.handler },
+      ...d.argument && { argument: d.argument }
+    });
+    const h = Object.keys(i).filter(
+      (w) => typeof i[w] == "object" && w !== "argument" && !["description", "handler"].includes(w)
+    );
+    if (h.length > 0) {
+      const w = h.reduce((m, p) => (m[p] = i[p], m), {});
+      Object.assign(t, cn(w, a));
+    }
+  }
+  return t;
+}
+const he = Kn({ config: F }), it = ({ config: r = F, commands: n, children: t }) => {
+  const [o, i] = fe.useState(), a = {
+    ...F,
+    ...r,
+    // Ensure nested objects are properly merged
+    storage: {
+      ...F.storage,
+      ...r.storage
+    },
+    // Ensure explicit values from config take precedence
+    cursorType: r.cursorType ?? F.cursorType,
+    cursorColor: r.cursorColor ?? F.cursorColor,
+    cursorSpeed: r.cursorSpeed ?? F.cursorSpeed,
+    showCitadelKey: r.showCitadelKey || "."
+  };
+  $(() => {
+    me.getInstance().initializeStorage(
+      a.storage ?? F.storage
+    ), i(me.getInstance().getStorage());
+  }, []);
+  const l = n ? cn(n) : void 0, d = {
+    config: a,
+    commands: l,
+    storage: o
+  };
+  return /* @__PURE__ */ g.jsx(he.Provider, { value: d, children: t });
+}, G = () => {
+  const r = Re(he);
+  if (r === void 0)
+    throw new Error("useCitadelConfig must be used within a CitadelConfigProvider");
+  return r.config;
+}, st = () => {
+  const r = Re(he);
+  if (r === void 0)
+    throw new Error("useCitadelCommands must be used within a CitadelConfigProvider");
+  return r.commands;
+}, dn = () => {
+  const r = Re(he);
+  if (r === void 0)
+    throw new Error("useCitadelStorage must be used within a CitadelConfigProvider");
+  return r.storage;
+};
+var ae = /* @__PURE__ */ ((r) => (r.Pending = "pending", r.Success = "success", r.Failure = "failure", r.Timeout = "timeout", r))(ae || {});
+class X {
+  constructor(n = Date.now()) {
+    A(this, "_status", "pending");
+    this.timestamp = n;
+  }
+  get status() {
+    return this._status;
+  }
+  markSuccess() {
+    this._status = "success";
+  }
+  markFailure() {
+    this._status = "failure";
+  }
+  markTimeout() {
+    this._status = "timeout";
+  }
+}
+class It extends X {
+  constructor(n, t) {
+    super(t), this.data = n;
+  }
+  render() {
+    return /* @__PURE__ */ g.jsx("pre", { className: "text-gray-200", children: JSON.stringify(this.data, null, 2) });
+  }
+}
+class un extends X {
+  constructor(n, t) {
+    super(t), this.text = n;
+  }
+  render() {
+    return /* @__PURE__ */ g.jsx("div", { className: "text-gray-200 whitespace-pre font-mono", children: this.text });
+  }
+}
+class lt extends X {
+  constructor(n, t) {
+    super(t), this.error = n, this.markFailure();
+  }
+  render() {
+    return /* @__PURE__ */ g.jsx("div", { className: "mt-1 text-red-400", children: this.error });
+  }
+}
+class ct extends X {
+  render() {
+    return /* @__PURE__ */ g.jsx("div", { className: "text-gray-400", children: "..." });
+  }
+}
+class At extends X {
+  constructor(n, t = "", o) {
+    super(o), this.imageUrl = n, this.altText = t;
+  }
+  render() {
+    return /* @__PURE__ */ g.jsx("div", { className: "my-2", children: /* @__PURE__ */ g.jsx(
+      "img",
+      {
+        src: this.imageUrl,
+        alt: this.altText,
+        className: "max-w-[400px] max-h-[300px] h-auto rounded-lg object-contain"
+      }
+    ) });
+  }
+}
+class dt {
+  constructor(n, t) {
+    A(this, "timestamp");
+    A(this, "command");
+    A(this, "result");
+    this.command = n, this.timestamp = Date.now(), this.result = t ?? new ct();
+  }
+}
+const je = async (r) => new un("");
+class Ee {
+  /**
+   * Creates a new CommandNode representing a command the user can enter. From a
+   * high level, a command is one or more words followed by an optional
+   * argument, and with an optional handler.
+   * 
+   * @param params Configuration parameters for the node
+   * @param params.fullPath Complete path from root to this node (e.g., ['service', 'deploy'])
+   * @param params.description Human-readable description of the command
+   * @param params.parent Optional parent node in the command hierarchy
+   * @param params.handler Optional async function to execute when command is invoked
+   * @param params.argument Optional argument definition for the command
+   * @throws {Error} If fullPath is empty or undefined
+   * 
+   */
+  constructor(n) {
+    A(this, "_fullPath");
+    A(this, "_description");
+    A(this, "_children");
+    A(this, "_argument");
+    A(this, "_handler");
+    A(this, "_parent");
+    A(this, "_signature");
+    if (!n.fullPath || n.fullPath.length === 0)
+      throw new Error("Command path cannot be empty");
+    this._fullPath = n.fullPath, this._description = n.description, this._children = /* @__PURE__ */ new Map(), this._argument = n.argument, this._handler = n.handler || je, this._parent = n.parent;
+  }
+  /**
+   * Gets the name of this command (last segment of the path)
+   */
+  get name() {
+    return this._fullPath[this._fullPath.length - 1];
+  }
+  /**
+   * Whether this is a leaf node (has no children)
+   */
+  get isLeaf() {
+    return this._children.size === 0;
+  }
+  /**
+   * Whether this command has a handler
+   */
+  get hasHandler() {
+    return this._handler !== void 0;
+  }
+  /**
+   * Whether this command requires an argument
+   */
+  get requiresArgument() {
+    return this._argument !== void 0;
+  }
+  /**
+   * Gets the parent node if it exists
+   */
+  get parent() {
+    return this._parent;
+  }
+  /**
+   * Gets the command's signature
+   */
+  get signature() {
+    return this._signature;
+  }
+  /**
+   * Sets the signature for this command based on the current command trie state
+   * @param trie The command trie to use for signature generation
+   */
+  setSignature(n) {
+    const t = n.buildSignatureForCommand(this);
+    this._signature = t.signature.join("");
+  }
+  /**
+   * Gets the map of child commands
+   */
+  get children() {
+    return this._children;
+  }
+  /**
+   * Whether this command has any children
+   */
+  get hasChildren() {
+    return this._children.size > 0;
+  }
+  /**
+   * Adds a child command
+   */
+  addChild(n, t) {
+    this._children.set(n, t);
+  }
+  /**
+   * Gets a child command by name
+   */
+  getChild(n) {
+    return this._children.get(n);
+  }
+  /**
+   * Gets the full path from root to this command
+   */
+  get fullPath() {
+    return this._fullPath;
+  }
+  /**
+   * Gets the command's description
+   */
+  get description() {
+    return this._description;
+  }
+  /**
+   * Gets the command's argument definition if it exists
+   */
+  get argument() {
+    return this._argument;
+  }
+  /**
+   * Sets the command's argument definition
+   */
+  set argument(n) {
+    this._argument = n;
+  }
+  /**
+   * Gets the command's handler
+   */
+  get handler() {
+    return this._handler;
+  }
+  /**
+   * Sets the command's handler
+   */
+  set handler(n) {
+    this._handler = n;
+  }
+}
+class ut {
+  /**
+   * Creates a new CommandTrie instance.
+   */
+  constructor() {
+    A(this, "_root");
+    this._root = new Ee({
+      fullPath: ["ROOT"],
+      description: "Root command node"
+    });
+  }
+  /**
+   * Adds a new command to the trie.
+   * 
+   * @param params Parameters for the command.
+   * @param params.path The path segments for the command (e.g., ['service', 'deploy'])
+   * @param params.description Description of what the command does
+   * @param params.handler Optional function to execute when command is invoked
+   * @param params.argument Optional argument definition for the command
+   * @throws {Error} If attempting to add a duplicate leaf command or a subcommand to a leaf
+   * 
+   */
+  addCommand(n) {
+    const { path: t, description: o, handler: i, argument: a } = n;
+    if (!(t != null && t.length))
+      throw new Error("Command path cannot be empty");
+    let l = this._root;
+    const d = t.length - 1;
+    for (let h = 0; h < t.length; h++) {
+      const w = t[h], m = h === d, p = t.slice(0, h + 1), u = l.children;
+      if (u.has(w)) {
+        const y = u.get(w);
+        if (m && y.isLeaf)
+          throw new Error(`Duplicate command: ${t.join(" ")}`);
+        if (!m && y.isLeaf)
+          throw new Error(`Cannot add subcommand to leaf command: ${t.slice(0, h + 1).join(" ")}`);
+        l = y;
+      } else {
+        const y = new Ee({
+          description: m ? o : `${w} commands`,
+          fullPath: p,
+          parent: l,
+          handler: m ? i : void 0,
+          argument: m ? a : void 0
+        });
+        l.addChild(w, y), l = y, this.setSignatures();
+      }
+    }
+  }
+  /**
+   * Retrieves a command from the trie.
+   * 
+   * @param path The path of the command.
+   * @returns The command node or undefined if not found.
+   */
+  getCommand(n) {
+    let t = this._root;
+    for (const o of n) {
+      const a = t.children.get(o);
+      if (!a)
+        return;
+      t = a;
+    }
+    return t;
+  }
+  /**
+   * Gets command completions for a given path.
+   * 
+   * @param path The path to get completions for.
+   * @returns An array of completion strings.
+   */
+  getCompletions(n) {
+    let t = this._root;
+    for (const l of n.slice(0, -1)) {
+      const h = t.children.get(l);
+      if (!h)
+        return [];
+      t = h;
+    }
+    const o = n[n.length - 1] || "", i = [], a = t.children;
+    if (n.length > 0) {
+      const l = a.get(o);
+      if (l)
+        return l.children.forEach((d, h) => {
+          i.push(h);
+        }), i;
+    }
+    return a.forEach((l, d) => {
+      d.startsWith(o) && i.push(d);
+    }), i;
+  }
+  /**
+   * Executes a command with the given path and arguments.
+   * @param path The command path
+   * @param args Arguments to pass to the command handler
+   * @returns The command result or undefined if command not found
+   * @throws Error if command validation fails
+   */
+  async executeCommand(n, t = []) {
+    var a;
+    const o = this.getCommand(n);
+    if (!o)
+      return;
+    if (!o.hasHandler)
+      throw new Error(`Command '${n.join(" ")}' is not executable`);
+    if (o.requiresArgument && t.length === 0)
+      throw new Error(`Command '${n.join(" ")}' requires argument: ${(a = o.argument) == null ? void 0 : a.name}`);
+    const i = o.handler;
+    if (!i)
+      throw new Error(`Command '${n.join(" ")}' has no handler`);
+    return await i(t);
+  }
+  /**
+   * Gets the root commands in the trie.
+   * 
+   * @returns An array of root command nodes.
+   */
+  getRootCommands() {
+    return Array.from(this._root.children.values());
+  }
+  /**
+   * Gets the leaf commands in the trie.
+   * 
+   * @returns An array of leaf command nodes.
+   */
+  getLeafCommands() {
+    const n = [], t = (o) => {
+      o.isLeaf ? n.push(o) : o.children.forEach((i) => {
+        t(i);
+      });
+    };
+    return this._root.children.forEach((o) => {
+      t(o);
+    }), n;
+  }
+  /**
+   * Retrieves a command using its unique signature.
+   * A signature is the minimal sequence of prefixes that uniquely identifies a command.
+   * 
+   * @param signature Array of minimal prefixes that uniquely identify the command
+   * @returns The matching command node or undefined if not found
+   * 
+   * @example
+   * // Will match 'image random cat' command
+   * getCommandBySignature(['i', 'r', 'c'])
+   * // Will match 'user show' command (not ambiguous with 'user status')
+   * getCommandBySignature(['u', 'sh'])
+   */
+  getCommandBySignature(n) {
+    if (!n.signature.length) return;
+    let t = this._root;
+    for (const o of n.signature) {
+      if (!o) return;
+      const i = Array.from(t.children.entries()).filter(([a]) => a.toLowerCase().startsWith(o.toLowerCase()));
+      if (i.length === 0)
+        return;
+      if (i.length > 1) {
+        const a = i.find(
+          ([l]) => l.toLowerCase() === o.toLowerCase()
+        );
+        if (!a)
+          return;
+        t = a[1];
+      } else
+        t = i[0][1];
+    }
+    return t === this._root ? void 0 : t;
+  }
+  /**
+   * Generates a minimal unique signature for a command node.
+   * The signature consists of the shortest prefixes that uniquely identify each segment
+   * in the path from root to this node.
+   * 
+   * @param command The command node to generate a signature for
+   * @returns Array of minimal prefixes that uniquely identify the command
+   * 
+   * @example
+   * // For commands: ['image', 'random', 'cat'] and ['image', 'random', 'dog']
+   * buildSignatureForCommand(catCommand) // returns ['i', 'r', 'c']
+   * // For commands: ['user', 'show'] and ['user', 'status']
+   * buildSignatureForCommand(showCommand) // returns ['u', 'sh']
+   */
+  buildSignatureForCommand(n) {
+    if (!n || n === this._root)
+      return { signature: [] };
+    const t = [];
+    let o = n;
+    const i = [];
+    for (; o && o !== this._root; )
+      i.unshift(o), o = o.parent;
+    o = this._root;
+    for (const a of i) {
+      const l = a.name, d = Array.from(o.children.keys());
+      let h = 1, w = !1;
+      for (; h <= l.length; ) {
+        const m = l.slice(0, h), p = m.toLowerCase(), u = d.filter(
+          (y) => y.toLowerCase().startsWith(p)
+        );
+        if (u.length === 1 && u[0].toLowerCase() === l.toLowerCase()) {
+          t.push(m), w = !0;
+          break;
+        }
+        h++;
+      }
+      w || t.push(l), o = a;
+    }
+    return { signature: t };
+  }
+  /**
+   * Validates the command trie structure for common errors.
+   * 
+   * Performs the following validations:
+   * 1. Checks for duplicate command paths
+   * 2. Ensures non-leaf nodes (nodes with children) use NoopHandler
+   * 3. Ensures non-leaf nodes don't have arguments
+   * 4. Verifies all nodes have a handler (either custom or NoopHandler)
+   * 5. Validates command path uniqueness
+   * 
+   * @returns An object containing:
+   *  - isValid: boolean indicating if the trie is valid
+   *  - errors: array of error messages describing any validation failures
+   * 
+   * @example
+   * ```typescript
+   * const result = commandTrie.validate();
+   * if (!result.isValid) {
+   *   console.error('Command trie validation failed:');
+   *   result.errors.forEach(error => console.error(error));
+   * }
+   * ```
+   */
+  /**
+   * Updates signatures for all nodes in the trie
+   */
+  setSignatures() {
+    const n = (t) => {
+      t !== this._root && t.setSignature(this), t.children.forEach((o) => n(o));
+    };
+    n(this._root);
+  }
+  validate() {
+    const n = [], t = /* @__PURE__ */ new Set(), o = (i) => {
+      if (i === this._root)
+        return;
+      const a = i.fullPath.join(" ");
+      t.has(a) && n.push(`Duplicate command path: ${a}`), t.add(a), i.handler || n.push(`Command missing handler: ${a}`);
+      const l = i.children;
+      l.size > 0 && (i.handler !== je && n.push(`Non-leaf command should use NoopHandler: ${a}`), i.argument && n.push(`Non-leaf command cannot have argument: ${a}`), l.forEach((d) => {
+        o(d);
+      }));
+    };
+    return this._root.children.forEach((i) => {
+      o(i);
+    }), {
+      isValid: n.length === 0,
+      errors: n
+    };
+  }
+}
+const mt = (r, n) => {
+  const t = async function(o) {
+    const i = r.getLeafCommands().filter((a) => a.name !== "help").map((a) => {
+      var d;
+      return `${a.fullPath.join(" ") + (a.requiresArgument ? ` <${(d = a.argument) == null ? void 0 : d.name}>` : "")} - ${a.description}`;
+    }).sort();
+    return n.includeHelpCommand && i.push("help - Show available commands"), new un(
+      i.length > 0 ? `Available Commands:
+` + i.join(`
+`) : "No commands available yet. Add some commands to get started!"
+    );
+  };
+  return ["help", new Ee({
+    fullPath: ["help"],
+    description: "Show available commands",
+    handler: t
+  })];
+}, mn = () => {
+  const r = G(), n = st();
+  return ie(() => {
+    const o = new ut();
+    if (r.includeHelpCommand) {
+      const [i, a] = mt(o, r);
+      o.addCommand({
+        path: [i],
+        description: a.description,
+        handler: a.handler,
+        argument: a.argument
+      });
+    }
+    return n && Object.entries(n).forEach(([i, a]) => {
+      o.addCommand({
+        path: i.split("."),
+        ...a
+      });
+    }), o;
+  }, [r.includeHelpCommand, n]);
+};
+function ft() {
+  const r = dn(), [n, t] = Y({
+    commands: [],
+    position: null,
+    savedInput: null
+  });
+  $(() => {
+    if (!r) return;
+    (async () => {
+      try {
+        const m = await r.getCommands();
+        t((p) => ({
+          ...p,
+          commands: m
+        }));
+      } catch (m) {
+        console.warn("Failed to load command history:", m);
+      }
+    })();
+  }, [r]);
+  const o = j(async (w) => {
+    if (r)
+      try {
+        await r.addCommand(w), t((m) => ({
+          ...m,
+          commands: [...m.commands, w],
+          position: null,
+          savedInput: null
+        }));
+      } catch (m) {
+        console.warn("Failed to save command to history:", m);
+      }
+  }, [r]), i = j(() => n.commands, [n.commands]), a = j((w, m) => {
+    if (n.commands.length === 0)
+      return { command: null, position: null };
+    n.position === null && w === "up" && t((u) => ({
+      ...u,
+      savedInput: m
+    }));
+    let p = null;
+    if (w === "up" ? n.position === null ? p = n.commands.length - 1 : n.position > 0 ? p = n.position - 1 : p = 0 : n.position === null || n.position >= n.commands.length - 1 ? p = null : p = n.position + 1, t((u) => ({
+      ...u,
+      position: p
+    })), p === null && n.savedInput) {
+      const u = {
+        inputs: n.savedInput.split(" ").filter(Boolean),
+        timestamp: Date.now()
+      };
+      return t((y) => ({
+        ...y,
+        savedInput: null
+      })), { command: u, position: null };
+    }
+    return {
+      command: p !== null ? n.commands[p] : null,
+      position: p
+    };
+  }, [n]), l = j((w) => {
+    t((m) => ({
+      ...m,
+      savedInput: w
+    }));
+  }, []), d = j(async () => {
+    try {
+      if (!r) return;
+      await r.clear(), t({
+        commands: [],
+        position: null,
+        savedInput: null
+      });
+    } catch (w) {
+      console.warn("Failed to clear command history:", w);
+    }
+  }, [r]);
+  return [n, {
+    addCommand: o,
+    getCommands: i,
+    navigateHistory: a,
+    saveInput: l,
+    clear: d
+  }];
+}
+function fn({ commandTrie: r } = {}) {
+  const [n, t] = Y("idle"), o = mn(), i = r || o, a = j((b, C) => b ? C.filter((f) => f.name.toLowerCase().startsWith(b.toLowerCase())) : C, []), l = j((b, C) => {
+    const f = a(b, C);
+    return f.length === 1 ? f[0].name : null;
+  }, [a]), d = j((b) => b != null && b.hasChildren ? Array.from(b.children.values()) : i.getRootCommands(), [i]), h = j((b, C) => a(b, C).length > 0, [a]), w = j((b, C, f) => {
+    i.getCommand(b) && (C.executeCommand(b, f || void 0), C.setCurrentInput(""), C.setIsEnteringArg(!1), t("idle"));
+  }, [i]), m = j((b, C, f) => {
+    if (f.setCurrentInput(b), !C.isEnteringArg) {
+      const _ = d(C.currentNode), S = l(b, _);
+      if (S && S !== b) {
+        const I = [...C.commandStack, S], T = i.getCommand(I);
+        T && (f.setCommandStack(I), f.setCurrentInput(""), f.setCurrentNode(T), !T.hasChildren && T.argument ? (f.setIsEnteringArg(!0), t("entering_argument")) : (f.setIsEnteringArg(!1), t("idle")));
+      }
+    }
+  }, [d, l, i]), p = j((b, C, f) => {
+    const { commandStack: _, currentInput: S, isEnteringArg: I, currentNode: T } = C;
+    switch (b.key) {
+      case "Tab":
+        if (b.preventDefault(), !I && S) {
+          const D = d(T), U = l(S, D);
+          U && f.setCurrentInput(U);
+        }
+        return;
+      case "Backspace":
+        if (S === "" && (b.preventDefault(), _.length > 0)) {
+          const D = _.slice(0, -1), U = D.length > 0 ? i.getCommand(D) : void 0;
+          f.setCommandStack(D), f.setCurrentNode(U), f.setIsEnteringArg(!1), t("entering_command");
+        }
+        return;
+      case "Enter":
+        if (b.preventDefault(), I && (T != null && T.handler))
+          S.trim() && w(_, f, [S.trim()]);
+        else if (!I && S) {
+          const D = d(T), U = a(S, D);
+          if (U.length === 1) {
+            const Z = U[0], Q = [..._, Z.name];
+            Z.argument ? (f.setCommandStack(Q), f.setCurrentNode(Z), f.setCurrentInput(""), f.setIsEnteringArg(!0), t("entering_argument")) : w(Q, f, void 0);
+          }
+        } else T && !T.argument && w(_, f, void 0);
+        return;
+    }
+    if (!I && !(T != null && T.argument)) {
+      const D = d(T);
+      if (!h(S + b.key, D)) {
+        b.preventDefault();
+        return;
+      }
+    }
+  }, [
+    d,
+    l,
+    a,
+    w,
+    i,
+    h
+  ]), u = j(async (b, C, f) => {
+    y(f);
+    let _ = [], S;
+    for (const I of b.inputs) {
+      const T = {
+        ...C,
+        commandStack: _,
+        currentNode: S
+      };
+      if (S != null && S.argument)
+        f.setIsEnteringArg(!0), f.setCurrentInput(I);
+      else {
+        const D = v(I, T);
+        D && (_ = [..._, D], f.setCommandStack(_), S = i.getCommand(_), f.setCurrentNode(S));
+      }
+    }
+  }, [m]), y = j((b) => {
+    b.setCurrentInput(""), b.setCommandStack([]), b.setCurrentNode(void 0), b.setIsEnteringArg(!1);
+  }, []), v = (b, C) => {
+    const f = d(C.currentNode);
+    return l(b, f) || "";
+  };
+  return {
+    handleInputChange: m,
+    handleKeyDown: p,
+    executeCommand: w,
+    inputState: n,
+    replayCommand: u,
+    // Expose internal functions for testing
+    findMatchingCommands: a,
+    getAutocompleteSuggestion: l,
+    getAvailableNodes: d,
+    isValidCommandInput: h
+  };
+}
+const ht = () => {
+  const r = mn(), n = G(), [t, o] = ft(), { replayCommand: i } = fn(), [a, l] = Y({
+    commandStack: [],
+    currentInput: "",
+    isEnteringArg: !1,
+    currentNode: void 0,
+    output: [],
+    validation: { isValid: !0 },
+    history: t
+  }), d = dn();
+  $(() => {
+  }, [d]), $(() => {
+    l((u) => ({
+      ...u,
+      history: t
+    }));
+  }, [t]);
+  const h = j(async (u, y) => {
+    const v = r.getCommand(u);
+    if (!v || !v.isLeaf) return;
+    const b = new dt([...u, ...y || []]);
+    l((C) => ({
+      ...C,
+      output: [...C.output, b]
+    })), l((C) => ({
+      ...C,
+      commandStack: [],
+      currentInput: "",
+      isEnteringArg: !1,
+      currentNode: void 0,
+      validation: { isValid: !0 }
+    }));
+    try {
+      const C = new Promise((S, I) => {
+        setTimeout(() => {
+          I(new Error("Request timed out"));
+        }, n.commandTimeoutMs);
+      }), f = await Promise.race([
+        v.handler(y || []),
+        C
+      ]);
+      if (!(f instanceof X))
+        throw new Error(
+          `The ${v.fullPath.join(".")} command returned an invalid result type. Commands must return an instance of a CommandResult.
+For example:
+   return new JsonCommandResult({ text: "Hello World" });
+Check the definition of the ${v.fullPath.join(".")} command and update the return type.`
+        );
+      f.markSuccess();
+      const _ = {
+        inputs: [...v.fullPath, ...y || []],
+        timestamp: Date.now()
+      };
+      try {
+        await o.addCommand(_), l((S) => ({
+          ...S,
+          output: S.output.map(
+            (I) => I.timestamp === b.timestamp ? { ...I, result: f } : I
+          )
+        }));
+      } catch (S) {
+        console.warn("Failed to save command to history:", S), l((I) => ({
+          ...I,
+          output: I.output.map(
+            (T) => T.timestamp === b.timestamp ? { ...T, result: f } : T
+          )
+        }));
+      }
+    } catch (C) {
+      const f = new lt(
+        C instanceof Error ? C.message : "Unknown error"
+      );
+      f.markSuccess(), l((_) => ({
+        ..._,
+        output: _.output.map(
+          (S) => S.timestamp === b.timestamp ? { ...S, result: f } : S
+        )
+      }));
+    }
+  }, [r, n.commandTimeoutMs, o, a]), w = j((u) => {
+    const { key: y } = u;
+    switch (y) {
+      case "ArrowUp":
+        u.preventDefault();
+        const { command: v } = o.navigateHistory("up", a.currentInput);
+        v && i(v, a, m);
+        break;
+      case "ArrowDown":
+        u.preventDefault();
+        const { command: b } = o.navigateHistory("down", a.currentInput);
+        b && i(b, a, m);
+        break;
+      case "Enter":
+        if (u.preventDefault(), a.history.position !== null) {
+          const C = a.history.commands[a.history.position];
+          h([...C.inputs]), l((f) => ({
+            ...f,
+            history: {
+              ...f.history,
+              position: null,
+              savedInput: null
+            }
+          }));
+        }
+        break;
+      case "Escape":
+        if (u.preventDefault(), a.history.position !== null) {
+          const C = a.history.savedInput || "";
+          l((f) => ({
+            ...f,
+            currentInput: C,
+            history: {
+              ...f.history,
+              position: null,
+              savedInput: null
+            }
+          }));
+        }
+        break;
+    }
+  }, [a.currentInput, a.history, o, h]);
+  $(() => (window.addEventListener("keydown", w), () => window.removeEventListener("keydown", w)), [w]);
+  const m = {
+    setCommandStack: j((u) => {
+      l((y) => ({
+        ...y,
+        commandStack: u,
+        currentNode: r.getCommand(u)
+      }));
+    }, [r]),
+    setCurrentInput: j((u) => {
+      l((y) => ({ ...y, currentInput: u }));
+    }, []),
+    setIsEnteringArg: j((u) => {
+      l((y) => ({ ...y, isEnteringArg: u }));
+    }, []),
+    setCurrentNode: j((u) => {
+      l((y) => ({ ...y, currentNode: u }));
+    }, []),
+    addOutput: j((u) => {
+      l((y) => ({
+        ...y,
+        output: [...y.output, u]
+      }));
+    }, []),
+    setValidation: j((u) => {
+      l((y) => ({ ...y, validation: u }));
+    }, []),
+    executeCommand: h,
+    executeHistoryCommand: j(async (u) => {
+      const v = a.history.commands[u];
+      if (!v) {
+        console.warn(`No command found at history index ${u}`);
+        return;
+      }
+      await i(v, a, m);
+    }, [a.history.commands, h]),
+    clearHistory: j(async () => {
+      try {
+        await o.clear();
+      } catch (u) {
+        console.warn("Failed to clear history:", u);
+      }
+    }, [o])
+  }, p = j(() => a.currentNode && a.currentNode.children ? Array.from(a.currentNode.children.values()) : r.getRootCommands(), [a.currentNode, r]);
+  return { state: a, actions: m, getAvailableCommands: p };
+}, pt = {
+  blink: {
+    character: "▋",
+    speed: 530,
+    color: "#fff"
+  },
+  spin: {
+    character: "⠋",
+    speed: 120,
+    color: "#fff"
+  },
+  solid: {
+    character: "▋",
+    speed: 0,
+    color: "#fff"
+  },
+  bbs: {
+    character: "|",
+    speed: 120,
+    color: "#fff"
+  }
+}, tn = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"], rn = ["|", "/", "-", "\\"], gt = ({
+  style: r = { type: "blink" },
+  isValid: n = !0,
+  errorMessage: t
+}) => {
+  const o = ie(() => ({
+    ...pt[r.type],
+    ...r
+  }), [r]), [i, a] = Y(!0), [l, d] = Y(0);
+  $(() => {
+    if (o.speed === 0) return;
+    const m = setInterval(() => {
+      o.type === "blink" ? a((p) => !p) : ["spin", "bbs"].includes(o.type) && d((p) => (p + 1) % (o.type === "bbs" ? rn.length : tn.length));
+    }, o.speed);
+    return () => clearInterval(m);
+  }, [o.type, o.speed]);
+  const h = ie(() => ({
+    color: n ? o.color : "#ff4444",
+    transition: "color 0.15s ease-in-out"
+  }), [n, o.color]), w = () => !n && t ? "✗" : ["spin", "bbs"].includes(o.type) ? (o.type === "bbs" ? rn : tn)[l] : o.type === "solid" || i ? o.character : " ";
+  return /* @__PURE__ */ g.jsx("div", { className: "relative inline-block", children: /* @__PURE__ */ g.jsx(
+    "span",
+    {
+      className: `command-cursor ${n ? "" : "animate-shake"}`,
+      style: h,
+      title: t,
+      children: w()
+    }
+  ) });
+}, wt = "_invalidInput_e9b9w_12", bt = "_shake_e9b9w_1", vt = "_flashBorder_e9b9w_1", yt = {
+  invalidInput: wt,
+  shake: bt,
+  flashBorder: vt
+}, xt = ({
+  state: r,
+  actions: n,
+  availableCommands: t
+}) => {
+  var u, y;
+  const o = J(null), { handleKeyDown: i, handleInputChange: a } = fn(), [l, d] = Y(!1), h = G(), w = (v) => {
+    var C, f;
+    const b = v.key === "Backspace" || v.key === "Escape" || v.key === "Tab" || v.key === "Shift" || v.key === "Control" || v.key === "Alt" || v.key === "Meta" || v.key === "ArrowLeft" || v.key === "ArrowRight" || v.key === "ArrowUp" || v.key === "ArrowDown" || v.key === "Enter";
+    if (!b && !r.isEnteringArg && !((C = r.currentNode) != null && C.hasChildren) && r.currentNode && !r.currentNode.requiresArgument && !r.currentNode.handler) {
+      v.preventDefault();
+      return;
+    }
+    if (!b && !r.isEnteringArg && !((f = r.currentNode) != null && f.requiresArgument)) {
+      const _ = r.currentNode ? Array.from(r.currentNode.children.values()) : t, S = (r.currentInput + v.key).toLowerCase();
+      if (!_.some(
+        (T) => T.name.toLowerCase().startsWith(S)
+      )) {
+        d(!0), setTimeout(() => d(!1), 300), v.preventDefault();
+        return;
+      }
+    }
+    i(v.nativeEvent, r, n);
+  }, m = (v) => {
+    a(v.target.value, r, n);
+  }, p = (v) => {
+    v.preventDefault();
+    const b = v.clipboardData.getData("text");
+    a(b, r, n);
+  };
+  return $(() => {
+    o.current && o.current.focus();
+  }, []), $(() => {
+    o.current && o.current.focus();
+  }, [r.commandStack]), /* @__PURE__ */ g.jsxs("div", { className: "flex flex-col w-full bg-gray-900 rounded-lg p-4", children: [
+    /* @__PURE__ */ g.jsxs("div", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ g.jsx("div", { className: "text-gray-400 font-mono", children: ">" }),
+      /* @__PURE__ */ g.jsxs("div", { className: "flex-1 font-mono flex items-center", children: [
+        /* @__PURE__ */ g.jsxs("span", { className: "text-blue-400 whitespace-pre", "data-testid": "user-input-area", children: [
+          r.commandStack.join(" "),
+          r.commandStack.length > 0 && " "
+        ] }),
+        /* @__PURE__ */ g.jsxs("div", { className: "relative flex-1", children: [
+          /* @__PURE__ */ g.jsx(
+            "input",
+            {
+              ref: o,
+              type: "text",
+              role: "textbox",
+              value: r.currentInput,
+              onChange: m,
+              onKeyDown: w,
+              onPaste: p,
+              "data-testid": "citadel-command-input",
+              className: `w-full bg-transparent outline-none text-gray-200 caret-transparent ${l ? yt.invalidInput : ""}`,
+              spellCheck: !1,
+              autoComplete: "off",
+              placeholder: r.isEnteringArg ? (y = (u = r.currentNode) == null ? void 0 : u.argument) == null ? void 0 : y.name : ""
+            }
+          ),
+          /* @__PURE__ */ g.jsx(
+            "div",
+            {
+              className: "absolute top-0 pointer-events-none",
+              style: {
+                left: `${r.currentInput.length}ch`,
+                transition: "left 0.05s ease-out"
+              },
+              children: /* @__PURE__ */ g.jsx(
+                gt,
+                {
+                  style: {
+                    type: h.cursorType ?? F.cursorType,
+                    color: h.cursorColor || F.cursorColor,
+                    speed: h.cursorSpeed || F.cursorSpeed
+                  },
+                  isValid: !l && r.validation.isValid,
+                  errorMessage: r.validation.message
+                }
+              )
+            }
+          )
+        ] })
+      ] })
+    ] }),
+    r.validation.message && /* @__PURE__ */ g.jsx("div", { className: `mt-2 text-sm ${r.validation.isValid ? "text-green-500" : "text-red-500"}`, children: r.validation.message })
+  ] });
+}, Ct = () => /* @__PURE__ */ g.jsx(
+  "div",
+  {
+    "data-testid": "spinner",
+    className: "animate-spin rounded-full h-4 w-4 border-2 border-gray-300 border-t-gray-600"
+  }
+), _t = ({
+  command: r,
+  timestamp: n,
+  status: t
+}) => /* @__PURE__ */ g.jsxs("div", { className: "flex items-center gap-2 font-mono text-sm", children: [
+  /* @__PURE__ */ g.jsxs("span", { className: "text-gray-200", children: [
+    "> ",
+    r
+  ] }),
+  /* @__PURE__ */ g.jsx("span", { className: "text-gray-400", children: "·" }),
+  /* @__PURE__ */ g.jsx("span", { className: "text-gray-500", children: n }),
+  t === ae.Pending && /* @__PURE__ */ g.jsx(Ct, {}),
+  t === ae.Success && /* @__PURE__ */ g.jsx(
+    "div",
+    {
+      "data-testid": "success-indicator",
+      className: "w-4 h-4 rounded-full bg-green-500"
+    }
+  ),
+  (t === ae.Timeout || t === ae.Failure) && /* @__PURE__ */ g.jsx(
+    "div",
+    {
+      "data-testid": "error-indicator",
+      className: "w-4 h-4 rounded-full bg-red-500"
+    }
+  )
+] }), St = ({ output: r, outputRef: n }) => {
+  const t = G(), o = j(() => {
+    if (n.current) {
+      const i = n.current;
+      requestAnimationFrame(() => {
+        i.scrollTop = i.scrollHeight;
+      });
+    }
+  }, [n]);
+  return $(() => {
+    if (o(), n.current) {
+      const i = n.current.getElementsByTagName("img"), a = i[i.length - 1];
+      if (a && !a.complete)
+        return a.addEventListener("load", o), () => a.removeEventListener("load", o);
+    }
+  }, [r, o]), /* @__PURE__ */ g.jsx(
+    "div",
+    {
+      ref: n,
+      className: "h-full overflow-y-auto border border-gray-700 rounded-lg p-3 text-left",
+      children: r.map((i, a) => /* @__PURE__ */ g.jsxs("div", { className: "mb-4 last:mb-0", children: [
+        /* @__PURE__ */ g.jsx(
+          _t,
+          {
+            command: i.command.join(" "),
+            timestamp: new Date(i.timestamp).toLocaleTimeString(),
+            status: i.result.status
+          }
+        ),
+        /* @__PURE__ */ g.jsx("pre", { className: `text-gray-200 whitespace-pre font-mono ${t.outputFontSize}`, children: i.result.render() })
+      ] }, a))
+    }
+  );
+}, kt = ({
+  state: r,
+  availableCommands: n
+}) => {
+  var h, w;
+  const t = G(), o = !r.isEnteringArg && n.length > 0, i = "h-12 mt-2 border-t border-gray-700 px-4", a = "text-gray-300 pt-2", l = ((h = r.currentNode) == null ? void 0 : h.isLeaf) && r.currentNode.handler === je && !r.currentNode.requiresArgument, d = fe.useMemo(() => {
+    if (!r.commandStack.length && t.includeHelpCommand) {
+      const m = n.filter((u) => u.name !== "help"), p = n.find((u) => u.name === "help");
+      return [...m, ...p ? [p] : []];
+    }
+    return n;
+  }, [n, r.commandStack, t.includeHelpCommand]);
+  return /* @__PURE__ */ g.jsx("div", { className: i, "data-testid": "available-commands", children: l ? /* @__PURE__ */ g.jsx("div", { className: a, children: r.currentNode ? /* @__PURE__ */ g.jsxs(g.Fragment, { children: [
+    /* @__PURE__ */ g.jsx("span", { className: "text-blue-400", children: r.currentNode.name }),
+    /* @__PURE__ */ g.jsxs("span", { className: "text-gray-400 ml-2", children: [
+      "- ",
+      r.currentNode.description
+    ] })
+  ] }) : null }) : o ? /* @__PURE__ */ g.jsx("div", { className: a, children: /* @__PURE__ */ g.jsx("div", { className: "flex flex-wrap gap-2", children: d.map((m) => {
+    const p = d.reduce((u, y) => {
+      if (y.name === m.name) return u;
+      let v = 0;
+      for (; v < m.name.length && v < y.name.length && m.name[v].toLowerCase() === y.name[v].toLowerCase(); )
+        v++;
+      return Math.max(u, v + 1);
+    }, 1);
+    return /* @__PURE__ */ g.jsx(
+      "div",
+      {
+        className: "px-2 py-1 rounded bg-gray-800 mr-2 last:mr-0",
+        children: /* @__PURE__ */ g.jsxs("span", { className: "font-mono text-white", children: [
+          /* @__PURE__ */ g.jsx("strong", { className: "underline", children: m.name.slice(0, p) }),
+          m.name.slice(p)
+        ] })
+      },
+      m.fullPath.join(".")
+    );
+  }) }) }) : /* @__PURE__ */ g.jsx("div", { className: a, children: (w = r.currentNode) == null ? void 0 : w.description }) });
+}, on = `:host {
+  --citadel-bg: rgb(17, 24, 39);
+  --citadel-text: rgba(255, 255, 255, 0.87);
+  --citadel-border: rgb(55, 65, 81);
+  --citadel-accent: #646cff;
+  --citadel-accent-hover: #535bf2;
+  --citadel-min-height: 200px;
+  --citadel-max-height: 80vh;
+  --citadel-default-height: 33vh;
+  --citadel-error: rgb(239, 68, 68);
+
+  height: var(--citadel-default-height);
+  max-height: var(--citadel-max-height);
+  min-height: var(--citadel-min-height);
+  width: 100%;
+
+  position: fixed;
+  bottom: 0;
+  left: 0;
+  right: 0;
+  overflow: hidden;
+
+  pointer-events: auto;
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+button {
+  border-radius: 8px;
+  border: 1px solid transparent;
+  padding: 0.6em 1.2em;
+  font-size: 1em;
+  font-weight: 500;
+  font-family: inherit;
+  background-color: #1a1a1a;
+  cursor: pointer;
+  transition: border-color 0.25s;
+}
+
+button:hover {
+  border-color: var(--citadel-accent);
+}
+
+button:focus,
+button:focus-visible {
+  outline: 4px auto -webkit-focus-ring-color;
+}
+
+a {
+  font-weight: 500;
+  color: var(--citadel-accent);
+  text-decoration: inherit;
+}
+
+a:hover {
+  color: var(--citadel-accent-hover);
+}
+
+.flex-1 { flex: 1 1 0%; }
+.flex-shrink-0 { flex-shrink: 0; }
+.min-h-0 { min-height: 0px; }
+.pt-3 { padding-top: 0.75rem; }
+.px-4 { padding-left: 1rem; padding-right: 1rem; }
+
+.h-full {
+  height: 100%;
+}
+.overflow-y-auto {
+  overflow-y: auto;
+}
+.border {
+  border-width: 1px;
+}
+.border-gray-700 {
+  --tw-border-opacity: 1;
+  border-color: rgb(55 65 81 / var(--tw-border-opacity, 1));
+}
+.rounded-lg {
+  border-radius: 0.5rem;
+}
+.p-3 {
+  padding: 0.75rem;
+}
+.text-left {
+  text-align: left;
+}
+
+`, an = `/* Keep only component-specific styles here */
+
+.container {
+  position: fixed;
+  height: var(--citadel-default-height);
+  min-height: var(--citadel-min-height);
+  max-height: var(--citadel-max-height);
+  background-color: var(--citadel-bg);
+  overflow: hidden;
+  width: 100%;
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+  bottom: 0;
+  left: 0;
+  right: 0;
+}
+
+.innerContainer {
+  height: 100%;
+  width: 100%;
+  display: flex;
+  flex-direction: column;
+  margin: 0;
+  padding: 0;
+}
+
+.inputSection {
+  border-top: 1px solid var(--citadel-border);
+  padding: 1rem;
+  margin: 0;
+  box-sizing: border-box;
+}
+
+.resizeHandle {
+  width: 100%;
+  height: 6px;
+  background: transparent;
+  cursor: ns-resize;
+  position: absolute;
+  top: -3px;
+  left: 0;
+  right: 0;
+  z-index: 10;
+  user-select: none;
+  -webkit-user-select: none;
+  pointer-events: all;
+}
+
+.resizeHandle:hover {
+  background: rgba(255, 255, 255, 0.1);
+}
+
+@keyframes citadel_slideUp {
+  from { transform: translateY(100%); }
+  to { transform: translateY(0); }
+}
+
+@keyframes citadel_slideDown {
+  from { transform: translateY(0); }
+  to { transform: translateY(100%); }
+}
+
+.citadel_slideUp {
+  animation: citadel_slideUp 0.2s ease-out forwards;
+}
+
+.citadel_slideDown {
+  animation: citadel_slideDown 0.2s ease-out forwards;
+}
+`, sn = `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+`, Et = `*, ::before, ::after {
+  --tw-border-spacing-x: 0;
+  --tw-border-spacing-y: 0;
+  --tw-translate-x: 0;
+  --tw-translate-y: 0;
+  --tw-rotate: 0;
+  --tw-skew-x: 0;
+  --tw-skew-y: 0;
+  --tw-scale-x: 1;
+  --tw-scale-y: 1;
+  --tw-pan-x:  ;
+  --tw-pan-y:  ;
+  --tw-pinch-zoom:  ;
+  --tw-scroll-snap-strictness: proximity;
+  --tw-gradient-from-position:  ;
+  --tw-gradient-via-position:  ;
+  --tw-gradient-to-position:  ;
+  --tw-ordinal:  ;
+  --tw-slashed-zero:  ;
+  --tw-numeric-figure:  ;
+  --tw-numeric-spacing:  ;
+  --tw-numeric-fraction:  ;
+  --tw-ring-inset:  ;
+  --tw-ring-offset-width: 0px;
+  --tw-ring-offset-color: #fff;
+  --tw-ring-color: rgb(59 130 246 / 0.5);
+  --tw-ring-offset-shadow: 0 0 #0000;
+  --tw-ring-shadow: 0 0 #0000;
+  --tw-shadow: 0 0 #0000;
+  --tw-shadow-colored: 0 0 #0000;
+  --tw-blur:  ;
+  --tw-brightness:  ;
+  --tw-contrast:  ;
+  --tw-grayscale:  ;
+  --tw-hue-rotate:  ;
+  --tw-invert:  ;
+  --tw-saturate:  ;
+  --tw-sepia:  ;
+  --tw-drop-shadow:  ;
+  --tw-backdrop-blur:  ;
+  --tw-backdrop-brightness:  ;
+  --tw-backdrop-contrast:  ;
+  --tw-backdrop-grayscale:  ;
+  --tw-backdrop-hue-rotate:  ;
+  --tw-backdrop-invert:  ;
+  --tw-backdrop-opacity:  ;
+  --tw-backdrop-saturate:  ;
+  --tw-backdrop-sepia:  ;
+  --tw-contain-size:  ;
+  --tw-contain-layout:  ;
+  --tw-contain-paint:  ;
+  --tw-contain-style:  ;
+}
+
+::backdrop {
+  --tw-border-spacing-x: 0;
+  --tw-border-spacing-y: 0;
+  --tw-translate-x: 0;
+  --tw-translate-y: 0;
+  --tw-rotate: 0;
+  --tw-skew-x: 0;
+  --tw-skew-y: 0;
+  --tw-scale-x: 1;
+  --tw-scale-y: 1;
+  --tw-pan-x:  ;
+  --tw-pan-y:  ;
+  --tw-pinch-zoom:  ;
+  --tw-scroll-snap-strictness: proximity;
+  --tw-gradient-from-position:  ;
+  --tw-gradient-via-position:  ;
+  --tw-gradient-to-position:  ;
+  --tw-ordinal:  ;
+  --tw-slashed-zero:  ;
+  --tw-numeric-figure:  ;
+  --tw-numeric-spacing:  ;
+  --tw-numeric-fraction:  ;
+  --tw-ring-inset:  ;
+  --tw-ring-offset-width: 0px;
+  --tw-ring-offset-color: #fff;
+  --tw-ring-color: rgb(59 130 246 / 0.5);
+  --tw-ring-offset-shadow: 0 0 #0000;
+  --tw-ring-shadow: 0 0 #0000;
+  --tw-shadow: 0 0 #0000;
+  --tw-shadow-colored: 0 0 #0000;
+  --tw-blur:  ;
+  --tw-brightness:  ;
+  --tw-contrast:  ;
+  --tw-grayscale:  ;
+  --tw-hue-rotate:  ;
+  --tw-invert:  ;
+  --tw-saturate:  ;
+  --tw-sepia:  ;
+  --tw-drop-shadow:  ;
+  --tw-backdrop-blur:  ;
+  --tw-backdrop-brightness:  ;
+  --tw-backdrop-contrast:  ;
+  --tw-backdrop-grayscale:  ;
+  --tw-backdrop-hue-rotate:  ;
+  --tw-backdrop-invert:  ;
+  --tw-backdrop-opacity:  ;
+  --tw-backdrop-saturate:  ;
+  --tw-backdrop-sepia:  ;
+  --tw-contain-size:  ;
+  --tw-contain-layout:  ;
+  --tw-contain-paint:  ;
+  --tw-contain-style:  ;
+}/*
+! tailwindcss v3.4.15 | MIT License | https://tailwindcss.com
+*//*
+1. Prevent padding and border from affecting element width. (https://github.com/mozdevs/cssremedy/issues/4)
+2. Allow adding a border to an element by just adding a border-width. (https://github.com/tailwindcss/tailwindcss/pull/116)
+*/
+
+*,
+::before,
+::after {
+  box-sizing: border-box; /* 1 */
+  border-width: 0; /* 2 */
+  border-style: solid; /* 2 */
+  border-color: #e5e7eb; /* 2 */
+}
+
+::before,
+::after {
+  --tw-content: '';
+}
+
+/*
+1. Use a consistent sensible line-height in all browsers.
+2. Prevent adjustments of font size after orientation changes in iOS.
+3. Use a more readable tab size.
+4. Use the user's configured \`sans\` font-family by default.
+5. Use the user's configured \`sans\` font-feature-settings by default.
+6. Use the user's configured \`sans\` font-variation-settings by default.
+7. Disable tap highlights on iOS
+*/
+
+html,
+:host {
+  line-height: 1.5; /* 1 */
+  -webkit-text-size-adjust: 100%; /* 2 */
+  -moz-tab-size: 4; /* 3 */
+  -o-tab-size: 4;
+     tab-size: 4; /* 3 */
+  font-family: ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"; /* 4 */
+  font-feature-settings: normal; /* 5 */
+  font-variation-settings: normal; /* 6 */
+  -webkit-tap-highlight-color: transparent; /* 7 */
+}
+
+/*
+1. Remove the margin in all browsers.
+2. Inherit line-height from \`html\` so users can set them as a class directly on the \`html\` element.
+*/
+
+body {
+  margin: 0; /* 1 */
+  line-height: inherit; /* 2 */
+}
+
+/*
+1. Add the correct height in Firefox.
+2. Correct the inheritance of border color in Firefox. (https://bugzilla.mozilla.org/show_bug.cgi?id=190655)
+3. Ensure horizontal rules are visible by default.
+*/
+
+hr {
+  height: 0; /* 1 */
+  color: inherit; /* 2 */
+  border-top-width: 1px; /* 3 */
+}
+
+/*
+Add the correct text decoration in Chrome, Edge, and Safari.
+*/
+
+abbr:where([title]) {
+  -webkit-text-decoration: underline dotted;
+          text-decoration: underline dotted;
+}
+
+/*
+Remove the default font size and weight for headings.
+*/
+
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  font-size: inherit;
+  font-weight: inherit;
+}
+
+/*
+Reset links to optimize for opt-in styling instead of opt-out.
+*/
+
+a {
+  color: inherit;
+  text-decoration: inherit;
+}
+
+/*
+Add the correct font weight in Edge and Safari.
+*/
+
+b,
+strong {
+  font-weight: bolder;
+}
+
+/*
+1. Use the user's configured \`mono\` font-family by default.
+2. Use the user's configured \`mono\` font-feature-settings by default.
+3. Use the user's configured \`mono\` font-variation-settings by default.
+4. Correct the odd \`em\` font sizing in all browsers.
+*/
+
+code,
+kbd,
+samp,
+pre {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace; /* 1 */
+  font-feature-settings: normal; /* 2 */
+  font-variation-settings: normal; /* 3 */
+  font-size: 1em; /* 4 */
+}
+
+/*
+Add the correct font size in all browsers.
+*/
+
+small {
+  font-size: 80%;
+}
+
+/*
+Prevent \`sub\` and \`sup\` elements from affecting the line height in all browsers.
+*/
+
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+/*
+1. Remove text indentation from table contents in Chrome and Safari. (https://bugs.chromium.org/p/chromium/issues/detail?id=999088, https://bugs.webkit.org/show_bug.cgi?id=201297)
+2. Correct table border color inheritance in all Chrome and Safari. (https://bugs.chromium.org/p/chromium/issues/detail?id=935729, https://bugs.webkit.org/show_bug.cgi?id=195016)
+3. Remove gaps between table borders by default.
+*/
+
+table {
+  text-indent: 0; /* 1 */
+  border-color: inherit; /* 2 */
+  border-collapse: collapse; /* 3 */
+}
+
+/*
+1. Change the font styles in all browsers.
+2. Remove the margin in Firefox and Safari.
+3. Remove default padding in all browsers.
+*/
+
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit; /* 1 */
+  font-feature-settings: inherit; /* 1 */
+  font-variation-settings: inherit; /* 1 */
+  font-size: 100%; /* 1 */
+  font-weight: inherit; /* 1 */
+  line-height: inherit; /* 1 */
+  letter-spacing: inherit; /* 1 */
+  color: inherit; /* 1 */
+  margin: 0; /* 2 */
+  padding: 0; /* 3 */
+}
+
+/*
+Remove the inheritance of text transform in Edge and Firefox.
+*/
+
+button,
+select {
+  text-transform: none;
+}
+
+/*
+1. Correct the inability to style clickable types in iOS and Safari.
+2. Remove default button styles.
+*/
+
+button,
+input:where([type='button']),
+input:where([type='reset']),
+input:where([type='submit']) {
+  -webkit-appearance: button; /* 1 */
+  background-color: transparent; /* 2 */
+  background-image: none; /* 2 */
+}
+
+/*
+Use the modern Firefox focus style for all focusable elements.
+*/
+
+:-moz-focusring {
+  outline: auto;
+}
+
+/*
+Remove the additional \`:invalid\` styles in Firefox. (https://github.com/mozilla/gecko-dev/blob/2f9eacd9d3d995c937b4251a5557d95d494c9be1/layout/style/res/forms.css#L728-L737)
+*/
+
+:-moz-ui-invalid {
+  box-shadow: none;
+}
+
+/*
+Add the correct vertical alignment in Chrome and Firefox.
+*/
+
+progress {
+  vertical-align: baseline;
+}
+
+/*
+Correct the cursor style of increment and decrement buttons in Safari.
+*/
+
+::-webkit-inner-spin-button,
+::-webkit-outer-spin-button {
+  height: auto;
+}
+
+/*
+1. Correct the odd appearance in Chrome and Safari.
+2. Correct the outline style in Safari.
+*/
+
+[type='search'] {
+  -webkit-appearance: textfield; /* 1 */
+  outline-offset: -2px; /* 2 */
+}
+
+/*
+Remove the inner padding in Chrome and Safari on macOS.
+*/
+
+::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+/*
+1. Correct the inability to style clickable types in iOS and Safari.
+2. Change font properties to \`inherit\` in Safari.
+*/
+
+::-webkit-file-upload-button {
+  -webkit-appearance: button; /* 1 */
+  font: inherit; /* 2 */
+}
+
+/*
+Add the correct display in Chrome and Safari.
+*/
+
+summary {
+  display: list-item;
+}
+
+/*
+Removes the default spacing and border for appropriate elements.
+*/
+
+blockquote,
+dl,
+dd,
+h1,
+h2,
+h3,
+h4,
+h5,
+h6,
+hr,
+figure,
+p,
+pre {
+  margin: 0;
+}
+
+fieldset {
+  margin: 0;
+  padding: 0;
+}
+
+legend {
+  padding: 0;
+}
+
+ol,
+ul,
+menu {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+
+/*
+Reset default styling for dialogs.
+*/
+dialog {
+  padding: 0;
+}
+
+/*
+Prevent resizing textareas horizontally by default.
+*/
+
+textarea {
+  resize: vertical;
+}
+
+/*
+1. Reset the default placeholder opacity in Firefox. (https://github.com/tailwindlabs/tailwindcss/issues/3300)
+2. Set the default placeholder color to the user's configured gray 400 color.
+*/
+
+input::-moz-placeholder, textarea::-moz-placeholder {
+  opacity: 1; /* 1 */
+  color: #9ca3af; /* 2 */
+}
+
+input::placeholder,
+textarea::placeholder {
+  opacity: 1; /* 1 */
+  color: #9ca3af; /* 2 */
+}
+
+/*
+Set the default cursor for buttons.
+*/
+
+button,
+[role="button"] {
+  cursor: pointer;
+}
+
+/*
+Make sure disabled buttons don't get the pointer cursor.
+*/
+:disabled {
+  cursor: default;
+}
+
+/*
+1. Make replaced elements \`display: block\` by default. (https://github.com/mozdevs/cssremedy/issues/14)
+2. Add \`vertical-align: middle\` to align replaced elements more sensibly by default. (https://github.com/jensimmons/cssremedy/issues/14#issuecomment-634934210)
+   This can trigger a poorly considered lint error in some tools but is included by design.
+*/
+
+img,
+svg,
+video,
+canvas,
+audio,
+iframe,
+embed,
+object {
+  display: block; /* 1 */
+  vertical-align: middle; /* 2 */
+}
+
+/*
+Constrain images and videos to the parent width and preserve their intrinsic aspect ratio. (https://github.com/mozdevs/cssremedy/issues/14)
+*/
+
+img,
+video {
+  max-width: 100%;
+  height: auto;
+}
+
+/* Make elements with the HTML hidden attribute stay hidden by default */
+[hidden]:where(:not([hidden="until-found"])) {
+  display: none;
+}
+.container {
+  width: 100%;
+}
+.pointer-events-none {
+  pointer-events: none;
+}
+.visible {
+  visibility: visible;
+}
+.static {
+  position: static;
+}
+.fixed {
+  position: fixed;
+}
+.absolute {
+  position: absolute;
+}
+.relative {
+  position: relative;
+}
+.top-0 {
+  top: 0px;
+}
+.my-2 {
+  margin-top: 0.5rem;
+  margin-bottom: 0.5rem;
+}
+.mb-4 {
+  margin-bottom: 1rem;
+}
+.ml-2 {
+  margin-left: 0.5rem;
+}
+.mr-2 {
+  margin-right: 0.5rem;
+}
+.mt-1 {
+  margin-top: 0.25rem;
+}
+.mt-2 {
+  margin-top: 0.5rem;
+}
+.block {
+  display: block;
+}
+.inline-block {
+  display: inline-block;
+}
+.flex {
+  display: flex;
+}
+.hidden {
+  display: none;
+}
+.h-12 {
+  height: 3rem;
+}
+.h-4 {
+  height: 1rem;
+}
+.h-auto {
+  height: auto;
+}
+.h-full {
+  height: 100%;
+}
+.max-h-\\[300px\\] {
+  max-height: 300px;
+}
+.min-h-0 {
+  min-height: 0px;
+}
+.min-h-screen {
+  min-height: 100vh;
+}
+.w-4 {
+  width: 1rem;
+}
+.w-full {
+  width: 100%;
+}
+.max-w-\\[400px\\] {
+  max-width: 400px;
+}
+.flex-1 {
+  flex: 1 1 0%;
+}
+.flex-shrink-0 {
+  flex-shrink: 0;
+}
+.transform {
+  transform: translate(var(--tw-translate-x), var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));
+}
+@keyframes spin {
+
+  to {
+    transform: rotate(360deg);
+  }
+}
+.animate-spin {
+  animation: spin 1s linear infinite;
+}
+.flex-col {
+  flex-direction: column;
+}
+.flex-wrap {
+  flex-wrap: wrap;
+}
+.items-center {
+  align-items: center;
+}
+.justify-center {
+  justify-content: center;
+}
+.gap-2 {
+  gap: 0.5rem;
+}
+.overflow-y-auto {
+  overflow-y: auto;
+}
+.whitespace-pre {
+  white-space: pre;
+}
+.rounded {
+  border-radius: 0.25rem;
+}
+.rounded-full {
+  border-radius: 9999px;
+}
+.rounded-lg {
+  border-radius: 0.5rem;
+}
+.border {
+  border-width: 1px;
+}
+.border-2 {
+  border-width: 2px;
+}
+.border-t {
+  border-top-width: 1px;
+}
+.border-gray-300 {
+  --tw-border-opacity: 1;
+  border-color: rgb(209 213 219 / var(--tw-border-opacity, 1));
+}
+.border-gray-700 {
+  --tw-border-opacity: 1;
+  border-color: rgb(55 65 81 / var(--tw-border-opacity, 1));
+}
+.border-t-gray-600 {
+  --tw-border-opacity: 1;
+  border-top-color: rgb(75 85 99 / var(--tw-border-opacity, 1));
+}
+.bg-gray-100 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(243 244 246 / var(--tw-bg-opacity, 1));
+}
+.bg-gray-800 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(31 41 55 / var(--tw-bg-opacity, 1));
+}
+.bg-gray-900 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(17 24 39 / var(--tw-bg-opacity, 1));
+}
+.bg-green-500 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(34 197 94 / var(--tw-bg-opacity, 1));
+}
+.bg-red-500 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(239 68 68 / var(--tw-bg-opacity, 1));
+}
+.bg-transparent {
+  background-color: transparent;
+}
+.bg-white {
+  --tw-bg-opacity: 1;
+  background-color: rgb(255 255 255 / var(--tw-bg-opacity, 1));
+}
+.object-contain {
+  -o-object-fit: contain;
+     object-fit: contain;
+}
+.p-3 {
+  padding: 0.75rem;
+}
+.p-4 {
+  padding: 1rem;
+}
+.p-6 {
+  padding: 1.5rem;
+}
+.px-2 {
+  padding-left: 0.5rem;
+  padding-right: 0.5rem;
+}
+.px-4 {
+  padding-left: 1rem;
+  padding-right: 1rem;
+}
+.py-1 {
+  padding-top: 0.25rem;
+  padding-bottom: 0.25rem;
+}
+.pt-2 {
+  padding-top: 0.5rem;
+}
+.pt-3 {
+  padding-top: 0.75rem;
+}
+.text-left {
+  text-align: left;
+}
+.font-mono {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+}
+.text-base {
+  font-size: 1rem;
+  line-height: 1.5rem;
+}
+.text-lg {
+  font-size: 1.125rem;
+  line-height: 1.75rem;
+}
+.text-sm {
+  font-size: 0.875rem;
+  line-height: 1.25rem;
+}
+.text-xs {
+  font-size: 0.75rem;
+  line-height: 1rem;
+}
+.text-blue-400 {
+  --tw-text-opacity: 1;
+  color: rgb(96 165 250 / var(--tw-text-opacity, 1));
+}
+.text-gray-200 {
+  --tw-text-opacity: 1;
+  color: rgb(229 231 235 / var(--tw-text-opacity, 1));
+}
+.text-gray-300 {
+  --tw-text-opacity: 1;
+  color: rgb(209 213 219 / var(--tw-text-opacity, 1));
+}
+.text-gray-400 {
+  --tw-text-opacity: 1;
+  color: rgb(156 163 175 / var(--tw-text-opacity, 1));
+}
+.text-gray-500 {
+  --tw-text-opacity: 1;
+  color: rgb(107 114 128 / var(--tw-text-opacity, 1));
+}
+.text-gray-700 {
+  --tw-text-opacity: 1;
+  color: rgb(55 65 81 / var(--tw-text-opacity, 1));
+}
+.text-green-500 {
+  --tw-text-opacity: 1;
+  color: rgb(34 197 94 / var(--tw-text-opacity, 1));
+}
+.text-red-400 {
+  --tw-text-opacity: 1;
+  color: rgb(248 113 113 / var(--tw-text-opacity, 1));
+}
+.text-red-500 {
+  --tw-text-opacity: 1;
+  color: rgb(239 68 68 / var(--tw-text-opacity, 1));
+}
+.text-white {
+  --tw-text-opacity: 1;
+  color: rgb(255 255 255 / var(--tw-text-opacity, 1));
+}
+.underline {
+  text-decoration-line: underline;
+}
+.caret-transparent {
+  caret-color: transparent;
+}
+.shadow {
+  --tw-shadow: 0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1);
+  --tw-shadow-colored: 0 1px 3px 0 var(--tw-shadow-color), 0 1px 2px -1px var(--tw-shadow-color);
+  box-shadow: var(--tw-ring-offset-shadow, 0 0 #0000), var(--tw-ring-shadow, 0 0 #0000), var(--tw-shadow);
+}
+.shadow-lg {
+  --tw-shadow: 0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1);
+  --tw-shadow-colored: 0 10px 15px -3px var(--tw-shadow-color), 0 4px 6px -4px var(--tw-shadow-color);
+  box-shadow: var(--tw-ring-offset-shadow, 0 0 #0000), var(--tw-ring-shadow, 0 0 #0000), var(--tw-shadow);
+}
+.outline-none {
+  outline: 2px solid transparent;
+  outline-offset: 2px;
+}
+.filter {
+  filter: var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow);
+}
+.transition {
+  transition-property: color, background-color, border-color, text-decoration-color, fill, stroke, opacity, box-shadow, transform, filter, -webkit-backdrop-filter;
+  transition-property: color, background-color, border-color, text-decoration-color, fill, stroke, opacity, box-shadow, transform, filter, backdrop-filter;
+  transition-property: color, background-color, border-color, text-decoration-color, fill, stroke, opacity, box-shadow, transform, filter, backdrop-filter, -webkit-backdrop-filter;
+  transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
+  transition-duration: 150ms;
+}
+.ease-in-out {
+  transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
+}
+.ease-out {
+  transition-timing-function: cubic-bezier(0, 0, 0.2, 1);
+}
+.last\\:mb-0:last-child {
+  margin-bottom: 0px;
+}
+.last\\:mr-0:last-child {
+  margin-right: 0px;
+}
+`, Pt = ({
+  config: r = F,
+  commands: n = {},
+  containerId: t = null
+}) => ($(() => {
+  const o = new hn(n, r), i = t ? document.getElementById(t) : document.body;
+  return i ? i.appendChild(o) : (console.warn(`Container with id "${t}" not found, falling back to body`), document.body.appendChild(o)), () => {
+    var a;
+    (a = o.parentElement) == null || a.removeChild(o);
+  };
+}, [n, t]), null);
+class hn extends HTMLElement {
+  constructor(t, o) {
+    super();
+    A(this, "shadow");
+    A(this, "root", null);
+    A(this, "commands");
+    A(this, "config");
+    this.shadow = this.attachShadow({ mode: "open" }), this.commands = t, this.config = o;
+  }
+  connectedCallback() {
+    try {
+      const o = [on, an, sn, Et].map((i) => {
+        const a = new CSSStyleSheet();
+        return a.replaceSync(i), a;
+      });
+      this.shadow.adoptedStyleSheets = [...o];
+    } catch {
+      const i = [on, an, sn].join(`
+`), a = document.createElement("style");
+      a.textContent = i, this.shadow.appendChild(a);
+    }
+    const t = document.createElement("div");
+    t.id = "citadel-root", this.shadow.appendChild(t), this.root = ke(t), this.root.render(
+      /* @__PURE__ */ g.jsx(it, { config: this.config || F, commands: this.commands, children: /* @__PURE__ */ g.jsx(Rt, {}) })
+    );
+  }
+  // disconnectedCallback() {
+  //   if (this.root) {
+  //     this.root.unmount();
+  //     this.root = null;
+  //   }
+  // }
+}
+customElements.define("citadel-element", hn);
+const Rt = () => {
+  const [r, n] = Y(!1), [t, o] = Y(!1), [i, a] = Y(null), l = J(null), d = J(null), h = J(!1), w = J(0), m = J(0), p = G(), { state: u, actions: y, getAvailableCommands: v } = ht(), b = j((S) => {
+    d.current && (h.current = !0, w.current = S.clientY, m.current = d.current.offsetHeight, document.documentElement.style.userSelect = "none", document.documentElement.style.webkitUserSelect = "none", document.documentElement.style.mozUserSelect = "none", document.documentElement.style.msUserSelect = "none", document.addEventListener("mousemove", C), document.addEventListener("mouseup", f));
+  }, []), C = j((S) => {
+    var U;
+    if (!h.current) return;
+    const I = S.clientY - w.current, T = (U = p.maxHeight) != null && U.endsWith("vh") ? window.innerHeight * parseInt(p.maxHeight, 10) / 100 : parseInt(p.maxHeight || "80vh", 10), D = Math.min(
+      Math.max(m.current - I, parseInt(p.minHeight || "200", 10)),
+      T
+    );
+    d.current && (d.current.style.height = `${D}px`, d.current.style.bottom = "0", a(D));
+  }, [p.maxHeight]), f = j(() => {
+    h.current = !1, document.documentElement.style.userSelect = "", document.documentElement.style.webkitUserSelect = "", document.documentElement.style.mozUserSelect = "", document.documentElement.style.msUserSelect = "", document.removeEventListener("mousemove", C), document.removeEventListener("mouseup", f);
+  }, []);
+  $(() => () => {
+    document.removeEventListener("mousemove", C), document.removeEventListener("mouseup", f);
+  }, [C, f]), Gn({
+    onOpen: () => n(!0),
+    onClose: () => o(!0),
+    isVisible: r,
+    showCitadelKey: p.showCitadelKey || "."
+  });
+  const _ = j(() => {
+    t && (n(!1), o(!1));
+  }, [t]);
+  return rt({
+    isVisible: r,
+    isClosing: t,
+    onAnimationComplete: _
+  }), r ? /* @__PURE__ */ g.jsxs(
+    "div",
+    {
+      ref: d,
+      className: `container ${r ? "citadel_slideUp" : ""} ${t ? "citadel_slideDown" : ""}`,
+      style: {
+        ...i ? { height: `${i}px` } : void 0,
+        maxHeight: p.maxHeight
+      },
+      children: [
+        /* @__PURE__ */ g.jsx("div", { className: "resizeHandle", onMouseDown: b }),
+        /* @__PURE__ */ g.jsxs("div", { className: "innerContainer", children: [
+          /* @__PURE__ */ g.jsx("div", { className: "flex-1 min-h-0 pt-3 px-4", children: /* @__PURE__ */ g.jsx(St, { output: u.output, outputRef: l }) }),
+          /* @__PURE__ */ g.jsxs("div", { children: [
+            /* @__PURE__ */ g.jsx(
+              xt,
+              {
+                state: u,
+                actions: y,
+                availableCommands: v()
+              }
+            ),
+            /* @__PURE__ */ g.jsx(
+              kt,
+              {
+                state: u,
+                availableCommands: v()
+              }
+            )
+          ] })
+        ] })
+      ]
+    }
+  ) : null;
+};
+export {
+  Pt as Citadel,
+  X as CommandResult,
+  ae as CommandStatus,
+  pt as DEFAULT_CURSOR_CONFIGS,
+  lt as ErrorCommandResult,
+  At as ImageCommandResult,
+  It as JsonCommandResult,
+  dt as OutputItem,
+  ct as PendingCommandResult,
+  un as TextCommandResult
+};