eidos-ui 0.1.0

package/dist/chunk-GL4DHGQE.js

@@ -0,0 +1,1316 @@
+import {
+  Select
+} from "./chunk-F54MVGKO.js";
+import {
+  Input
+} from "./chunk-A35Y5MRJ.js";
+import {
+  Dropdown
+} from "./chunk-SXF3TCYA.js";
+import {
+  Button
+} from "./chunk-FO5FNTJX.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-5WRI5ZAA.js";
+
+// node_modules/dayjs/dayjs.min.js
+var require_dayjs_min = __commonJS({
+  "node_modules/dayjs/dayjs.min.js"(exports, module) {
+    "use strict";
+    !(function(t, e) {
+      "object" == typeof exports && "undefined" != typeof module ? module.exports = e() : "function" == typeof define && define.amd ? define(e) : (t = "undefined" != typeof globalThis ? globalThis : t || self).dayjs = e();
+    })(exports, (function() {
+      "use strict";
+      var t = 1e3, e = 6e4, n = 36e5, r = "millisecond", i = "second", s = "minute", u = "hour", a = "day", o = "week", c = "month", f = "quarter", h = "year", d = "date", l = "Invalid Date", $ = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/, y = /\[([^\]]+)]|YYYY|YY|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, M = { name: "en", weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"), ordinal: function(t2) {
+        var e2 = ["th", "st", "nd", "rd"], n2 = t2 % 100;
+        return "[" + t2 + (e2[(n2 - 20) % 10] || e2[n2] || e2[0]) + "]";
+      } }, m = function(t2, e2, n2) {
+        var r2 = String(t2);
+        return !r2 || r2.length >= e2 ? t2 : "" + Array(e2 + 1 - r2.length).join(n2) + t2;
+      }, v = { s: m, z: function(t2) {
+        var e2 = -t2.utcOffset(), n2 = Math.abs(e2), r2 = Math.floor(n2 / 60), i2 = n2 % 60;
+        return (e2 <= 0 ? "+" : "-") + m(r2, 2, "0") + ":" + m(i2, 2, "0");
+      }, m: function t2(e2, n2) {
+        if (e2.date() < n2.date()) return -t2(n2, e2);
+        var r2 = 12 * (n2.year() - e2.year()) + (n2.month() - e2.month()), i2 = e2.clone().add(r2, c), s2 = n2 - i2 < 0, u2 = e2.clone().add(r2 + (s2 ? -1 : 1), c);
+        return +(-(r2 + (n2 - i2) / (s2 ? i2 - u2 : u2 - i2)) || 0);
+      }, a: function(t2) {
+        return t2 < 0 ? Math.ceil(t2) || 0 : Math.floor(t2);
+      }, p: function(t2) {
+        return { M: c, y: h, w: o, d: a, D: d, h: u, m: s, s: i, ms: r, Q: f }[t2] || String(t2 || "").toLowerCase().replace(/s$/, "");
+      }, u: function(t2) {
+        return void 0 === t2;
+      } }, g = "en", D = {};
+      D[g] = M;
+      var p = "$isDayjsObject", S = function(t2) {
+        return t2 instanceof _ || !(!t2 || !t2[p]);
+      }, w = function t2(e2, n2, r2) {
+        var i2;
+        if (!e2) return g;
+        if ("string" == typeof e2) {
+          var s2 = e2.toLowerCase();
+          D[s2] && (i2 = s2), n2 && (D[s2] = n2, i2 = s2);
+          var u2 = e2.split("-");
+          if (!i2 && u2.length > 1) return t2(u2[0]);
+        } else {
+          var a2 = e2.name;
+          D[a2] = e2, i2 = a2;
+        }
+        return !r2 && i2 && (g = i2), i2 || !r2 && g;
+      }, O = function(t2, e2) {
+        if (S(t2)) return t2.clone();
+        var n2 = "object" == typeof e2 ? e2 : {};
+        return n2.date = t2, n2.args = arguments, new _(n2);
+      }, b = v;
+      b.l = w, b.i = S, b.w = function(t2, e2) {
+        return O(t2, { locale: e2.$L, utc: e2.$u, x: e2.$x, $offset: e2.$offset });
+      };
+      var _ = (function() {
+        function M2(t2) {
+          this.$L = w(t2.locale, null, true), this.parse(t2), this.$x = this.$x || t2.x || {}, this[p] = true;
+        }
+        var m2 = M2.prototype;
+        return m2.parse = function(t2) {
+          this.$d = (function(t3) {
+            var e2 = t3.date, n2 = t3.utc;
+            if (null === e2) return /* @__PURE__ */ new Date(NaN);
+            if (b.u(e2)) return /* @__PURE__ */ new Date();
+            if (e2 instanceof Date) return new Date(e2);
+            if ("string" == typeof e2 && !/Z$/i.test(e2)) {
+              var r2 = e2.match($);
+              if (r2) {
+                var i2 = r2[2] - 1 || 0, s2 = (r2[7] || "0").substring(0, 3);
+                return n2 ? new Date(Date.UTC(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2)) : new Date(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2);
+              }
+            }
+            return new Date(e2);
+          })(t2), this.init();
+        }, m2.init = function() {
+          var t2 = this.$d;
+          this.$y = t2.getFullYear(), this.$M = t2.getMonth(), this.$D = t2.getDate(), this.$W = t2.getDay(), this.$H = t2.getHours(), this.$m = t2.getMinutes(), this.$s = t2.getSeconds(), this.$ms = t2.getMilliseconds();
+        }, m2.$utils = function() {
+          return b;
+        }, m2.isValid = function() {
+          return !(this.$d.toString() === l);
+        }, m2.isSame = function(t2, e2) {
+          var n2 = O(t2);
+          return this.startOf(e2) <= n2 && n2 <= this.endOf(e2);
+        }, m2.isAfter = function(t2, e2) {
+          return O(t2) < this.startOf(e2);
+        }, m2.isBefore = function(t2, e2) {
+          return this.endOf(e2) < O(t2);
+        }, m2.$g = function(t2, e2, n2) {
+          return b.u(t2) ? this[e2] : this.set(n2, t2);
+        }, m2.unix = function() {
+          return Math.floor(this.valueOf() / 1e3);
+        }, m2.valueOf = function() {
+          return this.$d.getTime();
+        }, m2.startOf = function(t2, e2) {
+          var n2 = this, r2 = !!b.u(e2) || e2, f2 = b.p(t2), l2 = function(t3, e3) {
+            var i2 = b.w(n2.$u ? Date.UTC(n2.$y, e3, t3) : new Date(n2.$y, e3, t3), n2);
+            return r2 ? i2 : i2.endOf(a);
+          }, $2 = function(t3, e3) {
+            return b.w(n2.toDate()[t3].apply(n2.toDate("s"), (r2 ? [0, 0, 0, 0] : [23, 59, 59, 999]).slice(e3)), n2);
+          }, y2 = this.$W, M3 = this.$M, m3 = this.$D, v2 = "set" + (this.$u ? "UTC" : "");
+          switch (f2) {
+            case h:
+              return r2 ? l2(1, 0) : l2(31, 11);
+            case c:
+              return r2 ? l2(1, M3) : l2(0, M3 + 1);
+            case o:
+              var g2 = this.$locale().weekStart || 0, D2 = (y2 < g2 ? y2 + 7 : y2) - g2;
+              return l2(r2 ? m3 - D2 : m3 + (6 - D2), M3);
+            case a:
+            case d:
+              return $2(v2 + "Hours", 0);
+            case u:
+              return $2(v2 + "Minutes", 1);
+            case s:
+              return $2(v2 + "Seconds", 2);
+            case i:
+              return $2(v2 + "Milliseconds", 3);
+            default:
+              return this.clone();
+          }
+        }, m2.endOf = function(t2) {
+          return this.startOf(t2, false);
+        }, m2.$set = function(t2, e2) {
+          var n2, o2 = b.p(t2), f2 = "set" + (this.$u ? "UTC" : ""), l2 = (n2 = {}, n2[a] = f2 + "Date", n2[d] = f2 + "Date", n2[c] = f2 + "Month", n2[h] = f2 + "FullYear", n2[u] = f2 + "Hours", n2[s] = f2 + "Minutes", n2[i] = f2 + "Seconds", n2[r] = f2 + "Milliseconds", n2)[o2], $2 = o2 === a ? this.$D + (e2 - this.$W) : e2;
+          if (o2 === c || o2 === h) {
+            var y2 = this.clone().set(d, 1);
+            y2.$d[l2]($2), y2.init(), this.$d = y2.set(d, Math.min(this.$D, y2.daysInMonth())).$d;
+          } else l2 && this.$d[l2]($2);
+          return this.init(), this;
+        }, m2.set = function(t2, e2) {
+          return this.clone().$set(t2, e2);
+        }, m2.get = function(t2) {
+          return this[b.p(t2)]();
+        }, m2.add = function(r2, f2) {
+          var d2, l2 = this;
+          r2 = Number(r2);
+          var $2 = b.p(f2), y2 = function(t2) {
+            var e2 = O(l2);
+            return b.w(e2.date(e2.date() + Math.round(t2 * r2)), l2);
+          };
+          if ($2 === c) return this.set(c, this.$M + r2);
+          if ($2 === h) return this.set(h, this.$y + r2);
+          if ($2 === a) return y2(1);
+          if ($2 === o) return y2(7);
+          var M3 = (d2 = {}, d2[s] = e, d2[u] = n, d2[i] = t, d2)[$2] || 1, m3 = this.$d.getTime() + r2 * M3;
+          return b.w(m3, this);
+        }, m2.subtract = function(t2, e2) {
+          return this.add(-1 * t2, e2);
+        }, m2.format = function(t2) {
+          var e2 = this, n2 = this.$locale();
+          if (!this.isValid()) return n2.invalidDate || l;
+          var r2 = t2 || "YYYY-MM-DDTHH:mm:ssZ", i2 = b.z(this), s2 = this.$H, u2 = this.$m, a2 = this.$M, o2 = n2.weekdays, c2 = n2.months, f2 = n2.meridiem, h2 = function(t3, n3, i3, s3) {
+            return t3 && (t3[n3] || t3(e2, r2)) || i3[n3].slice(0, s3);
+          }, d2 = function(t3) {
+            return b.s(s2 % 12 || 12, t3, "0");
+          }, $2 = f2 || function(t3, e3, n3) {
+            var r3 = t3 < 12 ? "AM" : "PM";
+            return n3 ? r3.toLowerCase() : r3;
+          };
+          return r2.replace(y, (function(t3, r3) {
+            return r3 || (function(t4) {
+              switch (t4) {
+                case "YY":
+                  return String(e2.$y).slice(-2);
+                case "YYYY":
+                  return b.s(e2.$y, 4, "0");
+                case "M":
+                  return a2 + 1;
+                case "MM":
+                  return b.s(a2 + 1, 2, "0");
+                case "MMM":
+                  return h2(n2.monthsShort, a2, c2, 3);
+                case "MMMM":
+                  return h2(c2, a2);
+                case "D":
+                  return e2.$D;
+                case "DD":
+                  return b.s(e2.$D, 2, "0");
+                case "d":
+                  return String(e2.$W);
+                case "dd":
+                  return h2(n2.weekdaysMin, e2.$W, o2, 2);
+                case "ddd":
+                  return h2(n2.weekdaysShort, e2.$W, o2, 3);
+                case "dddd":
+                  return o2[e2.$W];
+                case "H":
+                  return String(s2);
+                case "HH":
+                  return b.s(s2, 2, "0");
+                case "h":
+                  return d2(1);
+                case "hh":
+                  return d2(2);
+                case "a":
+                  return $2(s2, u2, true);
+                case "A":
+                  return $2(s2, u2, false);
+                case "m":
+                  return String(u2);
+                case "mm":
+                  return b.s(u2, 2, "0");
+                case "s":
+                  return String(e2.$s);
+                case "ss":
+                  return b.s(e2.$s, 2, "0");
+                case "SSS":
+                  return b.s(e2.$ms, 3, "0");
+                case "Z":
+                  return i2;
+              }
+              return null;
+            })(t3) || i2.replace(":", "");
+          }));
+        }, m2.utcOffset = function() {
+          return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
+        }, m2.diff = function(r2, d2, l2) {
+          var $2, y2 = this, M3 = b.p(d2), m3 = O(r2), v2 = (m3.utcOffset() - this.utcOffset()) * e, g2 = this - m3, D2 = function() {
+            return b.m(y2, m3);
+          };
+          switch (M3) {
+            case h:
+              $2 = D2() / 12;
+              break;
+            case c:
+              $2 = D2();
+              break;
+            case f:
+              $2 = D2() / 3;
+              break;
+            case o:
+              $2 = (g2 - v2) / 6048e5;
+              break;
+            case a:
+              $2 = (g2 - v2) / 864e5;
+              break;
+            case u:
+              $2 = g2 / n;
+              break;
+            case s:
+              $2 = g2 / e;
+              break;
+            case i:
+              $2 = g2 / t;
+              break;
+            default:
+              $2 = g2;
+          }
+          return l2 ? $2 : b.a($2);
+        }, m2.daysInMonth = function() {
+          return this.endOf(c).$D;
+        }, m2.$locale = function() {
+          return D[this.$L];
+        }, m2.locale = function(t2, e2) {
+          if (!t2) return this.$L;
+          var n2 = this.clone(), r2 = w(t2, e2, true);
+          return r2 && (n2.$L = r2), n2;
+        }, m2.clone = function() {
+          return b.w(this.$d, this);
+        }, m2.toDate = function() {
+          return new Date(this.valueOf());
+        }, m2.toJSON = function() {
+          return this.isValid() ? this.toISOString() : null;
+        }, m2.toISOString = function() {
+          return this.$d.toISOString();
+        }, m2.toString = function() {
+          return this.$d.toUTCString();
+        }, M2;
+      })(), Y = _.prototype;
+      return O.prototype = Y, [["$ms", r], ["$s", i], ["$m", s], ["$H", u], ["$W", a], ["$M", c], ["$y", h], ["$D", d]].forEach((function(t2) {
+        Y[t2[1]] = function(e2) {
+          return this.$g(e2, t2[0], t2[1]);
+        };
+      })), O.extend = function(t2, e2) {
+        return t2.$i || (t2(e2, _, O), t2.$i = true), O;
+      }, O.locale = w, O.isDayjs = S, O.unix = function(t2) {
+        return O(1e3 * t2);
+      }, O.en = D[g], O.Ls = D, O.p = {}, O;
+    }));
+  }
+});
+
+// node_modules/dayjs/plugin/utc.js
+var require_utc = __commonJS({
+  "node_modules/dayjs/plugin/utc.js"(exports, module) {
+    "use strict";
+    !(function(t, i) {
+      "object" == typeof exports && "undefined" != typeof module ? module.exports = i() : "function" == typeof define && define.amd ? define(i) : (t = "undefined" != typeof globalThis ? globalThis : t || self).dayjs_plugin_utc = i();
+    })(exports, (function() {
+      "use strict";
+      var t = "minute", i = /[+-]\d\d(?::?\d\d)?/g, e = /([+-]|\d\d)/g;
+      return function(s, f, n) {
+        var u = f.prototype;
+        n.utc = function(t2) {
+          var i2 = { date: t2, utc: true, args: arguments };
+          return new f(i2);
+        }, u.utc = function(i2) {
+          var e2 = n(this.toDate(), { locale: this.$L, utc: true });
+          return i2 ? e2.add(this.utcOffset(), t) : e2;
+        }, u.local = function() {
+          return n(this.toDate(), { locale: this.$L, utc: false });
+        };
+        var r = u.parse;
+        u.parse = function(t2) {
+          t2.utc && (this.$u = true), this.$utils().u(t2.$offset) || (this.$offset = t2.$offset), r.call(this, t2);
+        };
+        var o = u.init;
+        u.init = function() {
+          if (this.$u) {
+            var t2 = this.$d;
+            this.$y = t2.getUTCFullYear(), this.$M = t2.getUTCMonth(), this.$D = t2.getUTCDate(), this.$W = t2.getUTCDay(), this.$H = t2.getUTCHours(), this.$m = t2.getUTCMinutes(), this.$s = t2.getUTCSeconds(), this.$ms = t2.getUTCMilliseconds();
+          } else o.call(this);
+        };
+        var a = u.utcOffset;
+        u.utcOffset = function(s2, f2) {
+          var n2 = this.$utils().u;
+          if (n2(s2)) return this.$u ? 0 : n2(this.$offset) ? a.call(this) : this.$offset;
+          if ("string" == typeof s2 && (s2 = (function(t2) {
+            void 0 === t2 && (t2 = "");
+            var s3 = t2.match(i);
+            if (!s3) return null;
+            var f3 = ("" + s3[0]).match(e) || ["-", 0, 0], n3 = f3[0], u3 = 60 * +f3[1] + +f3[2];
+            return 0 === u3 ? 0 : "+" === n3 ? u3 : -u3;
+          })(s2), null === s2)) return this;
+          var u2 = Math.abs(s2) <= 16 ? 60 * s2 : s2;
+          if (0 === u2) return this.utc(f2);
+          var r2 = this.clone();
+          if (f2) return r2.$offset = u2, r2.$u = false, r2;
+          var o2 = this.$u ? this.toDate().getTimezoneOffset() : -1 * this.utcOffset();
+          return (r2 = this.local().add(u2 + o2, t)).$offset = u2, r2.$x.$localOffset = o2, r2;
+        };
+        var h = u.format;
+        u.format = function(t2) {
+          var i2 = t2 || (this.$u ? "YYYY-MM-DDTHH:mm:ss[Z]" : "");
+          return h.call(this, i2);
+        }, u.valueOf = function() {
+          var t2 = this.$utils().u(this.$offset) ? 0 : this.$offset + (this.$x.$localOffset || this.$d.getTimezoneOffset());
+          return this.$d.valueOf() - 6e4 * t2;
+        }, u.isUTC = function() {
+          return !!this.$u;
+        }, u.toISOString = function() {
+          return this.toDate().toISOString();
+        }, u.toString = function() {
+          return this.toDate().toUTCString();
+        };
+        var l = u.toDate;
+        u.toDate = function(t2) {
+          return "s" === t2 && this.$offset ? n(this.format("YYYY-MM-DD HH:mm:ss:SSS")).toDate() : l.call(this);
+        };
+        var c = u.diff;
+        u.diff = function(t2, i2, e2) {
+          if (t2 && this.$u === t2.$u) return c.call(this, t2, i2, e2);
+          var s2 = this.local(), f2 = n(t2).local();
+          return c.call(s2, f2, i2, e2);
+        };
+      };
+    }));
+  }
+});
+
+// node_modules/dayjs/plugin/timezone.js
+var require_timezone = __commonJS({
+  "node_modules/dayjs/plugin/timezone.js"(exports, module) {
+    "use strict";
+    !(function(t, e) {
+      "object" == typeof exports && "undefined" != typeof module ? module.exports = e() : "function" == typeof define && define.amd ? define(e) : (t = "undefined" != typeof globalThis ? globalThis : t || self).dayjs_plugin_timezone = e();
+    })(exports, (function() {
+      "use strict";
+      var t = { year: 0, month: 1, day: 2, hour: 3, minute: 4, second: 5 }, e = {};
+      return function(n, i, r) {
+        var o, a = function(t2, n2, i2) {
+          void 0 === i2 && (i2 = {});
+          var r2 = new Date(t2), o2 = (function(t3, n3) {
+            void 0 === n3 && (n3 = {});
+            var i3 = n3.timeZoneName || "short", r3 = t3 + "|" + i3, o3 = e[r3];
+            return o3 || (o3 = new Intl.DateTimeFormat("en-US", { hour12: false, timeZone: t3, year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit", second: "2-digit", timeZoneName: i3 }), e[r3] = o3), o3;
+          })(n2, i2);
+          return o2.formatToParts(r2);
+        }, u = function(e2, n2) {
+          for (var i2 = a(e2, n2), o2 = [], u2 = 0; u2 < i2.length; u2 += 1) {
+            var f2 = i2[u2], s2 = f2.type, m = f2.value, c = t[s2];
+            c >= 0 && (o2[c] = parseInt(m, 10));
+          }
+          var l = o2[3], d = 24 === l ? 0 : l, h = o2[0] + "-" + o2[1] + "-" + o2[2] + " " + d + ":" + o2[4] + ":" + o2[5] + ":000", v = +e2;
+          return (r.utc(h).valueOf() - (v -= v % 1e3)) / 6e4;
+        }, f = i.prototype;
+        f.tz = function(t2, e2) {
+          if (void 0 === t2 && (t2 = o), !this.isValid()) return this;
+          var n2, i2 = this.utcOffset(), a2 = this.toDate(), f2 = a2.toLocaleString("en-US", { timeZone: t2 }), s2 = u(+a2, t2);
+          if (!Number(s2)) n2 = this.utcOffset(0, e2);
+          else if (n2 = r(f2, { locale: this.$L }).$set("millisecond", this.$ms).utcOffset(s2, true), e2) {
+            var m = n2.utcOffset();
+            n2 = n2.add(i2 - m, "minute");
+          }
+          return n2.$x.$timezone = t2, n2;
+        }, f.offsetName = function(t2) {
+          var e2 = this.$x.$timezone || r.tz.guess(), n2 = a(this.valueOf(), e2, { timeZoneName: t2 }).find((function(t3) {
+            return "timezonename" === t3.type.toLowerCase();
+          }));
+          return n2 && n2.value;
+        };
+        var s = f.startOf;
+        f.startOf = function(t2, e2) {
+          if (!this.$x || !this.$x.$timezone) return s.call(this, t2, e2);
+          var n2 = r(this.format("YYYY-MM-DD HH:mm:ss:SSS"), { locale: this.$L });
+          return s.call(n2, t2, e2).tz(this.$x.$timezone, true);
+        }, r.tz = function(t2, e2, n2) {
+          var i2 = n2 && e2, a2 = n2 || e2 || o, f2 = u(+r(), a2);
+          if ("string" != typeof t2) return r(t2).tz(a2);
+          var s2 = r.utc(t2, i2).valueOf();
+          if (Number.isNaN(s2)) {
+            var m = r(NaN);
+            return m.$x.$timezone = a2, m;
+          }
+          var c = (function(t3, e3, n3) {
+            var i3 = t3 - 60 * e3 * 1e3, r2 = u(i3, n3);
+            if (e3 === r2) return [i3, e3];
+            var o2 = u(i3 -= 60 * (r2 - e3) * 1e3, n3);
+            return r2 === o2 ? [i3, r2] : [t3 - 60 * Math.min(r2, o2) * 1e3, Math.max(r2, o2)];
+          })(s2, f2, a2), l = c[0], d = c[1], h = r(l).utcOffset(d);
+          return h.$x.$timezone = a2, h;
+        }, r.tz.guess = function() {
+          return Intl.DateTimeFormat().resolvedOptions().timeZone;
+        }, r.tz.setDefault = function(t2) {
+          o = t2;
+        };
+      };
+    }));
+  }
+});
+
+// node_modules/dayjs/plugin/weekOfYear.js
+var require_weekOfYear = __commonJS({
+  "node_modules/dayjs/plugin/weekOfYear.js"(exports, module) {
+    "use strict";
+    !(function(e, t) {
+      "object" == typeof exports && "undefined" != typeof module ? module.exports = t() : "function" == typeof define && define.amd ? define(t) : (e = "undefined" != typeof globalThis ? globalThis : e || self).dayjs_plugin_weekOfYear = t();
+    })(exports, (function() {
+      "use strict";
+      var e = "week", t = "year";
+      return function(i, n, r) {
+        var f = n.prototype;
+        f.week = function(i2) {
+          if (void 0 === i2 && (i2 = null), null !== i2) return this.add(7 * (i2 - this.week()), "day");
+          var n2 = this.$locale().yearStart || 1;
+          if (11 === this.month() && this.date() > 25) {
+            var f2 = r(this).startOf(t).add(1, t).date(n2), s = r(this).endOf(e);
+            if (f2.isBefore(s)) return 1;
+          }
+          var a = r(this).startOf(t).date(n2).startOf(e).subtract(1, "millisecond"), o = this.diff(a, e, true);
+          return o < 0 ? r(this).startOf("week").week() : Math.ceil(o);
+        }, f.weeks = function(e2) {
+          return void 0 === e2 && (e2 = null), this.week(e2);
+        };
+      };
+    }));
+  }
+});
+
+// src/components/DatePicker/DatePicker.component.tsx
+var import_dayjs2 = __toESM(require_dayjs_min(), 1);
+var import_utc = __toESM(require_utc(), 1);
+var import_timezone = __toESM(require_timezone(), 1);
+import { useState as useState2, useCallback as useCallback3, useRef, useMemo as useMemo2 } from "react";
+import { Calendar as CalendarIcon, X } from "lucide-react";
+
+// src/components/DatePicker/Calendar.component.tsx
+var import_dayjs = __toESM(require_dayjs_min(), 1);
+var import_weekOfYear = __toESM(require_weekOfYear(), 1);
+import { useMemo, useCallback } from "react";
+import { ChevronLeft, ChevronRight } from "lucide-react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import_dayjs.default.extend(import_weekOfYear.default);
+var Calendar = ({
+  currentDate,
+  selectedDates,
+  rangeStart,
+  rangeEnd,
+  // mode, // TODO: Use this for different selection behaviors
+  granularity = "day",
+  onDateSelect,
+  onMonthChange,
+  minDate,
+  maxDate,
+  disabledDates = [],
+  disabledDaysOfWeek = [],
+  showWeekNumbers = false,
+  firstDayOfWeek = 1,
+  // Monday
+  showNavigation = true
+}) => {
+  const monthOptions = useMemo(() => {
+    return Array.from({ length: 12 }, (_, i) => ({
+      id: i.toString(),
+      label: (0, import_dayjs.default)().month(i).format("MMMM"),
+      value: i.toString()
+    }));
+  }, []);
+  const yearOptions = useMemo(() => {
+    const currentYear = (0, import_dayjs.default)().year();
+    const years = [];
+    for (let year = currentYear - 50; year <= currentYear + 50; year++) {
+      years.push({
+        id: year.toString(),
+        label: year.toString(),
+        value: year.toString()
+      });
+    }
+    return years;
+  }, []);
+  const handleMonthSelect = useCallback(
+    (value) => {
+      if (typeof value === "string") {
+        const newDate = currentDate.month(parseInt(value));
+        onMonthChange(newDate);
+      }
+    },
+    [currentDate, onMonthChange]
+  );
+  const handleYearSelect = useCallback(
+    (value) => {
+      if (typeof value === "string") {
+        const newDate = currentDate.year(parseInt(value));
+        onMonthChange(newDate);
+      }
+    },
+    [currentDate, onMonthChange]
+  );
+  const handlePrevMonth = useCallback(() => {
+    onMonthChange(currentDate.subtract(1, "month"));
+  }, [currentDate, onMonthChange]);
+  const handleNextMonth = useCallback(() => {
+    onMonthChange(currentDate.add(1, "month"));
+  }, [currentDate, onMonthChange]);
+  const handlePrevYear = useCallback(() => {
+    onMonthChange(currentDate.subtract(1, "year"));
+  }, [currentDate, onMonthChange]);
+  const handleNextYear = useCallback(() => {
+    onMonthChange(currentDate.add(1, "year"));
+  }, [currentDate, onMonthChange]);
+  const monthCells = useMemo(() => {
+    return Array.from({ length: 12 }, (_, i) => {
+      const monthDate = currentDate.month(i).startOf("month");
+      const isToday = monthDate.isSame((0, import_dayjs.default)(), "month");
+      const isSelected = selectedDates.some((date) => date.isSame(monthDate, "month"));
+      const isDisabled = minDate && monthDate.endOf("month").isBefore(minDate, "month") || maxDate && monthDate.isAfter(maxDate, "month");
+      const isRangeStart = rangeStart?.isSame(monthDate, "month") || false;
+      const isRangeEnd = rangeEnd?.isSame(monthDate, "month") || false;
+      const isInRange = rangeStart && rangeEnd && monthDate.isAfter(rangeStart, "month") && monthDate.isBefore(rangeEnd, "month");
+      return {
+        date: monthDate,
+        isToday,
+        isSelected,
+        isDisabled,
+        isRangeStart,
+        isRangeEnd,
+        isInRange
+      };
+    });
+  }, [currentDate, selectedDates, rangeStart, rangeEnd, minDate, maxDate]);
+  const calendarDays = useMemo(() => {
+    const startOfMonth = currentDate.startOf("month");
+    let startOfCalendar = startOfMonth.startOf("week");
+    if (firstDayOfWeek === 1) {
+      startOfCalendar = startOfMonth.day() === 0 ? startOfMonth.subtract(6, "day") : startOfMonth.startOf("week").add(1, "day");
+    }
+    const days = [];
+    let current = startOfCalendar;
+    for (let i = 0; i < 42; i++) {
+      const isCurrentMonth = current.month() === currentDate.month();
+      const isToday = current.isSame((0, import_dayjs.default)(), "day");
+      const isSelected = selectedDates.some((date) => date.isSame(current, "day"));
+      const isDisabled = minDate && current.isBefore(minDate, "day") || maxDate && current.isAfter(maxDate, "day") || disabledDates.some((date) => date.isSame(current, "day")) || disabledDaysOfWeek.includes(current.day());
+      const isRangeStart = rangeStart?.isSame(current, "day") || false;
+      const isRangeEnd = rangeEnd?.isSame(current, "day") || false;
+      const isInRange = rangeStart && rangeEnd && current.isAfter(rangeStart, "day") && current.isBefore(rangeEnd, "day");
+      days.push({
+        date: current,
+        isCurrentMonth,
+        isToday,
+        isSelected,
+        isDisabled,
+        isRangeStart,
+        isRangeEnd,
+        isInRange
+      });
+      current = current.add(1, "day");
+    }
+    return days;
+  }, [
+    currentDate,
+    selectedDates,
+    rangeStart,
+    rangeEnd,
+    minDate,
+    maxDate,
+    disabledDates,
+    disabledDaysOfWeek,
+    firstDayOfWeek
+  ]);
+  const weekDays = useMemo(() => {
+    const days = [];
+    let start = firstDayOfWeek === 0 ? (0, import_dayjs.default)().startOf("week") : (0, import_dayjs.default)().startOf("week").add(1, "day");
+    for (let i = 0; i < 7; i++) {
+      days.push(start.format("dd"));
+      start = start.add(1, "day");
+    }
+    return days;
+  }, [firstDayOfWeek]);
+  const handleDateClick = useCallback(
+    (date) => {
+      onDateSelect(date);
+    },
+    [onDateSelect]
+  );
+  return /* @__PURE__ */ jsxs("div", { className: "eidos-calendar", children: [
+    /* @__PURE__ */ jsx("div", { className: "eidos-calendar-header", children: showNavigation ? granularity === "month" ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Button, { variant: "text", icon: ChevronLeft, onClick: handlePrevYear }),
+      /* @__PURE__ */ jsx("div", { className: "eidos-calendar-selectors", children: /* @__PURE__ */ jsx(
+        Select,
+        {
+          options: yearOptions,
+          value: currentDate.year().toString(),
+          onChange: handleYearSelect,
+          clearable: false,
+          dropdownProps: {
+            dropdownGroup: "calendar-navigation"
+          }
+        }
+      ) }),
+      /* @__PURE__ */ jsx(Button, { variant: "text", icon: ChevronRight, onClick: handleNextYear })
+    ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Button, { variant: "text", icon: ChevronLeft, onClick: handlePrevMonth }),
+      /* @__PURE__ */ jsxs("div", { className: "eidos-calendar-selectors", children: [
+        /* @__PURE__ */ jsx(
+          Select,
+          {
+            options: monthOptions,
+            value: currentDate.month().toString(),
+            onChange: handleMonthSelect,
+            clearable: false,
+            dropdownProps: {
+              dropdownGroup: "calendar-navigation"
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Select,
+          {
+            options: yearOptions,
+            value: currentDate.year().toString(),
+            onChange: handleYearSelect,
+            clearable: false,
+            dropdownProps: {
+              dropdownGroup: "calendar-navigation"
+            }
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx(Button, { variant: "text", icon: ChevronRight, onClick: handleNextMonth })
+    ] }) : /* @__PURE__ */ jsx("div", { className: "eidos-calendar-label", children: currentDate.format(granularity === "month" ? "YYYY" : "MMMM YYYY") }) }),
+    granularity === "month" ? /* @__PURE__ */ jsx("div", { className: "eidos-calendar-month-cells", children: monthCells.map((month, index) => /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        className: `eidos-calendar-date-cell eidos-calendar-month-cell ${month.isToday ? "eidos-calendar-today" : ""} ${month.isSelected ? "eidos-calendar-selected" : ""} ${month.isDisabled ? "eidos-calendar-disabled" : ""} ${month.isRangeStart ? "eidos-calendar-range-start" : ""} ${month.isRangeEnd ? "eidos-calendar-range-end" : ""} ${month.isInRange ? "eidos-calendar-in-range" : ""}`.trim(),
+        onClick: () => !month.isDisabled && handleDateClick(month.date),
+        disabled: month.isDisabled,
+        children: month.date.format("MMM")
+      },
+      index
+    )) }) : /* @__PURE__ */ jsxs("div", { className: "eidos-calendar-grid", children: [
+      showWeekNumbers && /* @__PURE__ */ jsxs("div", { className: "eidos-calendar-week-numbers-column", children: [
+        /* @__PURE__ */ jsx("div", { className: "eidos-calendar-week-number-header" }),
+        Array.from({ length: 6 }, (_, weekIndex) => {
+          const weekStart = calendarDays[weekIndex * 7].date;
+          return /* @__PURE__ */ jsx("div", { className: "eidos-calendar-week-number", children: weekStart.format("W") }, weekIndex);
+        })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "eidos-calendar-content", children: [
+        /* @__PURE__ */ jsx("div", { className: "eidos-calendar-week-days", children: weekDays.map((day, index) => /* @__PURE__ */ jsx("div", { className: "eidos-calendar-week-day", children: day }, index)) }),
+        /* @__PURE__ */ jsx("div", { className: "eidos-calendar-date-cells", children: calendarDays.map((day, index) => /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            className: `eidos-calendar-date-cell ${!day.isCurrentMonth ? "eidos-calendar-other-month" : ""} ${day.isToday ? "eidos-calendar-today" : ""} ${day.isSelected ? "eidos-calendar-selected" : ""} ${day.isDisabled ? "eidos-calendar-disabled" : ""} ${day.isRangeStart ? "eidos-calendar-range-start" : ""} ${day.isRangeEnd ? "eidos-calendar-range-end" : ""} ${day.isInRange ? "eidos-calendar-in-range" : ""}`.trim(),
+            onClick: () => !day.isDisabled && handleDateClick(day.date),
+            disabled: day.isDisabled,
+            children: day.date.date()
+          },
+          index
+        )) })
+      ] })
+    ] })
+  ] });
+};
+
+// src/components/DatePicker/TimeInput.component.tsx
+import { useState, useEffect, useCallback as useCallback2 } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var TimeInput = ({
+  value,
+  onChange,
+  includeSeconds = false,
+  disabled = false,
+  label = "Time"
+}) => {
+  const [hours, setHours] = useState(value.hours.toString().padStart(2, "0"));
+  const [minutes, setMinutes] = useState(value.minutes.toString().padStart(2, "0"));
+  const [seconds, setSeconds] = useState((value.seconds || 0).toString().padStart(2, "0"));
+  useEffect(() => {
+    setHours(value.hours.toString().padStart(2, "0"));
+    setMinutes(value.minutes.toString().padStart(2, "0"));
+    setSeconds((value.seconds || 0).toString().padStart(2, "0"));
+  }, [value]);
+  const handleTimeChange = useCallback2(
+    (newHours, newMinutes, newSeconds) => {
+      onChange({
+        hours: newHours,
+        minutes: newMinutes,
+        seconds: newSeconds
+      });
+    },
+    [onChange]
+  );
+  const handleHoursChange = useCallback2(
+    (e) => {
+      const newHours = Math.max(0, Math.min(23, parseInt(e.target.value) || 0));
+      setHours(newHours.toString().padStart(2, "0"));
+      handleTimeChange(newHours, value.minutes, value.seconds || 0);
+    },
+    [handleTimeChange, value.minutes, value.seconds]
+  );
+  const handleMinutesChange = useCallback2(
+    (e) => {
+      const newMinutes = Math.max(0, Math.min(59, parseInt(e.target.value) || 0));
+      setMinutes(newMinutes.toString().padStart(2, "0"));
+      handleTimeChange(value.hours, newMinutes, value.seconds || 0);
+    },
+    [handleTimeChange, value.hours, value.seconds]
+  );
+  const handleSecondsChange = useCallback2(
+    (e) => {
+      const newSeconds = Math.max(0, Math.min(59, parseInt(e.target.value) || 0));
+      setSeconds(newSeconds.toString().padStart(2, "0"));
+      handleTimeChange(value.hours, value.minutes, newSeconds);
+    },
+    [handleTimeChange, value.hours, value.minutes]
+  );
+  return /* @__PURE__ */ jsxs2("div", { className: "eidos-time-input", children: [
+    label && /* @__PURE__ */ jsx2("label", { className: "eidos-time-input-label", children: label }),
+    /* @__PURE__ */ jsxs2("div", { className: "eidos-time-input-inputs", children: [
+      /* @__PURE__ */ jsxs2("div", { className: "eidos-time-input-input-group", children: [
+        /* @__PURE__ */ jsx2(
+          Input,
+          {
+            type: "number",
+            value: hours,
+            onChange: handleHoursChange,
+            disabled,
+            min: 0,
+            max: 23,
+            placeholder: "HH",
+            size: "sm",
+            className: "eidos-time-input-time-field"
+          }
+        ),
+        /* @__PURE__ */ jsx2("span", { className: "eidos-time-input-separator", children: ":" })
+      ] }),
+      /* @__PURE__ */ jsxs2("div", { className: "eidos-time-input-input-group", children: [
+        /* @__PURE__ */ jsx2(
+          Input,
+          {
+            type: "number",
+            value: minutes,
+            onChange: handleMinutesChange,
+            disabled,
+            min: 0,
+            max: 59,
+            placeholder: "MM",
+            size: "sm",
+            className: "eidos-time-input-time-field"
+          }
+        ),
+        includeSeconds && /* @__PURE__ */ jsx2("span", { className: "eidos-time-input-separator", children: ":" })
+      ] }),
+      includeSeconds && /* @__PURE__ */ jsx2("div", { className: "eidos-time-input-input-group", children: /* @__PURE__ */ jsx2(
+        Input,
+        {
+          type: "number",
+          value: seconds,
+          onChange: handleSecondsChange,
+          disabled,
+          min: 0,
+          max: 59,
+          placeholder: "SS",
+          size: "sm",
+          className: "eidos-time-input-time-field"
+        }
+      ) })
+    ] })
+  ] });
+};
+
+// src/components/DatePicker/DatePicker.component.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+import_dayjs2.default.extend(import_utc.default);
+import_dayjs2.default.extend(import_timezone.default);
+var DatePicker = ({
+  mode,
+  value,
+  onChange,
+  granularity = "day",
+  time = { enabled: false },
+  calendar = { numberOfCalendars: 2 },
+  format = {
+    displayFormat: "MMM DD, YYYY",
+    inputFormat: "YYYY-MM-DD",
+    timeFormat: "HH:mm",
+    timezone: "UTC"
+  },
+  placeholder = "Select date...",
+  disabled = false,
+  required = false,
+  name,
+  id,
+  inputProps = {},
+  minDate,
+  maxDate,
+  disabledDates = [],
+  disabledDaysOfWeek = [],
+  className = "",
+  fullWidth = false,
+  minWidth,
+  maxWidth,
+  minHeight,
+  maxHeight,
+  autoWidth = false
+}) => {
+  const [dropdownKey, setDropdownKey] = useState2(0);
+  const pickerTimezone = format.timezone || "UTC";
+  const composeDateOnly = useCallback3(
+    (date, boundary = "start") => {
+      const anchored = import_dayjs2.default.tz(date.format("YYYY-MM-DD"), pickerTimezone);
+      return boundary === "end" ? anchored.endOf("day") : anchored.startOf("day");
+    },
+    [pickerTimezone]
+  );
+  const composeLocalDateTime = useCallback3(
+    (date, t) => date.hour(t.hours).minute(t.minutes).second(t.seconds || 0),
+    []
+  );
+  const recomposeIsoWithTime = useCallback3(
+    (isoString, t) => (0, import_dayjs2.default)(isoString).hour(t.hours).minute(t.minutes).second(t.seconds || 0).toISOString(),
+    []
+  );
+  const numberOfCalendars = granularity === "month" ? 1 : calendar.numberOfCalendars || 2;
+  const independentCalendars = calendar.independent ?? false;
+  const [calendarDates, setCalendarDates] = useState2(
+    () => Array.from({ length: numberOfCalendars }, (_, i) => (0, import_dayjs2.default)().add(i, "month"))
+  );
+  const handleCalendarMonthChange = useCallback3(
+    (index, newDate) => {
+      if (!independentCalendars) {
+        const anchor = newDate.subtract(index, "month");
+        setCalendarDates(
+          Array.from({ length: numberOfCalendars }, (_, i) => anchor.add(i, "month"))
+        );
+        return;
+      }
+      setCalendarDates((prev) => {
+        const next = [...prev];
+        let clamped = newDate;
+        const left = prev[index - 1];
+        const right = prev[index + 1];
+        if (left && !clamped.isAfter(left, "month")) {
+          clamped = left.add(1, "month");
+        }
+        if (right && !clamped.isBefore(right, "month")) {
+          clamped = right.subtract(1, "month");
+        }
+        next[index] = clamped;
+        return next;
+      });
+    },
+    [independentCalendars, numberOfCalendars]
+  );
+  const triggerRef = useRef(null);
+  const minDateObj = useMemo2(() => minDate ? (0, import_dayjs2.default)(minDate) : void 0, [minDate]);
+  const maxDateObj = useMemo2(() => maxDate ? (0, import_dayjs2.default)(maxDate) : void 0, [maxDate]);
+  const disabledDatesObj = useMemo2(() => disabledDates.map((d) => (0, import_dayjs2.default)(d)), [disabledDates]);
+  const defaultStartTime = useMemo2(() => ({ hours: 0, minutes: 0, seconds: 0 }), []);
+  const defaultEndTime = useMemo2(() => ({ hours: 23, minutes: 59, seconds: 59 }), []);
+  const toLocalDateString = useCallback3(
+    (isoString) => {
+      if (!isoString) return null;
+      const parsed = (0, import_dayjs2.default)(isoString);
+      return (time.enabled ? parsed : parsed.tz(pickerTimezone)).format("YYYY-MM-DD");
+    },
+    [time.enabled, pickerTimezone]
+  );
+  const { selectedDates, rangeStart, rangeEnd } = useMemo2(() => {
+    if (!value?.date) {
+      return { selectedDates: [], rangeStart: null, rangeEnd: null };
+    }
+    switch (mode) {
+      case "single": {
+        const isoString = value.date;
+        const localDateStr = toLocalDateString(isoString);
+        return {
+          selectedDates: localDateStr ? [(0, import_dayjs2.default)(localDateStr)] : [],
+          rangeStart: null,
+          rangeEnd: null
+        };
+      }
+      case "multiple": {
+        const isoStrings = value.date;
+        const localDateStrings = isoStrings.map((d) => toLocalDateString(d)).filter(Boolean);
+        return {
+          selectedDates: localDateStrings.map((d) => (0, import_dayjs2.default)(d)),
+          rangeStart: null,
+          rangeEnd: null
+        };
+      }
+      case "range": {
+        const range = value.date;
+        const startStr = toLocalDateString(range.start);
+        const endStr = toLocalDateString(range.end);
+        return {
+          selectedDates: [],
+          rangeStart: startStr ? (0, import_dayjs2.default)(startStr) : null,
+          rangeEnd: endStr ? (0, import_dayjs2.default)(endStr) : null
+        };
+      }
+      default:
+        return { selectedDates: [], rangeStart: null, rangeEnd: null };
+    }
+  }, [value, mode, toLocalDateString]);
+  const handleDateSelect = useCallback3(
+    (selectedDate) => {
+      const effectiveDate = granularity === "month" ? selectedDate.endOf("month") : selectedDate;
+      const compareUnit = granularity === "month" ? "month" : "day";
+      switch (mode) {
+        case "single": {
+          let dateWithTime;
+          const activeTime = value?.time ?? defaultStartTime;
+          if (time.enabled) {
+            dateWithTime = composeLocalDateTime(effectiveDate, activeTime);
+          } else {
+            dateWithTime = composeDateOnly(effectiveDate, "start");
+          }
+          const newValue = {
+            date: dateWithTime.toISOString(),
+            time: time.enabled ? activeTime : void 0
+          };
+          onChange?.(newValue);
+          setDropdownKey((prev) => prev + 1);
+          break;
+        }
+        case "multiple": {
+          const currentDates = value?.date || [];
+          const currentDayjs = currentDates.map((d) => (0, import_dayjs2.default)(d));
+          const existingIndex = currentDayjs.findIndex((d) => d.isSame(effectiveDate, compareUnit));
+          let newDates;
+          if (existingIndex >= 0) {
+            newDates = currentDayjs.filter((_, index) => index !== existingIndex);
+          } else {
+            const activeTime = value?.time ?? defaultStartTime;
+            const dateWithTime = time.enabled ? composeLocalDateTime(effectiveDate, activeTime) : composeDateOnly(effectiveDate, "start");
+            newDates = [...currentDayjs, dateWithTime];
+          }
+          const newValue = {
+            date: newDates.map((d) => d.toISOString()),
+            time: time.enabled ? value?.time ?? defaultStartTime : void 0
+          };
+          onChange?.(newValue);
+          break;
+        }
+        case "range": {
+          const currentRange = value?.date || {
+            start: null,
+            end: null
+          };
+          const currentRangeTime = value?.time || {
+            start: defaultStartTime,
+            end: defaultEndTime
+          };
+          if (!currentRange.start || currentRange.start && currentRange.end) {
+            const startWithTime = time.enabled ? composeLocalDateTime(effectiveDate, currentRangeTime.start) : composeDateOnly(effectiveDate, "start");
+            const newValue = {
+              date: { start: startWithTime.toISOString(), end: null },
+              time: time.enabled ? currentRangeTime : void 0
+            };
+            onChange?.(newValue);
+          } else {
+            const start = time.enabled ? (0, import_dayjs2.default)(currentRange.start) : (0, import_dayjs2.default)(currentRange.start).tz(pickerTimezone);
+            let end = effectiveDate;
+            if (end.isBefore(start, compareUnit)) {
+              end = start;
+            }
+            end = time.enabled ? composeLocalDateTime(end, currentRangeTime.end) : composeDateOnly(end, "end");
+            const newValue = {
+              date: {
+                start: currentRange.start,
+                end: end.toISOString()
+              },
+              time: time.enabled ? currentRangeTime : void 0
+            };
+            onChange?.(newValue);
+            setDropdownKey((prev) => prev + 1);
+          }
+          break;
+        }
+      }
+    },
+    [
+      mode,
+      time,
+      value,
+      onChange,
+      defaultStartTime,
+      defaultEndTime,
+      composeDateOnly,
+      composeLocalDateTime,
+      pickerTimezone,
+      granularity
+    ]
+  );
+  const displayValue = useMemo2(() => {
+    if (!value?.date) return "";
+    const displayFmt = format.displayFormat || (granularity === "month" ? "MMM YYYY" : "MMM DD, YYYY");
+    const parseDateOnlyAware = (iso) => time.enabled ? (0, import_dayjs2.default)(iso) : (0, import_dayjs2.default)(iso).tz(pickerTimezone);
+    switch (mode) {
+      case "single": {
+        const date = parseDateOnlyAware(value.date);
+        let result = date.format(displayFmt);
+        if (time.enabled) {
+          const timeStr = time.includeSeconds ? date.format("HH:mm:ss") : date.format("HH:mm");
+          result += ` ${timeStr}`;
+        }
+        return result;
+      }
+      case "multiple": {
+        const dates = value.date;
+        if (time.enabled) {
+          const formattedDates = dates.map((d) => {
+            const date = parseDateOnlyAware(d);
+            const dateStr = date.format(displayFmt);
+            const timeStr = time.includeSeconds ? date.format("HH:mm:ss") : date.format("HH:mm");
+            return `${dateStr} ${timeStr}`;
+          });
+          return formattedDates.join(", ");
+        } else {
+          const formattedDates = dates.map((d) => parseDateOnlyAware(d).format(displayFmt));
+          return formattedDates.join(", ");
+        }
+      }
+      case "range": {
+        const rangeValue = value.date;
+        const parts = [];
+        if (rangeValue.start) {
+          const startDate = parseDateOnlyAware(rangeValue.start);
+          let startStr = startDate.format(displayFmt);
+          if (time.enabled) {
+            const timeStr = time.includeSeconds ? startDate.format("HH:mm:ss") : startDate.format("HH:mm");
+            startStr += ` ${timeStr}`;
+          }
+          parts.push(startStr);
+        }
+        if (rangeValue.end) {
+          const endDate = parseDateOnlyAware(rangeValue.end);
+          let endStr = endDate.format(displayFmt);
+          if (time.enabled) {
+            const timeStr = time.includeSeconds ? endDate.format("HH:mm:ss") : endDate.format("HH:mm");
+            endStr += ` ${timeStr}`;
+          }
+          parts.push(endStr);
+        }
+        return parts.join(" - ");
+      }
+      default:
+        return "";
+    }
+  }, [value, mode, time, format, pickerTimezone, granularity]);
+  const handleClear = useCallback3(
+    (e) => {
+      if (e) {
+        e.stopPropagation();
+      }
+      const clearedValue = (() => {
+        if (mode === "multiple") {
+          return {
+            date: [],
+            time: time.enabled ? defaultStartTime : void 0
+          };
+        } else if (mode === "range") {
+          return {
+            date: { start: null, end: null },
+            time: time.enabled ? {
+              start: defaultStartTime,
+              end: defaultEndTime
+            } : void 0
+          };
+        } else {
+          return {
+            date: null,
+            time: time.enabled ? defaultStartTime : void 0
+          };
+        }
+      })();
+      onChange?.(clearedValue);
+      setDropdownKey((prev) => prev + 1);
+    },
+    [mode, time, onChange, defaultStartTime, defaultEndTime]
+  );
+  const triggerElement = /* @__PURE__ */ jsx3(
+    "div",
+    {
+      ref: triggerRef,
+      className: `eidos-date-picker-trigger${fullWidth ? " eidos-date-picker-trigger--fullWidth" : ""}`,
+      children: /* @__PURE__ */ jsx3(
+        Input,
+        {
+          value: displayValue,
+          placeholder,
+          disabled,
+          required,
+          name,
+          id,
+          readOnly: true,
+          preIcon: CalendarIcon,
+          posIcon: displayValue ? X : void 0,
+          posIconButton: !!displayValue,
+          onPosIconClick: displayValue ? handleClear : void 0,
+          ...inputProps,
+          clearable: false
+        }
+      )
+    }
+  );
+  const dropdownContent = /* @__PURE__ */ jsxs3("div", { className: "eidos-date-picker-content", children: [
+    /* @__PURE__ */ jsx3("div", { className: "eidos-date-picker-calendars-wrapper", children: Array.from({ length: numberOfCalendars }, (_, index) => {
+      const calendarDate = calendarDates[index] ?? (0, import_dayjs2.default)().add(index, "month");
+      return /* @__PURE__ */ jsx3(
+        Calendar,
+        {
+          currentDate: calendarDate,
+          selectedDates,
+          rangeStart,
+          rangeEnd,
+          mode,
+          granularity,
+          onDateSelect: handleDateSelect,
+          onMonthChange: (newDate) => handleCalendarMonthChange(index, newDate),
+          minDate: minDateObj,
+          maxDate: maxDateObj,
+          disabledDates: disabledDatesObj,
+          disabledDaysOfWeek,
+          showWeekNumbers: calendar.showWeekNumbers,
+          firstDayOfWeek: calendar.firstDayOfWeek,
+          showNavigation: independentCalendars || index === 0
+        },
+        index
+      );
+    }) }),
+    time.enabled && /* @__PURE__ */ jsxs3("div", { className: "eidos-date-picker-time-container", children: [
+      mode === "single" && /* @__PURE__ */ jsx3(
+        TimeInput,
+        {
+          value: value?.time || defaultStartTime,
+          onChange: (newTime) => {
+            const currentIso = value?.date;
+            const newValue = {
+              ...value,
+              date: currentIso ? recomposeIsoWithTime(currentIso, newTime) : currentIso,
+              time: newTime
+            };
+            onChange?.(newValue);
+          },
+          includeSeconds: time.includeSeconds,
+          disabled,
+          label: "Time"
+        }
+      ),
+      mode === "multiple" && /* @__PURE__ */ jsx3(
+        TimeInput,
+        {
+          value: value?.time || defaultStartTime,
+          onChange: (newTime) => {
+            const currentDates = value?.date || [];
+            const newValue = {
+              ...value,
+              date: currentDates.map(
+                (d) => recomposeIsoWithTime(d, newTime)
+              ),
+              time: newTime
+            };
+            onChange?.(newValue);
+          },
+          includeSeconds: time.includeSeconds,
+          disabled,
+          label: "Time for all dates"
+        }
+      ),
+      mode === "range" && /* @__PURE__ */ jsxs3("div", { className: "eidos-date-picker-range-time-inputs", children: [
+        /* @__PURE__ */ jsx3(
+          TimeInput,
+          {
+            value: value?.time?.start || defaultStartTime,
+            onChange: (newTime) => {
+              const currentRangeTime = value?.time || {
+                start: defaultStartTime,
+                end: defaultEndTime
+              };
+              const currentRange = value?.date || {
+                start: null,
+                end: null
+              };
+              const newValue = {
+                ...value,
+                date: {
+                  ...currentRange,
+                  start: currentRange.start ? recomposeIsoWithTime(currentRange.start, newTime) : currentRange.start
+                },
+                time: {
+                  ...currentRangeTime,
+                  start: newTime
+                }
+              };
+              onChange?.(newValue);
+            },
+            includeSeconds: time.includeSeconds,
+            disabled,
+            label: "Start time"
+          }
+        ),
+        /* @__PURE__ */ jsx3(
+          TimeInput,
+          {
+            value: value?.time?.end || defaultEndTime,
+            onChange: (newTime) => {
+              const currentRangeTime = value?.time || {
+                start: defaultStartTime,
+                end: defaultEndTime
+              };
+              const currentRange = value?.date || {
+                start: null,
+                end: null
+              };
+              const newValue = {
+                ...value,
+                date: {
+                  ...currentRange,
+                  end: currentRange.end ? recomposeIsoWithTime(currentRange.end, newTime) : currentRange.end
+                },
+                time: {
+                  ...currentRangeTime,
+                  end: newTime
+                }
+              };
+              onChange?.(newValue);
+            },
+            includeSeconds: time.includeSeconds,
+            disabled,
+            label: "End time"
+          }
+        )
+      ] })
+    ] })
+  ] });
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      className: `eidos-date-picker-container${fullWidth ? " eidos-date-picker-container--fullWidth" : ""} ${className}`.trim(),
+      children: /* @__PURE__ */ jsx3(
+        Dropdown,
+        {
+          trigger: triggerElement,
+          content: dropdownContent,
+          placement: "bottom",
+          minWidth,
+          maxWidth: maxWidth || "none",
+          minHeight,
+          maxHeight: maxHeight || "none",
+          autoWidth,
+          triggerRef
+        },
+        dropdownKey
+      )
+    }
+  );
+};
+DatePicker.displayName = "DatePicker";
+
+export {
+  Calendar,
+  TimeInput,
+  DatePicker
+};
+//# sourceMappingURL=chunk-GL4DHGQE.js.map