var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));

// node_modules/dayjs/dayjs.min.js
var require_dayjs_min = __commonJS({
  "node_modules/dayjs/dayjs.min.js"(exports, module) {
    !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 = /\[([^\]]+)]|Y{1,4}|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 = /* @__PURE__ */ __name(function(t2, e2, n2) {
        var r2 = String(t2);
        return !r2 || r2.length >= e2 ? t2 : "" + Array(e2 + 1 - r2.length).join(n2) + t2;
      }, "m"), 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: /* @__PURE__ */ __name(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);
      }, "t"), 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 = /* @__PURE__ */ __name(function(t2) {
        return t2 instanceof _ || !(!t2 || !t2[p]);
      }, "S"), w = /* @__PURE__ */ __name(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;
      }, "t"), O = /* @__PURE__ */ __name(function(t2, e2) {
        if (S(t2))
          return t2.clone();
        var n2 = "object" == typeof e2 ? e2 : {};
        return n2.date = t2, n2.args = arguments, new _(n2);
      }, "O"), 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;
        }
        __name(M2, "M");
        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 = /* @__PURE__ */ __name(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);
          }, "l"), $2 = /* @__PURE__ */ __name(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 = /* @__PURE__ */ __name(function(t2) {
            var e2 = O(l2);
            return b.w(e2.date(e2.date() + Math.round(t2 * r2)), l2);
          }, "y");
          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 = /* @__PURE__ */ __name(function(t3, n3, i3, s3) {
            return t3 && (t3[n3] || t3(e2, r2)) || i3[n3].slice(0, s3);
          }, "h"), d2 = /* @__PURE__ */ __name(function(t3) {
            return b.s(s2 % 12 || 12, t3, "0");
          }, "d"), $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 = /* @__PURE__ */ __name(function() {
            return b.m(y2, m3);
          }, "D");
          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;
      }(), k = _.prototype;
      return O.prototype = k, [["$ms", r], ["$s", i], ["$m", s], ["$H", u], ["$W", a], ["$M", c], ["$y", h], ["$D", d]].forEach(function(t2) {
        k[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) {
    !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) {
    !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, o) {
        var r, a = /* @__PURE__ */ __name(function(t2, n2, i2) {
          void 0 === i2 && (i2 = {});
          var o2 = new Date(t2), r2 = function(t3, n3) {
            void 0 === n3 && (n3 = {});
            var i3 = n3.timeZoneName || "short", o3 = t3 + "|" + i3, r3 = e[o3];
            return r3 || (r3 = 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[o3] = r3), r3;
          }(n2, i2);
          return r2.formatToParts(o2);
        }, "a"), u = /* @__PURE__ */ __name(function(e2, n2) {
          for (var i2 = a(e2, n2), r2 = [], u2 = 0; u2 < i2.length; u2 += 1) {
            var f2 = i2[u2], s2 = f2.type, m = f2.value, c = t[s2];
            c >= 0 && (r2[c] = parseInt(m, 10));
          }
          var d = r2[3], l = 24 === d ? 0 : d, h = r2[0] + "-" + r2[1] + "-" + r2[2] + " " + l + ":" + r2[4] + ":" + r2[5] + ":000", v = +e2;
          return (o.utc(h).valueOf() - (v -= v % 1e3)) / 6e4;
        }, "u"), f = i.prototype;
        f.tz = function(t2, e2) {
          void 0 === t2 && (t2 = r);
          var n2, i2 = this.utcOffset(), a2 = this.toDate(), u2 = a2.toLocaleString("en-US", { timeZone: t2 }), f2 = Math.round((a2 - new Date(u2)) / 1e3 / 60), s2 = 15 * -Math.round(a2.getTimezoneOffset() / 15) - f2;
          if (!Number(s2))
            n2 = this.utcOffset(0, e2);
          else if (n2 = o(u2, { 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 || o.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 = o(this.format("YYYY-MM-DD HH:mm:ss:SSS"), { locale: this.$L });
          return s.call(n2, t2, e2).tz(this.$x.$timezone, true);
        }, o.tz = function(t2, e2, n2) {
          var i2 = n2 && e2, a2 = n2 || e2 || r, f2 = u(+o(), a2);
          if ("string" != typeof t2)
            return o(t2).tz(a2);
          var s2 = function(t3, e3, n3) {
            var i3 = t3 - 60 * e3 * 1e3, o2 = u(i3, n3);
            if (e3 === o2)
              return [i3, e3];
            var r2 = u(i3 -= 60 * (o2 - e3) * 1e3, n3);
            return o2 === r2 ? [i3, o2] : [t3 - 60 * Math.min(o2, r2) * 1e3, Math.max(o2, r2)];
          }(o.utc(t2, i2).valueOf(), f2, a2), m = s2[0], c = s2[1], d = o(m).utcOffset(c);
          return d.$x.$timezone = a2, d;
        }, o.tz.guess = function() {
          return Intl.DateTimeFormat().resolvedOptions().timeZone;
        }, o.tz.setDefault = function(t2) {
          r = t2;
        };
      };
    });
  }
});

// node_modules/dayjs/plugin/isoWeek.js
var require_isoWeek = __commonJS({
  "node_modules/dayjs/plugin/isoWeek.js"(exports, module) {
    !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_isoWeek = t();
    }(exports, function() {
      "use strict";
      var e = "day";
      return function(t, i, s) {
        var a = /* @__PURE__ */ __name(function(t2) {
          return t2.add(4 - t2.isoWeekday(), e);
        }, "a"), d = i.prototype;
        d.isoWeekYear = function() {
          return a(this).year();
        }, d.isoWeek = function(t2) {
          if (!this.$utils().u(t2))
            return this.add(7 * (t2 - this.isoWeek()), e);
          var i2, d2, n2, o, r = a(this), u = (i2 = this.isoWeekYear(), d2 = this.$u, n2 = (d2 ? s.utc : s)().year(i2).startOf("year"), o = 4 - n2.isoWeekday(), n2.isoWeekday() > 4 && (o += 7), n2.add(o, e));
          return r.diff(u, "week") + 1;
        }, d.isoWeekday = function(e2) {
          return this.$utils().u(e2) ? this.day() || 7 : this.day(this.day() % 7 ? e2 : e2 - 7);
        };
        var n = d.startOf;
        d.startOf = function(e2, t2) {
          var i2 = this.$utils(), s2 = !!i2.u(t2) || t2;
          return "isoweek" === i2.p(e2) ? s2 ? this.date(this.date() - (this.isoWeekday() - 1)).startOf("day") : this.date(this.date() - 1 - (this.isoWeekday() - 1) + 7).endOf("day") : n.bind(this)(e2, t2);
        };
      };
    });
  }
});

// node_modules/@novadi/core/dist/token.js
var tokenCounter = 0;
function Token(description) {
  const id = ++tokenCounter;
  const sym = Symbol(description ? `Token(${description})` : `Token#${id}`);
  const token2 = {
    symbol: sym,
    description,
    toString() {
      return description ? `Token<${description}>` : `Token<#${id}>`;
    }
  };
  return token2;
}
__name(Token, "Token");

// node_modules/@novadi/core/dist/errors.js
var _ContainerError = class _ContainerError extends Error {
  constructor(message) {
    super(message);
    this.name = "ContainerError";
  }
};
__name(_ContainerError, "ContainerError");
var ContainerError = _ContainerError;
var _BindingNotFoundError = class _BindingNotFoundError extends ContainerError {
  constructor(tokenDescription, path = []) {
    const pathStr = path.length > 0 ? `
  Dependency path: ${path.join(" -> ")}` : "";
    super(`Token "${tokenDescription}" is not bound or registered in the container.${pathStr}`);
    this.name = "BindingNotFoundError";
  }
};
__name(_BindingNotFoundError, "BindingNotFoundError");
var BindingNotFoundError = _BindingNotFoundError;
var _CircularDependencyError = class _CircularDependencyError extends ContainerError {
  constructor(path) {
    super(`Circular dependency detected: ${path.join(" -> ")}`);
    this.name = "CircularDependencyError";
  }
};
__name(_CircularDependencyError, "CircularDependencyError");
var CircularDependencyError = _CircularDependencyError;

// node_modules/@novadi/core/dist/autowire.js
var paramNameCache = /* @__PURE__ */ new WeakMap();
function extractParameterNames(constructor) {
  const cached = paramNameCache.get(constructor);
  if (cached) {
    return cached;
  }
  const fnStr = constructor.toString();
  const match = fnStr.match(/constructor\s*\(([^)]*)\)/) || fnStr.match(/^[^(]*\(([^)]*)\)/);
  if (!match || !match[1]) {
    return [];
  }
  const params = match[1].split(",").map((param) => param.trim()).filter((param) => param.length > 0).map((param) => {
    let name = param.split(/[:=]/)[0].trim();
    name = name.replace(/^((public|private|protected|readonly)\s+)+/, "");
    if (name.includes("{") || name.includes("[")) {
      return null;
    }
    return name;
  }).filter((name) => name !== null);
  paramNameCache.set(constructor, params);
  return params;
}
__name(extractParameterNames, "extractParameterNames");
function resolveByMap(constructor, container2, options) {
  if (!options.map) {
    throw new Error("AutoWire map strategy requires options.map to be defined");
  }
  const paramNames = extractParameterNames(constructor);
  const resolvedDeps = [];
  for (const paramName of paramNames) {
    const resolver = options.map[paramName];
    if (resolver === void 0) {
      if (options.strict) {
        throw new Error(`Cannot resolve parameter "${paramName}" on ${constructor.name}. Not found in autowire map. Add it to the map: .autoWire({ map: { ${paramName}: ... } })`);
      } else {
        resolvedDeps.push(void 0);
      }
      continue;
    }
    if (typeof resolver === "function") {
      resolvedDeps.push(resolver(container2));
    } else {
      resolvedDeps.push(container2.resolve(resolver));
    }
  }
  return resolvedDeps;
}
__name(resolveByMap, "resolveByMap");
function resolveByMapResolvers(_constructor, container2, options) {
  if (!options.mapResolvers || options.mapResolvers.length === 0) {
    return [];
  }
  const resolvedDeps = [];
  for (let i = 0; i < options.mapResolvers.length; i++) {
    const resolver = options.mapResolvers[i];
    if (resolver === void 0) {
      resolvedDeps.push(void 0);
    } else if (typeof resolver === "function") {
      resolvedDeps.push(resolver(container2));
    } else {
      resolvedDeps.push(container2.resolve(resolver));
    }
  }
  return resolvedDeps;
}
__name(resolveByMapResolvers, "resolveByMapResolvers");
function autowire(constructor, container2, options) {
  const opts = {
    by: "paramName",
    strict: false,
    ...options
  };
  if (opts.mapResolvers && opts.mapResolvers.length > 0) {
    return resolveByMapResolvers(constructor, container2, opts);
  }
  if (opts.map && Object.keys(opts.map).length > 0) {
    return resolveByMap(constructor, container2, opts);
  }
  return [];
}
__name(autowire, "autowire");

// node_modules/@novadi/core/dist/builder.js
var _RegistrationBuilder = class _RegistrationBuilder {
  constructor(pending, registrations) {
    this.registrations = registrations;
    this.configs = [];
    this.defaultLifetime = "singleton";
    this.pending = pending;
  }
  /**
   * Bind this registration to a token or interface type
   *
   * @overload
   * @param {Token<U>} token - Explicit token for binding
   *
   * @overload
   * @param {string} typeName - Interface type name (auto-generated by transformer)
   */
  as(tokenOrTypeName) {
    if (tokenOrTypeName && typeof tokenOrTypeName === "object" && "symbol" in tokenOrTypeName) {
      const config = {
        token: tokenOrTypeName,
        type: this.pending.type,
        value: this.pending.value,
        factory: this.pending.factory,
        constructor: this.pending.constructor,
        lifetime: this.defaultLifetime
      };
      this.configs.push(config);
      this.registrations.push(config);
      return this;
    } else {
      const config = {
        token: null,
        // Will be set during build()
        type: this.pending.type,
        value: this.pending.value,
        factory: this.pending.factory,
        constructor: this.pending.constructor,
        lifetime: this.defaultLifetime,
        interfaceType: tokenOrTypeName
      };
      this.configs.push(config);
      this.registrations.push(config);
      return this;
    }
  }
  /**
   * Register as default implementation for an interface
   * Combines as() + asDefault()
   */
  asDefaultInterface(typeName) {
    this.as("TInterface", typeName);
    return this.asDefault();
  }
  /**
   * Register as a keyed interface implementation
   * Combines as() + keyed()
   */
  asKeyedInterface(key, typeName) {
    this.as("TInterface", typeName);
    return this.keyed(key);
  }
  /**
   * Register as multiple implemented interfaces
   */
  asImplementedInterfaces(tokens) {
    if (tokens.length === 0) {
      return this;
    }
    if (this.configs.length > 0) {
      for (const config of this.configs) {
        config.lifetime = "singleton";
        config.additionalTokens = config.additionalTokens || [];
        config.additionalTokens.push(...tokens);
      }
      return this;
    }
    const firstConfig = {
      token: tokens[0],
      type: this.pending.type,
      value: this.pending.value,
      factory: this.pending.factory,
      constructor: this.pending.constructor,
      lifetime: "singleton"
    };
    this.configs.push(firstConfig);
    this.registrations.push(firstConfig);
    for (let i = 1; i < tokens.length; i++) {
      firstConfig.additionalTokens = firstConfig.additionalTokens || [];
      firstConfig.additionalTokens.push(tokens[i]);
    }
    return this;
  }
  /**
   * Set singleton lifetime (one instance for entire container)
   */
  singleInstance() {
    for (const config of this.configs) {
      config.lifetime = "singleton";
    }
    return this;
  }
  /**
   * Set per-request lifetime (one instance per resolve call tree)
   */
  instancePerRequest() {
    for (const config of this.configs) {
      config.lifetime = "per-request";
    }
    return this;
  }
  /**
   * Set transient lifetime (new instance every time)
   * Alias for default behavior
   */
  instancePerDependency() {
    for (const config of this.configs) {
      config.lifetime = "transient";
    }
    return this;
  }
  /**
   * Name this registration for named resolution
   */
  named(name) {
    for (const config of this.configs) {
      config.name = name;
    }
    return this;
  }
  /**
   * Key this registration for keyed resolution
   */
  keyed(key) {
    for (const config of this.configs) {
      config.key = key;
    }
    return this;
  }
  /**
   * Mark this as default registration
   * Default registrations don't override existing ones
   */
  asDefault() {
    for (const config of this.configs) {
      config.isDefault = true;
    }
    return this;
  }
  /**
   * Only register if token not already registered
   */
  ifNotRegistered() {
    for (const config of this.configs) {
      config.ifNotRegistered = true;
    }
    return this;
  }
  /**
   * Specify parameter values for constructor (primitives and constants)
   * Use this for non-DI parameters like strings, numbers, config values
   */
  withParameters(parameters) {
    for (const config of this.configs) {
      config.parameterValues = parameters;
    }
    return this;
  }
  /**
   * Enable automatic dependency injection (autowiring)
   * Supports three strategies: paramName (default), map, and class
   *
   * @example
   * ```ts
   * // Strategy 1: paramName (default, requires non-minified code in dev)
   * builder.registerType(EventBus).as<IEventBus>().autoWire()
   *
   * // Strategy 2: map (minify-safe, explicit)
   * builder.registerType(EventBus).as<IEventBus>().autoWire({
   *   map: {
   *     logger: (c) => c.resolveType<ILogger>()
   *   }
   * })
   *
   * // Strategy 3: class (requires build-time codegen)
   * builder.registerType(EventBus).as<IEventBus>().autoWire({ by: 'class' })
   * ```
   */
  autoWire(options) {
    for (const config of this.configs) {
      config.autowireOptions = options || { by: "paramName", strict: false };
    }
    return this;
  }
};
__name(_RegistrationBuilder, "RegistrationBuilder");
var RegistrationBuilder = _RegistrationBuilder;
var _Builder = class _Builder {
  constructor(baseContainer) {
    this.baseContainer = baseContainer;
    this.registrations = [];
  }
  /**
   * Register a class constructor
   */
  registerType(constructor) {
    const pending = {
      type: "type",
      value: null,
      constructor
    };
    return new RegistrationBuilder(pending, this.registrations);
  }
  /**
   * Register a pre-created instance
   */
  registerInstance(instance) {
    const pending = {
      type: "instance",
      value: instance,
      constructor: void 0
    };
    return new RegistrationBuilder(pending, this.registrations);
  }
  /**
   * Register a factory function
   */
  register(factory) {
    const pending = {
      type: "factory",
      value: null,
      factory,
      constructor: void 0
    };
    return new RegistrationBuilder(pending, this.registrations);
  }
  /**
   * Register a module (function that adds multiple registrations)
   */
  module(moduleFunc) {
    moduleFunc(this);
    return this;
  }
  /**
   * Resolve interface type names to tokens
   * @internal
   */
  resolveInterfaceTokens(container2) {
    for (const config of this.registrations) {
      if (config.interfaceType !== void 0 && !config.token) {
        config.token = container2.interfaceToken(config.interfaceType);
      }
    }
  }
  /**
   * Identify tokens that have non-default registrations
   * @internal
   */
  identifyNonDefaultTokens() {
    const tokensWithNonDefaults = /* @__PURE__ */ new Set();
    for (const config of this.registrations) {
      if (!config.isDefault && !config.name && config.key === void 0) {
        tokensWithNonDefaults.add(config.token);
      }
    }
    return tokensWithNonDefaults;
  }
  /**
   * Check if registration should be skipped
   * @internal
   */
  shouldSkipRegistration(config, tokensWithNonDefaults, registeredTokens) {
    if (config.isDefault && !config.name && config.key === void 0 && tokensWithNonDefaults.has(config.token)) {
      return true;
    }
    if (config.ifNotRegistered && registeredTokens.has(config.token)) {
      return true;
    }
    if (config.isDefault && registeredTokens.has(config.token)) {
      return true;
    }
    return false;
  }
  /**
   * Create binding token for registration (named, keyed, or multi)
   * @internal
   */
  createBindingToken(config, namedRegistrations, keyedRegistrations, multiRegistrations) {
    if (config.name) {
      const bindingToken = Token(`__named_${config.name}`);
      namedRegistrations.set(config.name, { ...config, token: bindingToken });
      return bindingToken;
    } else if (config.key !== void 0) {
      const keyStr = typeof config.key === "symbol" ? config.key.toString() : config.key;
      const bindingToken = Token(`__keyed_${keyStr}`);
      keyedRegistrations.set(config.key, { ...config, token: bindingToken });
      return bindingToken;
    } else {
      if (multiRegistrations.has(config.token)) {
        const bindingToken = Token(`__multi_${config.token.toString()}_${multiRegistrations.get(config.token).length}`);
        multiRegistrations.get(config.token).push(bindingToken);
        return bindingToken;
      } else {
        multiRegistrations.set(config.token, [config.token]);
        return config.token;
      }
    }
  }
  /**
   * Register additional interfaces for a config
   * @internal
   */
  registerAdditionalInterfaces(container2, config, bindingToken, registeredTokens) {
    if (config.additionalTokens) {
      for (const additionalToken of config.additionalTokens) {
        container2.bindFactory(additionalToken, (c) => c.resolve(bindingToken), { lifetime: config.lifetime });
        registeredTokens.add(additionalToken);
      }
    }
  }
  /**
   * Build the container with all registered bindings
   */
  build() {
    const container2 = this.baseContainer.createChild();
    this.resolveInterfaceTokens(container2);
    const registeredTokens = /* @__PURE__ */ new Set();
    const namedRegistrations = /* @__PURE__ */ new Map();
    const keyedRegistrations = /* @__PURE__ */ new Map();
    const multiRegistrations = /* @__PURE__ */ new Map();
    const tokensWithNonDefaults = this.identifyNonDefaultTokens();
    for (const config of this.registrations) {
      if (this.shouldSkipRegistration(config, tokensWithNonDefaults, registeredTokens)) {
        continue;
      }
      const bindingToken = this.createBindingToken(config, namedRegistrations, keyedRegistrations, multiRegistrations);
      this.applyRegistration(container2, { ...config, token: bindingToken });
      registeredTokens.add(config.token);
      this.registerAdditionalInterfaces(container2, config, bindingToken, registeredTokens);
    }
    ;
    container2.__namedRegistrations = namedRegistrations;
    container2.__keyedRegistrations = keyedRegistrations;
    container2.__multiRegistrations = multiRegistrations;
    return container2;
  }
  /**
   * Analyze constructor to detect dependencies
   * @internal
   */
  analyzeConstructor(constructor) {
    const constructorStr = constructor.toString();
    const hasDependencies = /constructor\s*\([^)]+\)/.test(constructorStr);
    return { hasDependencies };
  }
  /**
   * Create optimized factory for zero-dependency constructors
   * @internal
   */
  createOptimizedFactory(container2, config, options) {
    if (config.lifetime === "singleton") {
      const instance = new config.constructor();
      container2.bindValue(config.token, instance);
    } else if (config.lifetime === "transient") {
      const ctor = config.constructor;
      const fastFactory = /* @__PURE__ */ __name(() => new ctor(), "fastFactory");
      container2.fastTransientCache.set(config.token, fastFactory);
      container2.bindFactory(config.token, fastFactory, options);
    } else {
      const factory = /* @__PURE__ */ __name(() => new config.constructor(), "factory");
      container2.bindFactory(config.token, factory, options);
    }
  }
  /**
   * Create autowire factory
   * @internal
   */
  createAutoWireFactory(container2, config, options) {
    const factory = /* @__PURE__ */ __name((c) => {
      const resolvedDeps = autowire(config.constructor, c, config.autowireOptions);
      return new config.constructor(...resolvedDeps);
    }, "factory");
    container2.bindFactory(config.token, factory, options);
  }
  /**
   * Create withParameters factory
   * @internal
   */
  createParameterFactory(container2, config, options) {
    const factory = /* @__PURE__ */ __name(() => {
      const values = Object.values(config.parameterValues);
      return new config.constructor(...values);
    }, "factory");
    container2.bindFactory(config.token, factory, options);
  }
  /**
   * Apply type registration (class constructor)
   * @internal
   */
  applyTypeRegistration(container2, config, options) {
    const { hasDependencies } = this.analyzeConstructor(config.constructor);
    if (!hasDependencies && !config.autowireOptions && !config.parameterValues) {
      this.createOptimizedFactory(container2, config, options);
      return;
    }
    if (config.autowireOptions) {
      this.createAutoWireFactory(container2, config, options);
      return;
    }
    if (config.parameterValues) {
      this.createParameterFactory(container2, config, options);
      return;
    }
    if (hasDependencies) {
      const className = config.constructor.name || "UnnamedClass";
      throw new Error(`Service "${className}" has constructor dependencies but no autowiring configuration.

Solutions:
  1. \u2B50 Use the NovaDI transformer (recommended):
     - Add "@novadi/core/unplugin" to your build config
     - Transformer automatically generates .autoWire() for all dependencies

  2. Add manual autowiring:
     .autoWire({ map: { /* param: resolver */ } })

  3. Use a factory function:
     .register((c) => new ${className}(...))

See docs: https://github.com/janus007/NovaDI#autowire`);
    }
    const factory = /* @__PURE__ */ __name(() => new config.constructor(), "factory");
    container2.bindFactory(config.token, factory, options);
  }
  applyRegistration(container2, config) {
    const options = { lifetime: config.lifetime };
    switch (config.type) {
      case "instance":
        container2.bindValue(config.token, config.value);
        break;
      case "factory":
        container2.bindFactory(config.token, config.factory, options);
        break;
      case "type":
        this.applyTypeRegistration(container2, config, options);
        break;
    }
  }
};
__name(_Builder, "Builder");
var Builder = _Builder;

// node_modules/@novadi/core/dist/container.js
function isDisposable(obj) {
  return obj && typeof obj.dispose === "function";
}
__name(isDisposable, "isDisposable");
var _ResolutionContext = class _ResolutionContext {
  constructor() {
    this.resolvingStack = /* @__PURE__ */ new Set();
    this.perRequestCache = /* @__PURE__ */ new Map();
  }
  isResolving(token2) {
    return this.resolvingStack.has(token2);
  }
  enterResolve(token2) {
    this.resolvingStack.add(token2);
  }
  exitResolve(token2) {
    this.resolvingStack.delete(token2);
    this.path = void 0;
  }
  getPath() {
    if (!this.path) {
      this.path = Array.from(this.resolvingStack).map((t) => t.toString());
    }
    return [...this.path];
  }
  cachePerRequest(token2, instance) {
    this.perRequestCache.set(token2, instance);
  }
  getPerRequest(token2) {
    return this.perRequestCache.get(token2);
  }
  hasPerRequest(token2) {
    return this.perRequestCache.has(token2);
  }
  /**
   * Reset context for reuse in object pool
   * Performance: Reusing contexts avoids heap allocations
   */
  reset() {
    this.resolvingStack.clear();
    this.perRequestCache.clear();
    this.path = void 0;
  }
};
__name(_ResolutionContext, "ResolutionContext");
var ResolutionContext = _ResolutionContext;
var _ResolutionContextPool = class _ResolutionContextPool {
  constructor() {
    this.pool = [];
    this.maxSize = 10;
  }
  acquire() {
    const context = this.pool.pop();
    if (context) {
      context.reset();
      return context;
    }
    return new ResolutionContext();
  }
  release(context) {
    if (this.pool.length < this.maxSize) {
      this.pool.push(context);
    }
  }
};
__name(_ResolutionContextPool, "ResolutionContextPool");
var ResolutionContextPool = _ResolutionContextPool;
var _Container = class _Container {
  constructor(parent) {
    this.bindings = /* @__PURE__ */ new Map();
    this.singletonCache = /* @__PURE__ */ new Map();
    this.singletonOrder = [];
    this.interfaceRegistry = /* @__PURE__ */ new Map();
    this.interfaceTokenCache = /* @__PURE__ */ new Map();
    this.fastTransientCache = /* @__PURE__ */ new Map();
    this.ultraFastSingletonCache = /* @__PURE__ */ new Map();
    this.parent = parent;
  }
  /**
   * Bind a pre-created value to a token
   */
  bindValue(token2, value) {
    this.bindings.set(token2, {
      type: "value",
      lifetime: "singleton",
      value,
      constructor: void 0
    });
    this.invalidateBindingCache();
  }
  /**
   * Bind a factory function to a token
   */
  bindFactory(token2, factory, options) {
    this.bindings.set(token2, {
      type: "factory",
      lifetime: options?.lifetime || "transient",
      factory,
      dependencies: options?.dependencies,
      constructor: void 0
    });
    this.invalidateBindingCache();
  }
  /**
   * Bind a class constructor to a token
   */
  bindClass(token2, constructor, options) {
    const binding = {
      type: "class",
      lifetime: options?.lifetime || "transient",
      constructor,
      dependencies: options?.dependencies
    };
    this.bindings.set(token2, binding);
    this.invalidateBindingCache();
    if (binding.lifetime === "transient" && (!binding.dependencies || binding.dependencies.length === 0)) {
      this.fastTransientCache.set(token2, () => new constructor());
    }
  }
  /**
   * Resolve a dependency synchronously
   * Performance optimized with multiple fast paths
   */
  resolve(token2) {
    const cached = this.tryGetFromCaches(token2);
    if (cached !== void 0) {
      return cached;
    }
    if (this.currentContext) {
      return this.resolveWithContext(token2, this.currentContext);
    }
    const context = _Container.contextPool.acquire();
    this.currentContext = context;
    try {
      return this.resolveWithContext(token2, context);
    } finally {
      this.currentContext = void 0;
      _Container.contextPool.release(context);
    }
  }
  /**
   * SPECIALIZED: Ultra-fast singleton resolve (no safety checks)
   * Use ONLY when you're 100% sure the token is a registered singleton
   * @internal For performance-critical paths only
   */
  resolveSingletonUnsafe(token2) {
    return this.ultraFastSingletonCache.get(token2) ?? this.singletonCache.get(token2);
  }
  /**
   * SPECIALIZED: Fast transient resolve for zero-dependency classes
   * Skips all context creation and circular dependency checks
   * @internal For performance-critical paths only
   */
  resolveTransientSimple(token2) {
    const factory = this.fastTransientCache.get(token2);
    if (factory) {
      return factory();
    }
    return this.resolve(token2);
  }
  /**
   * SPECIALIZED: Batch resolve multiple dependencies at once
   * More efficient than multiple individual resolves
   */
  resolveBatch(tokens) {
    const wasResolving = !!this.currentContext;
    const context = this.currentContext || _Container.contextPool.acquire();
    if (!wasResolving) {
      this.currentContext = context;
    }
    try {
      const results = tokens.map((token2) => {
        const cached = this.tryGetFromCaches(token2);
        if (cached !== void 0)
          return cached;
        return this.resolveWithContext(token2, context);
      });
      return results;
    } finally {
      if (!wasResolving) {
        this.currentContext = void 0;
        _Container.contextPool.release(context);
      }
    }
  }
  /**
   * Resolve a dependency asynchronously (supports async factories)
   */
  async resolveAsync(token2) {
    if (this.currentContext) {
      return this.resolveAsyncWithContext(token2, this.currentContext);
    }
    const context = _Container.contextPool.acquire();
    this.currentContext = context;
    try {
      return await this.resolveAsyncWithContext(token2, context);
    } finally {
      this.currentContext = void 0;
      _Container.contextPool.release(context);
    }
  }
  /**
   * Try to get instance from all cache levels
   * Returns undefined if not cached
   * @internal
   */
  tryGetFromCaches(token2) {
    const ultraFast = this.ultraFastSingletonCache.get(token2);
    if (ultraFast !== void 0) {
      return ultraFast;
    }
    if (this.singletonCache.has(token2)) {
      const cached = this.singletonCache.get(token2);
      this.ultraFastSingletonCache.set(token2, cached);
      return cached;
    }
    const fastFactory = this.fastTransientCache.get(token2);
    if (fastFactory) {
      return fastFactory();
    }
    return void 0;
  }
  /**
   * Cache instance based on lifetime strategy
   * @internal
   */
  cacheInstance(token2, instance, lifetime, context) {
    if (lifetime === "singleton") {
      this.singletonCache.set(token2, instance);
      this.singletonOrder.push(token2);
      this.ultraFastSingletonCache.set(token2, instance);
    } else if (lifetime === "per-request" && context) {
      context.cachePerRequest(token2, instance);
    }
  }
  /**
   * Validate and get binding with circular dependency check
   * Returns binding or throws error
   * @internal
   */
  validateAndGetBinding(token2, context) {
    if (context.isResolving(token2)) {
      throw new CircularDependencyError([...context.getPath(), token2.toString()]);
    }
    const binding = this.getBinding(token2);
    if (!binding) {
      throw new BindingNotFoundError(token2.toString(), context.getPath());
    }
    return binding;
  }
  /**
   * Instantiate from binding synchronously
   * @internal
   */
  instantiateBindingSync(binding, token2, context) {
    switch (binding.type) {
      case "value":
        return binding.value;
      case "factory":
        const result = binding.factory(this);
        if (result instanceof Promise) {
          throw new Error(`Async factory detected for ${token2.toString()}. Use resolveAsync() instead.`);
        }
        return result;
      case "class":
        const deps = binding.dependencies || [];
        const resolvedDeps = deps.map((dep) => this.resolveWithContext(dep, context));
        return new binding.constructor(...resolvedDeps);
      case "inline-class":
        return new binding.constructor();
      default:
        throw new Error(`Unknown binding type: ${binding.type}`);
    }
  }
  /**
   * Instantiate from binding asynchronously
   * @internal
   */
  async instantiateBindingAsync(binding, context) {
    switch (binding.type) {
      case "value":
        return binding.value;
      case "factory":
        return await Promise.resolve(binding.factory(this));
      case "class":
        const deps = binding.dependencies || [];
        const resolvedDeps = await Promise.all(deps.map((dep) => this.resolveAsyncWithContext(dep, context)));
        return new binding.constructor(...resolvedDeps);
      case "inline-class":
        return new binding.constructor();
      default:
        throw new Error(`Unknown binding type: ${binding.type}`);
    }
  }
  /**
   * Create a child container that inherits bindings from this container
   */
  createChild() {
    return new _Container(this);
  }
  /**
   * Dispose all singleton instances in reverse registration order
   */
  async dispose() {
    const errors = [];
    for (let i = this.singletonOrder.length - 1; i >= 0; i--) {
      const token2 = this.singletonOrder[i];
      const instance = this.singletonCache.get(token2);
      if (instance && isDisposable(instance)) {
        try {
          await instance.dispose();
        } catch (error) {
          errors.push(error);
        }
      }
    }
    this.singletonCache.clear();
    this.singletonOrder.length = 0;
  }
  /**
   * Create a fluent builder for registering dependencies
   */
  builder() {
    return new Builder(this);
  }
  /**
   * Resolve a named service
   */
  resolveNamed(name) {
    const namedRegistrations = this.__namedRegistrations;
    if (!namedRegistrations) {
      throw new Error(`Named service "${name}" not found. No named registrations exist.`);
    }
    const config = namedRegistrations.get(name);
    if (!config) {
      throw new Error(`Named service "${name}" not found`);
    }
    return this.resolve(config.token);
  }
  /**
   * Resolve a keyed service
   */
  resolveKeyed(key) {
    const keyedRegistrations = this.__keyedRegistrations;
    if (!keyedRegistrations) {
      throw new Error(`Keyed service not found. No keyed registrations exist.`);
    }
    const config = keyedRegistrations.get(key);
    if (!config) {
      const keyStr = typeof key === "symbol" ? key.toString() : `"${key}"`;
      throw new Error(`Keyed service ${keyStr} not found`);
    }
    return this.resolve(config.token);
  }
  /**
   * Resolve all registrations for a token
   */
  resolveAll(token2) {
    const multiRegistrations = this.__multiRegistrations;
    if (!multiRegistrations) {
      return [];
    }
    const tokens = multiRegistrations.get(token2);
    if (!tokens || tokens.length === 0) {
      return [];
    }
    return tokens.map((t) => this.resolve(t));
  }
  /**
   * Get registry information for debugging/visualization
   * Returns array of binding information
   */
  getRegistry() {
    const registry = [];
    this.bindings.forEach((binding, token2) => {
      registry.push({
        token: token2.description || token2.symbol.toString(),
        type: binding.type,
        lifetime: binding.lifetime,
        dependencies: binding.dependencies?.map((d) => d.description || d.symbol.toString())
      });
    });
    return registry;
  }
  /**
   * Get or create a token for an interface type
   * Uses a type name hash as key for the interface registry
   */
  interfaceToken(typeName) {
    const key = typeName || `Interface_${Math.random().toString(36).substr(2, 9)}`;
    if (this.interfaceRegistry.has(key)) {
      return this.interfaceRegistry.get(key);
    }
    if (this.parent) {
      const parentToken = this.parent.interfaceToken(key);
      return parentToken;
    }
    const token2 = Token(key);
    this.interfaceRegistry.set(key, token2);
    return token2;
  }
  /**
   * Resolve a dependency by interface type without explicit token
   */
  resolveType(typeName) {
    const key = typeName || "";
    let token2 = this.interfaceTokenCache.get(key);
    if (!token2) {
      token2 = this.interfaceToken(typeName);
      this.interfaceTokenCache.set(key, token2);
    }
    return this.resolve(token2);
  }
  /**
   * Resolve a keyed interface
   */
  resolveTypeKeyed(key, _typeName) {
    return this.resolveKeyed(key);
  }
  /**
   * Resolve all registrations for an interface type
   */
  resolveTypeAll(typeName) {
    const token2 = this.interfaceToken(typeName);
    return this.resolveAll(token2);
  }
  /**
   * Internal: Resolve with context for circular dependency detection
   */
  resolveWithContext(token2, context) {
    const binding = this.validateAndGetBinding(token2, context);
    if (binding.lifetime === "per-request" && context.hasPerRequest(token2)) {
      return context.getPerRequest(token2);
    }
    if (binding.lifetime === "singleton" && this.singletonCache.has(token2)) {
      return this.singletonCache.get(token2);
    }
    context.enterResolve(token2);
    try {
      const instance = this.instantiateBindingSync(binding, token2, context);
      this.cacheInstance(token2, instance, binding.lifetime, context);
      return instance;
    } finally {
      context.exitResolve(token2);
    }
  }
  /**
   * Internal: Async resolve with context
   */
  async resolveAsyncWithContext(token2, context) {
    const binding = this.validateAndGetBinding(token2, context);
    if (binding.lifetime === "per-request" && context.hasPerRequest(token2)) {
      return context.getPerRequest(token2);
    }
    if (binding.lifetime === "singleton" && this.singletonCache.has(token2)) {
      return this.singletonCache.get(token2);
    }
    context.enterResolve(token2);
    try {
      const instance = await this.instantiateBindingAsync(binding, context);
      this.cacheInstance(token2, instance, binding.lifetime, context);
      return instance;
    } finally {
      context.exitResolve(token2);
    }
  }
  /**
   * Get binding from this container or parent chain
   * Performance optimized: Uses flat cache to avoid recursive parent lookups
   */
  getBinding(token2) {
    if (!this.bindingCache) {
      this.buildBindingCache();
    }
    return this.bindingCache.get(token2);
  }
  /**
   * Build flat cache of all bindings including parent chain
   * This converts O(n) parent chain traversal to O(1) lookup
   */
  buildBindingCache() {
    this.bindingCache = /* @__PURE__ */ new Map();
    let current = this;
    while (current) {
      current.bindings.forEach((binding, token2) => {
        if (!this.bindingCache.has(token2)) {
          this.bindingCache.set(token2, binding);
        }
      });
      current = current.parent;
    }
  }
  /**
   * Invalidate binding cache when new bindings are added
   * Called by bindValue, bindFactory, bindClass
   */
  invalidateBindingCache() {
    this.bindingCache = void 0;
    this.ultraFastSingletonCache.clear();
  }
};
__name(_Container, "Container");
var Container = _Container;
Container.contextPool = new ResolutionContextPool();

// src/features/date/DateRenderer.ts
var _DateRenderer = class _DateRenderer {
  constructor(dateService) {
    this.dateService = dateService;
    this.type = "date";
  }
  render(context) {
    const dates = context.filter["date"] || [];
    const resourceIds = context.filter["resource"] || [];
    const dateGrouping = context.groupings?.find((g) => g.type === "date");
    const hideHeader = dateGrouping?.hideHeader === true;
    const iterations = resourceIds.length || 1;
    let columnCount = 0;
    for (let r = 0; r < iterations; r++) {
      const resourceId = resourceIds[r];
      for (const dateStr of dates) {
        const date = this.dateService.parseISO(dateStr);
        const segments = { date: dateStr };
        if (resourceId)
          segments.resource = resourceId;
        const columnKey = this.dateService.buildColumnKey(segments);
        const header = document.createElement("swp-day-header");
        header.dataset.date = dateStr;
        header.dataset.columnKey = columnKey;
        if (resourceId) {
          header.dataset.resourceId = resourceId;
        }
        if (hideHeader) {
          header.dataset.hidden = "true";
        }
        header.innerHTML = `
          <swp-day-name>${this.dateService.getDayName(date, "short")}</swp-day-name>
          <swp-day-date>${date.getDate()}</swp-day-date>
        `;
        context.headerContainer.appendChild(header);
        const column = document.createElement("swp-day-column");
        column.dataset.date = dateStr;
        column.dataset.columnKey = columnKey;
        if (resourceId) {
          column.dataset.resourceId = resourceId;
        }
        column.innerHTML = "<swp-events-layer></swp-events-layer>";
        context.columnContainer.appendChild(column);
        columnCount++;
      }
    }
    const container2 = context.columnContainer.closest("swp-calendar-container");
    if (container2) {
      container2.style.setProperty("--grid-columns", String(columnCount));
    }
  }
};
__name(_DateRenderer, "DateRenderer");
var DateRenderer = _DateRenderer;

// src/core/DateService.ts
var import_dayjs = __toESM(require_dayjs_min(), 1);
var import_utc = __toESM(require_utc(), 1);
var import_timezone = __toESM(require_timezone(), 1);
var import_isoWeek = __toESM(require_isoWeek(), 1);
import_dayjs.default.extend(import_utc.default);
import_dayjs.default.extend(import_timezone.default);
import_dayjs.default.extend(import_isoWeek.default);
var _DateService = class _DateService {
  constructor(config, baseDate) {
    this.config = config;
    this.timezone = config.timezone;
    this.baseDate = baseDate ? (0, import_dayjs.default)(baseDate) : (0, import_dayjs.default)();
  }
  /**
   * Set a fixed base date (useful for demos with static mock data)
   */
  setBaseDate(date) {
    this.baseDate = (0, import_dayjs.default)(date);
  }
  /**
   * Get the current base date (either fixed or today)
   */
  getBaseDate() {
    return this.baseDate.toDate();
  }
  parseISO(isoString) {
    return (0, import_dayjs.default)(isoString).toDate();
  }
  getDayName(date, format = "short") {
    return new Intl.DateTimeFormat(this.config.locale, { weekday: format }).format(date);
  }
  /**
   * Get dates starting from a day offset
   * @param dayOffset - Day offset from base date
   * @param count - Number of consecutive days to return
   * @returns Array of date strings in YYYY-MM-DD format
   */
  getDatesFromOffset(dayOffset, count) {
    const startDate = this.baseDate.add(dayOffset, "day");
    return Array.from({ length: count }, (_, i) => startDate.add(i, "day").format("YYYY-MM-DD"));
  }
  /**
   * Get specific weekdays from the week containing the offset date
   * @param dayOffset - Day offset from base date
   * @param workDays - Array of ISO weekday numbers (1=Monday, 7=Sunday)
   * @returns Array of date strings in YYYY-MM-DD format
   */
  getWorkDaysFromOffset(dayOffset, workDays) {
    const targetDate = this.baseDate.add(dayOffset, "day");
    const monday = targetDate.startOf("week").add(1, "day");
    return workDays.map((isoDay) => {
      const daysFromMonday = isoDay === 7 ? 6 : isoDay - 1;
      return monday.add(daysFromMonday, "day").format("YYYY-MM-DD");
    });
  }
  // Legacy methods for backwards compatibility
  getWeekDates(weekOffset = 0, days = 7) {
    return this.getDatesFromOffset(weekOffset * 7, days);
  }
  getWorkWeekDates(weekOffset, workDays) {
    return this.getWorkDaysFromOffset(weekOffset * 7, workDays);
  }
  // ============================================
  // FORMATTING
  // ============================================
  formatTime(date, showSeconds = false) {
    const pattern = showSeconds ? "HH:mm:ss" : "HH:mm";
    return (0, import_dayjs.default)(date).format(pattern);
  }
  formatTimeRange(start, end) {
    return `${this.formatTime(start)} - ${this.formatTime(end)}`;
  }
  formatDate(date) {
    return (0, import_dayjs.default)(date).format("YYYY-MM-DD");
  }
  getDateKey(date) {
    return this.formatDate(date);
  }
  // ============================================
  // COLUMN KEY
  // ============================================
  /**
   * Build a uniform columnKey from grouping segments
   * Handles any combination of date, resource, team, etc.
   *
   * @example
   * buildColumnKey({ date: '2025-12-09' }) → "2025-12-09"
   * buildColumnKey({ date: '2025-12-09', resource: 'EMP001' }) → "2025-12-09:EMP001"
   */
  buildColumnKey(segments) {
    const date = segments.date;
    const others = Object.entries(segments).filter(([k]) => k !== "date").sort(([a], [b]) => a.localeCompare(b)).map(([, v]) => v);
    return date ? [date, ...others].join(":") : others.join(":");
  }
  /**
   * Parse a columnKey back into segments
   * Assumes format: "date:resource:..." or just "date"
   */
  parseColumnKey(columnKey) {
    const parts = columnKey.split(":");
    return {
      date: parts[0],
      resource: parts[1]
    };
  }
  /**
   * Extract dateKey from columnKey (first segment)
   */
  getDateFromColumnKey(columnKey) {
    return columnKey.split(":")[0];
  }
  // ============================================
  // TIME CALCULATIONS
  // ============================================
  timeToMinutes(timeString) {
    const parts = timeString.split(":").map(Number);
    const hours = parts[0] || 0;
    const minutes = parts[1] || 0;
    return hours * 60 + minutes;
  }
  minutesToTime(totalMinutes) {
    const hours = Math.floor(totalMinutes / 60);
    const minutes = totalMinutes % 60;
    return (0, import_dayjs.default)().hour(hours).minute(minutes).format("HH:mm");
  }
  getMinutesSinceMidnight(date) {
    const d = (0, import_dayjs.default)(date);
    return d.hour() * 60 + d.minute();
  }
  // ============================================
  // UTC CONVERSIONS
  // ============================================
  toUTC(localDate) {
    return import_dayjs.default.tz(localDate, this.timezone).utc().toISOString();
  }
  fromUTC(utcString) {
    return import_dayjs.default.utc(utcString).tz(this.timezone).toDate();
  }
  // ============================================
  // DATE CREATION
  // ============================================
  createDateAtTime(baseDate, timeString) {
    const totalMinutes = this.timeToMinutes(timeString);
    const hours = Math.floor(totalMinutes / 60);
    const minutes = totalMinutes % 60;
    return (0, import_dayjs.default)(baseDate).startOf("day").hour(hours).minute(minutes).toDate();
  }
  getISOWeekDay(date) {
    return (0, import_dayjs.default)(date).isoWeekday();
  }
};
__name(_DateService, "DateService");
var DateService = _DateService;

// src/core/BaseGroupingRenderer.ts
var _BaseGroupingRenderer = class _BaseGroupingRenderer {
  /**
   * Main render method - handles common logic
   */
  async render(context) {
    const allowedIds = context.filter[this.type] || [];
    if (allowedIds.length === 0)
      return;
    const entities = await this.getEntities(allowedIds);
    const dateCount = context.filter["date"]?.length || 1;
    const childIds = context.childType ? context.filter[context.childType] || [] : [];
    for (const entity of entities) {
      const entityChildIds = context.parentChildMap?.[entity.id] || [];
      const childCount = entityChildIds.filter((id) => childIds.includes(id)).length;
      const colspan = childCount * dateCount;
      const header = document.createElement(this.config.elementTag);
      header.dataset[this.config.idAttribute] = entity.id;
      header.style.setProperty(this.config.colspanVar, String(colspan));
      this.renderHeader(entity, header, context);
      context.headerContainer.appendChild(header);
    }
  }
  /**
   * Override this method for custom header rendering
   * Default: just sets textContent to display name
   */
  renderHeader(entity, header, _context) {
    header.textContent = this.getDisplayName(entity);
  }
  /**
   * Helper to render a single entity header.
   * Can be used by subclasses that override render() but want consistent header creation.
   */
  createHeader(entity, context) {
    const header = document.createElement(this.config.elementTag);
    header.dataset[this.config.idAttribute] = entity.id;
    this.renderHeader(entity, header, context);
    return header;
  }
};
__name(_BaseGroupingRenderer, "BaseGroupingRenderer");
var BaseGroupingRenderer = _BaseGroupingRenderer;

// src/features/resource/ResourceRenderer.ts
var _ResourceRenderer = class _ResourceRenderer extends BaseGroupingRenderer {
  constructor(resourceService) {
    super();
    this.resourceService = resourceService;
    this.type = "resource";
    this.config = {
      elementTag: "swp-resource-header",
      idAttribute: "resourceId",
      colspanVar: "--resource-cols"
    };
  }
  getEntities(ids) {
    return this.resourceService.getByIds(ids);
  }
  getDisplayName(entity) {
    return entity.displayName;
  }
  /**
   * Override render to handle:
   * 1. Special ordering when parentChildMap exists (resources grouped by parent)
   * 2. Different colspan calculation (just dateCount, not childCount * dateCount)
   */
  async render(context) {
    const resourceIds = context.filter["resource"] || [];
    const dateCount = context.filter["date"]?.length || 1;
    let orderedResourceIds;
    if (context.parentChildMap) {
      orderedResourceIds = [];
      for (const childIds of Object.values(context.parentChildMap)) {
        for (const childId of childIds) {
          if (resourceIds.includes(childId)) {
            orderedResourceIds.push(childId);
          }
        }
      }
    } else {
      orderedResourceIds = resourceIds;
    }
    const resources = await this.getEntities(orderedResourceIds);
    const resourceMap = new Map(resources.map((r) => [r.id, r]));
    for (const resourceId of orderedResourceIds) {
      const resource = resourceMap.get(resourceId);
      if (!resource)
        continue;
      const header = this.createHeader(resource, context);
      header.style.gridColumn = `span ${dateCount}`;
      context.headerContainer.appendChild(header);
    }
  }
};
__name(_ResourceRenderer, "ResourceRenderer");
var ResourceRenderer = _ResourceRenderer;

// src/features/team/TeamRenderer.ts
var _TeamRenderer = class _TeamRenderer extends BaseGroupingRenderer {
  constructor(teamService) {
    super();
    this.teamService = teamService;
    this.type = "team";
    this.config = {
      elementTag: "swp-team-header",
      idAttribute: "teamId",
      colspanVar: "--team-cols"
    };
  }
  getEntities(ids) {
    return this.teamService.getByIds(ids);
  }
  getDisplayName(entity) {
    return entity.name;
  }
};
__name(_TeamRenderer, "TeamRenderer");
var TeamRenderer = _TeamRenderer;

// src/features/department/DepartmentRenderer.ts
var _DepartmentRenderer = class _DepartmentRenderer extends BaseGroupingRenderer {
  constructor(departmentService) {
    super();
    this.departmentService = departmentService;
    this.type = "department";
    this.config = {
      elementTag: "swp-department-header",
      idAttribute: "departmentId",
      colspanVar: "--department-cols"
    };
  }
  getEntities(ids) {
    return this.departmentService.getByIds(ids);
  }
  getDisplayName(entity) {
    return entity.name;
  }
};
__name(_DepartmentRenderer, "DepartmentRenderer");
var DepartmentRenderer = _DepartmentRenderer;

// src/core/RenderBuilder.ts
function buildPipeline(renderers) {
  return {
    async run(context) {
      for (const renderer of renderers) {
        await renderer.render(context);
      }
    }
  };
}
__name(buildPipeline, "buildPipeline");

// src/core/FilterTemplate.ts
var _FilterTemplate = class _FilterTemplate {
  constructor(dateService, entityResolver) {
    this.dateService = dateService;
    this.entityResolver = entityResolver;
    this.fields = [];
  }
  /**
   * Tilføj felt til template
   * @param idProperty - Property-navn (bruges på både event og column.dataset)
   * @param derivedFrom - Hvis feltet udledes fra anden property (f.eks. date fra start)
   */
  addField(idProperty, derivedFrom) {
    this.fields.push({ idProperty, derivedFrom });
    return this;
  }
  /**
   * Parse dot-notation string into components
   * @example 'resource.teamId' → { entityType: 'resource', property: 'teamId', foreignKey: 'resourceId' }
   */
  parseDotNotation(idProperty) {
    if (!idProperty.includes("."))
      return null;
    const [entityType, property] = idProperty.split(".");
    return {
      entityType,
      property,
      foreignKey: entityType + "Id"
      // Convention: resource → resourceId
    };
  }
  /**
   * Get dataset key for column lookup
   * For dot-notation 'resource.teamId', we look for 'teamId' in dataset
   */
  getDatasetKey(idProperty) {
    const dotNotation = this.parseDotNotation(idProperty);
    if (dotNotation) {
      return dotNotation.property;
    }
    return idProperty;
  }
  /**
   * Byg nøgle fra kolonne
   * Læser værdier fra column.dataset[idProperty]
   * For dot-notation, uses the property part (resource.teamId → teamId)
   */
  buildKeyFromColumn(column) {
    return this.fields.map((f) => {
      const key = this.getDatasetKey(f.idProperty);
      return column.dataset[key] || "";
    }).join(":");
  }
  /**
   * Byg nøgle fra event
   * Læser værdier fra event[idProperty] eller udleder fra derivedFrom
   * For dot-notation, resolves via EntityResolver
   */
  buildKeyFromEvent(event) {
    const eventRecord = event;
    return this.fields.map((f) => {
      const dotNotation = this.parseDotNotation(f.idProperty);
      if (dotNotation) {
        return this.resolveDotNotation(eventRecord, dotNotation);
      }
      if (f.derivedFrom) {
        const sourceValue = eventRecord[f.derivedFrom];
        if (sourceValue instanceof Date) {
          return this.dateService.getDateKey(sourceValue);
        }
        return String(sourceValue || "");
      }
      return String(eventRecord[f.idProperty] || "");
    }).join(":");
  }
  /**
   * Resolve dot-notation reference via EntityResolver
   */
  resolveDotNotation(eventRecord, dotNotation) {
    if (!this.entityResolver) {
      console.warn(`FilterTemplate: EntityResolver required for dot-notation '${dotNotation.entityType}.${dotNotation.property}'`);
      return "";
    }
    const foreignId = eventRecord[dotNotation.foreignKey];
    if (!foreignId)
      return "";
    const entity = this.entityResolver.resolve(dotNotation.entityType, String(foreignId));
    if (!entity)
      return "";
    return String(entity[dotNotation.property] || "");
  }
  /**
   * Match event mod kolonne
   */
  matches(event, column) {
    return this.buildKeyFromEvent(event) === this.buildKeyFromColumn(column);
  }
};
__name(_FilterTemplate, "FilterTemplate");
var FilterTemplate = _FilterTemplate;

// src/core/CalendarOrchestrator.ts
var _CalendarOrchestrator = class _CalendarOrchestrator {
  constructor(allRenderers, eventRenderer, scheduleRenderer, headerDrawerRenderer, dateService, entityServices) {
    this.allRenderers = allRenderers;
    this.eventRenderer = eventRenderer;
    this.scheduleRenderer = scheduleRenderer;
    this.headerDrawerRenderer = headerDrawerRenderer;
    this.dateService = dateService;
    this.entityServices = entityServices;
  }
  async render(viewConfig, container2) {
    const headerContainer = container2.querySelector("swp-calendar-header");
    const columnContainer = container2.querySelector("swp-day-columns");
    if (!headerContainer || !columnContainer) {
      throw new Error("Missing swp-calendar-header or swp-day-columns");
    }
    const filter = {};
    for (const grouping of viewConfig.groupings) {
      filter[grouping.type] = grouping.values;
    }
    const filterTemplate = new FilterTemplate(this.dateService);
    for (const grouping of viewConfig.groupings) {
      if (grouping.idProperty) {
        filterTemplate.addField(grouping.idProperty, grouping.derivedFrom);
      }
    }
    const { parentChildMap, childType } = await this.resolveBelongsTo(viewConfig.groupings, filter);
    const context = { headerContainer, columnContainer, filter, groupings: viewConfig.groupings, parentChildMap, childType };
    headerContainer.innerHTML = "";
    columnContainer.innerHTML = "";
    const levels = viewConfig.groupings.map((g) => g.type).join(" ");
    headerContainer.dataset.levels = levels;
    const activeRenderers = this.selectRenderers(viewConfig);
    const pipeline = buildPipeline(activeRenderers);
    await pipeline.run(context);
    await this.scheduleRenderer.render(container2, filter);
    await this.eventRenderer.render(container2, filter, filterTemplate);
    await this.headerDrawerRenderer.render(container2, filter, filterTemplate);
  }
  selectRenderers(viewConfig) {
    const types = viewConfig.groupings.map((g) => g.type);
    return types.map((type) => this.allRenderers.find((r) => r.type === type)).filter((r) => r !== void 0);
  }
  /**
   * Resolve belongsTo relations to build parent-child map
   * e.g., belongsTo: 'team.resourceIds' → { team1: ['EMP001', 'EMP002'], team2: [...] }
   * Also returns the childType (the grouping type that has belongsTo)
   */
  async resolveBelongsTo(groupings, filter) {
    const childGrouping = groupings.find((g) => g.belongsTo);
    if (!childGrouping?.belongsTo)
      return {};
    const [entityType, property] = childGrouping.belongsTo.split(".");
    if (!entityType || !property)
      return {};
    const parentIds = filter[entityType] || [];
    if (parentIds.length === 0)
      return {};
    const service = this.entityServices.find((s) => s.entityType.toLowerCase() === entityType);
    if (!service)
      return {};
    const allEntities = await service.getAll();
    const entities = allEntities.filter((e) => parentIds.includes(e.id));
    const map = {};
    for (const entity of entities) {
      const entityRecord = entity;
      const children = entityRecord[property] || [];
      map[entityRecord.id] = children;
    }
    return { parentChildMap: map, childType: childGrouping.type };
  }
};
__name(_CalendarOrchestrator, "CalendarOrchestrator");
var CalendarOrchestrator = _CalendarOrchestrator;

// src/core/NavigationAnimator.ts
var _NavigationAnimator = class _NavigationAnimator {
  constructor(headerTrack, contentTrack, headerDrawer) {
    this.headerTrack = headerTrack;
    this.contentTrack = contentTrack;
    this.headerDrawer = headerDrawer;
  }
  async slide(direction, renderFn) {
    const out = direction === "left" ? "-100%" : "100%";
    const into = direction === "left" ? "100%" : "-100%";
    await this.animateOut(out);
    await renderFn();
    await this.animateIn(into);
  }
  async animateOut(translate) {
    const animations = [
      this.headerTrack.animate([{ transform: "translateX(0)" }, { transform: `translateX(${translate})` }], { duration: 200, easing: "ease-in" }).finished,
      this.contentTrack.animate([{ transform: "translateX(0)" }, { transform: `translateX(${translate})` }], { duration: 200, easing: "ease-in" }).finished
    ];
    if (this.headerDrawer) {
      animations.push(this.headerDrawer.animate([{ transform: "translateX(0)" }, { transform: `translateX(${translate})` }], { duration: 200, easing: "ease-in" }).finished);
    }
    await Promise.all(animations);
  }
  async animateIn(translate) {
    const animations = [
      this.headerTrack.animate([{ transform: `translateX(${translate})` }, { transform: "translateX(0)" }], { duration: 200, easing: "ease-out" }).finished,
      this.contentTrack.animate([{ transform: `translateX(${translate})` }, { transform: "translateX(0)" }], { duration: 200, easing: "ease-out" }).finished
    ];
    if (this.headerDrawer) {
      animations.push(this.headerDrawer.animate([{ transform: `translateX(${translate})` }, { transform: "translateX(0)" }], { duration: 200, easing: "ease-out" }).finished);
    }
    await Promise.all(animations);
  }
};
__name(_NavigationAnimator, "NavigationAnimator");
var NavigationAnimator = _NavigationAnimator;

// src/core/CalendarEvents.ts
var CalendarEvents = {
  // Command events (host → calendar)
  CMD_NAVIGATE_PREV: "calendar:cmd:navigate:prev",
  CMD_NAVIGATE_NEXT: "calendar:cmd:navigate:next",
  CMD_DRAWER_TOGGLE: "calendar:cmd:drawer:toggle",
  CMD_RENDER: "calendar:cmd:render",
  CMD_WORKWEEK_CHANGE: "calendar:cmd:workweek:change",
  CMD_VIEW_UPDATE: "calendar:cmd:view:update"
};

// src/core/CalendarApp.ts
var _CalendarApp = class _CalendarApp {
  constructor(orchestrator, timeAxisRenderer, dateService, scrollManager, headerDrawerManager, dragDropManager, edgeScrollManager, resizeManager, headerDrawerRenderer, eventPersistenceManager, settingsService, viewConfigService, eventBus) {
    this.orchestrator = orchestrator;
    this.timeAxisRenderer = timeAxisRenderer;
    this.dateService = dateService;
    this.scrollManager = scrollManager;
    this.headerDrawerManager = headerDrawerManager;
    this.dragDropManager = dragDropManager;
    this.edgeScrollManager = edgeScrollManager;
    this.resizeManager = resizeManager;
    this.headerDrawerRenderer = headerDrawerRenderer;
    this.eventPersistenceManager = eventPersistenceManager;
    this.settingsService = settingsService;
    this.viewConfigService = viewConfigService;
    this.eventBus = eventBus;
    this.dayOffset = 0;
    this.currentViewId = "simple";
    this.workweekPreset = null;
    this.groupingOverrides = /* @__PURE__ */ new Map();
  }
  async init(container2) {
    this.container = container2;
    const gridSettings = await this.settingsService.getGridSettings();
    if (!gridSettings) {
      throw new Error("GridSettings not found");
    }
    this.workweekPreset = await this.settingsService.getDefaultWorkweekPreset();
    this.animator = new NavigationAnimator(container2.querySelector("swp-header-track"), container2.querySelector("swp-content-track"), container2.querySelector("swp-header-drawer"));
    this.timeAxisRenderer.render(container2.querySelector("#time-axis"), gridSettings.dayStartHour, gridSettings.dayEndHour);
    this.scrollManager.init(container2);
    this.headerDrawerManager.init(container2);
    this.dragDropManager.init(container2);
    this.resizeManager.init(container2);
    const scrollableContent = container2.querySelector("swp-scrollable-content");
    this.edgeScrollManager.init(scrollableContent);
    this.setupEventListeners();
    this.emitStatus("ready");
  }
  setupEventListeners() {
    this.eventBus.on(CalendarEvents.CMD_NAVIGATE_PREV, () => {
      this.handleNavigatePrev();
    });
    this.eventBus.on(CalendarEvents.CMD_NAVIGATE_NEXT, () => {
      this.handleNavigateNext();
    });
    this.eventBus.on(CalendarEvents.CMD_DRAWER_TOGGLE, () => {
      this.headerDrawerManager.toggle();
    });
    this.eventBus.on(CalendarEvents.CMD_RENDER, (e) => {
      const { viewId } = e.detail;
      this.handleRenderCommand(viewId);
    });
    this.eventBus.on(CalendarEvents.CMD_WORKWEEK_CHANGE, (e) => {
      const { presetId } = e.detail;
      this.handleWorkweekChange(presetId);
    });
    this.eventBus.on(CalendarEvents.CMD_VIEW_UPDATE, (e) => {
      const { type, values } = e.detail;
      this.handleViewUpdate(type, values);
    });
  }
  async handleRenderCommand(viewId) {
    this.currentViewId = viewId;
    await this.render();
    this.emitStatus("rendered", { viewId });
  }
  async handleNavigatePrev() {
    const step = this.workweekPreset?.periodDays ?? 7;
    this.dayOffset -= step;
    await this.animator.slide("right", () => this.render());
    this.emitStatus("rendered", { viewId: this.currentViewId });
  }
  async handleNavigateNext() {
    const step = this.workweekPreset?.periodDays ?? 7;
    this.dayOffset += step;
    await this.animator.slide("left", () => this.render());
    this.emitStatus("rendered", { viewId: this.currentViewId });
  }
  async handleWorkweekChange(presetId) {
    const preset = await this.settingsService.getWorkweekPreset(presetId);
    if (preset) {
      this.workweekPreset = preset;
      await this.render();
      this.emitStatus("rendered", { viewId: this.currentViewId });
    }
  }
  async handleViewUpdate(type, values) {
    this.groupingOverrides.set(type, values);
    await this.render();
    this.emitStatus("rendered", { viewId: this.currentViewId });
  }
  async render() {
    const storedConfig = await this.viewConfigService.getById(this.currentViewId);
    if (!storedConfig) {
      this.emitStatus("error", { message: `ViewConfig not found: ${this.currentViewId}` });
      return;
    }
    const workDays = this.workweekPreset?.workDays || [1, 2, 3, 4, 5];
    const periodDays = this.workweekPreset?.periodDays ?? 7;
    const dates = periodDays === 1 ? this.dateService.getDatesFromOffset(this.dayOffset, workDays.length) : this.dateService.getWorkDaysFromOffset(this.dayOffset, workDays);
    const viewConfig = {
      ...storedConfig,
      groupings: storedConfig.groupings.map((g) => {
        if (g.type === "date") {
          return { ...g, values: dates };
        }
        const override = this.groupingOverrides.get(g.type);
        if (override) {
          return { ...g, values: override };
        }
        return g;
      })
    };
    await this.orchestrator.render(viewConfig, this.container);
  }
  emitStatus(status, detail) {
    this.container.dispatchEvent(new CustomEvent(`calendar:status:${status}`, {
      detail,
      bubbles: true
    }));
  }
};
__name(_CalendarApp, "CalendarApp");
var CalendarApp = _CalendarApp;

// src/features/timeaxis/TimeAxisRenderer.ts
var _TimeAxisRenderer = class _TimeAxisRenderer {
  render(container2, startHour = 6, endHour = 20) {
    container2.innerHTML = "";
    for (let hour = startHour; hour <= endHour; hour++) {
      const marker = document.createElement("swp-hour-marker");
      marker.textContent = `${hour.toString().padStart(2, "0")}:00`;
      container2.appendChild(marker);
    }
  }
};
__name(_TimeAxisRenderer, "TimeAxisRenderer");
var TimeAxisRenderer = _TimeAxisRenderer;

// src/core/ScrollManager.ts
var _ScrollManager = class _ScrollManager {
  init(container2) {
    this.scrollableContent = container2.querySelector("swp-scrollable-content");
    this.timeAxisContent = container2.querySelector("swp-time-axis-content");
    this.calendarHeader = container2.querySelector("swp-calendar-header");
    this.headerDrawer = container2.querySelector("swp-header-drawer");
    this.headerViewport = container2.querySelector("swp-header-viewport");
    this.headerSpacer = container2.querySelector("swp-header-spacer");
    this.scrollableContent.addEventListener("scroll", () => this.onScroll());
    this.resizeObserver = new ResizeObserver(() => this.syncHeaderSpacerHeight());
    this.resizeObserver.observe(this.headerViewport);
    this.syncHeaderSpacerHeight();
  }
  syncHeaderSpacerHeight() {
    const computedHeight = getComputedStyle(this.headerViewport).height;
    this.headerSpacer.style.height = computedHeight;
  }
  onScroll() {
    const { scrollTop, scrollLeft } = this.scrollableContent;
    this.timeAxisContent.style.transform = `translateY(-${scrollTop}px)`;
    this.calendarHeader.style.transform = `translateX(-${scrollLeft}px)`;
    this.headerDrawer.style.transform = `translateX(-${scrollLeft}px)`;
  }
};
__name(_ScrollManager, "ScrollManager");
var ScrollManager = _ScrollManager;

// src/core/HeaderDrawerManager.ts
var _HeaderDrawerManager = class _HeaderDrawerManager {
  constructor() {
    this.expanded = false;
    this.currentRows = 0;
    this.rowHeight = 25;
    this.duration = 200;
  }
  init(container2) {
    this.drawer = container2.querySelector("swp-header-drawer");
    if (!this.drawer)
      console.error("HeaderDrawerManager: swp-header-drawer not found");
  }
  toggle() {
    this.expanded ? this.collapse() : this.expand();
  }
  /**
   * Expand drawer to single row (legacy support)
   */
  expand() {
    this.expandToRows(1);
  }
  /**
   * Expand drawer to fit specified number of rows
   */
  expandToRows(rowCount) {
    const targetHeight = rowCount * this.rowHeight;
    const currentHeight = this.expanded ? this.currentRows * this.rowHeight : 0;
    if (this.expanded && this.currentRows === rowCount)
      return;
    this.currentRows = rowCount;
    this.expanded = true;
    this.animate(currentHeight, targetHeight);
  }
  collapse() {
    if (!this.expanded)
      return;
    const currentHeight = this.currentRows * this.rowHeight;
    this.expanded = false;
    this.currentRows = 0;
    this.animate(currentHeight, 0);
  }
  animate(from, to) {
    const keyframes = [
      { height: `${from}px` },
      { height: `${to}px` }
    ];
    const options = {
      duration: this.duration,
      easing: "ease",
      fill: "forwards"
    };
    this.drawer.animate(keyframes, options);
  }
  isExpanded() {
    return this.expanded;
  }
  getRowCount() {
    return this.currentRows;
  }
};
__name(_HeaderDrawerManager, "HeaderDrawerManager");
var HeaderDrawerManager = _HeaderDrawerManager;

// src/demo/MockStores.ts
var _MockTeamStore = class _MockTeamStore {
  constructor() {
    this.type = "team";
    this.teams = [
      { id: "alpha", name: "Team Alpha" },
      { id: "beta", name: "Team Beta" }
    ];
  }
  getByIds(ids) {
    return this.teams.filter((t) => ids.includes(t.id));
  }
};
__name(_MockTeamStore, "MockTeamStore");
var MockTeamStore = _MockTeamStore;
var _MockResourceStore = class _MockResourceStore {
  constructor() {
    this.type = "resource";
    this.resources = [
      { id: "alice", name: "Alice", teamId: "alpha" },
      { id: "bob", name: "Bob", teamId: "alpha" },
      { id: "carol", name: "Carol", teamId: "beta" },
      { id: "dave", name: "Dave", teamId: "beta" }
    ];
  }
  getByIds(ids) {
    return this.resources.filter((r) => ids.includes(r.id));
  }
};
__name(_MockResourceStore, "MockResourceStore");
var MockResourceStore = _MockResourceStore;

// src/demo/DemoApp.ts
var _DemoApp = class _DemoApp {
  constructor(indexedDBContext, dataSeeder, auditService, calendarApp, dateService, resourceService, eventBus) {
    this.indexedDBContext = indexedDBContext;
    this.dataSeeder = dataSeeder;
    this.auditService = auditService;
    this.calendarApp = calendarApp;
    this.dateService = dateService;
    this.resourceService = resourceService;
    this.eventBus = eventBus;
    this.currentView = "simple";
  }
  async init() {
    this.dateService.setBaseDate(/* @__PURE__ */ new Date("2025-12-08"));
    await this.indexedDBContext.initialize();
    console.log("[DemoApp] IndexedDB initialized");
    await this.dataSeeder.seedIfEmpty();
    console.log("[DemoApp] Data seeding complete");
    this.container = document.querySelector("swp-calendar-container");
    await this.calendarApp.init(this.container);
    console.log("[DemoApp] CalendarApp initialized");
    this.setupNavigation();
    this.setupDrawerToggle();
    this.setupViewSwitching();
    this.setupWorkweekSelector();
    await this.setupResourceSelector();
    this.setupStatusListeners();
    this.eventBus.emit(CalendarEvents.CMD_RENDER, { viewId: this.currentView });
  }
  setupNavigation() {
    document.getElementById("btn-prev").onclick = () => {
      this.eventBus.emit(CalendarEvents.CMD_NAVIGATE_PREV);
    };
    document.getElementById("btn-next").onclick = () => {
      this.eventBus.emit(CalendarEvents.CMD_NAVIGATE_NEXT);
    };
  }
  setupViewSwitching() {
    const chips = document.querySelectorAll(".view-chip");
    chips.forEach((chip) => {
      chip.addEventListener("click", () => {
        chips.forEach((c) => c.classList.remove("active"));
        chip.classList.add("active");
        const view = chip.dataset.view;
        if (view) {
          this.currentView = view;
          this.updateSelectorVisibility();
          this.eventBus.emit(CalendarEvents.CMD_RENDER, { viewId: view });
        }
      });
    });
  }
  updateSelectorVisibility() {
    const selector = document.querySelector("swp-resource-selector");
    const showSelector = this.currentView === "picker" || this.currentView === "day";
    selector?.classList.toggle("hidden", !showSelector);
  }
  setupDrawerToggle() {
    document.getElementById("btn-drawer").onclick = () => {
      this.eventBus.emit(CalendarEvents.CMD_DRAWER_TOGGLE);
    };
  }
  setupWorkweekSelector() {
    const workweekSelect = document.getElementById("workweek-select");
    workweekSelect?.addEventListener("change", () => {
      const presetId = workweekSelect.value;
      this.eventBus.emit(CalendarEvents.CMD_WORKWEEK_CHANGE, { presetId });
    });
  }
  async setupResourceSelector() {
    const resources = await this.resourceService.getAll();
    const container2 = document.querySelector(".resource-checkboxes");
    if (!container2)
      return;
    container2.innerHTML = "";
    resources.forEach((r) => {
      const label = document.createElement("label");
      label.innerHTML = `
        <input type="checkbox" value="${r.id}" checked>
        ${r.displayName}
      `;
      container2.appendChild(label);
    });
    container2.addEventListener("change", () => {
      const checked = container2.querySelectorAll("input:checked");
      const values = Array.from(checked).map((cb) => cb.value);
      this.eventBus.emit(CalendarEvents.CMD_VIEW_UPDATE, { type: "resource", values });
    });
  }
  setupStatusListeners() {
    this.container.addEventListener("calendar:status:ready", () => {
      console.log("[DemoApp] Calendar ready");
    });
    this.container.addEventListener("calendar:status:rendered", (e) => {
      console.log("[DemoApp] Calendar rendered:", e.detail.viewId);
    });
    this.container.addEventListener("calendar:status:error", (e) => {
      console.error("[DemoApp] Calendar error:", e.detail.message);
    });
  }
};
__name(_DemoApp, "DemoApp");
var DemoApp = _DemoApp;

// src/core/EventBus.ts
var _EventBus = class _EventBus {
  constructor() {
    this.eventLog = [];
    this.debug = false;
    this.listeners = /* @__PURE__ */ new Set();
    this.logConfig = {
      calendar: true,
      grid: true,
      event: true,
      scroll: true,
      navigation: true,
      view: true,
      default: true
    };
  }
  /**
   * Subscribe to an event via DOM addEventListener
   */
  on(eventType, handler, options) {
    document.addEventListener(eventType, handler, options);
    this.listeners.add({ eventType, handler, options });
    return () => this.off(eventType, handler);
  }
  /**
   * Subscribe to an event once
   */
  once(eventType, handler) {
    return this.on(eventType, handler, { once: true });
  }
  /**
   * Unsubscribe from an event
   */
  off(eventType, handler) {
    document.removeEventListener(eventType, handler);
    for (const listener of this.listeners) {
      if (listener.eventType === eventType && listener.handler === handler) {
        this.listeners.delete(listener);
        break;
      }
    }
  }
  /**
   * Emit an event via DOM CustomEvent
   */
  emit(eventType, detail = {}) {
    if (!eventType) {
      return false;
    }
    const event = new CustomEvent(eventType, {
      detail: detail ?? {},
      bubbles: true,
      cancelable: true
    });
    if (this.debug) {
      this.logEventWithGrouping(eventType, detail);
    }
    this.eventLog.push({
      type: eventType,
      detail: detail ?? {},
      timestamp: Date.now()
    });
    return !document.dispatchEvent(event);
  }
  /**
   * Log event with console grouping
   */
  logEventWithGrouping(eventType, _detail) {
    const category = this.extractCategory(eventType);
    if (!this.logConfig[category]) {
      return;
    }
    this.getCategoryStyle(category);
  }
  /**
   * Extract category from event type
   */
  extractCategory(eventType) {
    if (!eventType) {
      return "unknown";
    }
    if (eventType.includes(":")) {
      return eventType.split(":")[0];
    }
    const lowerType = eventType.toLowerCase();
    if (lowerType.includes("grid") || lowerType.includes("rendered"))
      return "grid";
    if (lowerType.includes("event") || lowerType.includes("sync"))
      return "event";
    if (lowerType.includes("scroll"))
      return "scroll";
    if (lowerType.includes("nav") || lowerType.includes("date"))
      return "navigation";
    if (lowerType.includes("view"))
      return "view";
    return "default";
  }
  /**
   * Get styling for different categories
   */
  getCategoryStyle(category) {
    const styles = {
      calendar: { emoji: "\u{1F4C5}", color: "#2196F3" },
      grid: { emoji: "\u{1F4CA}", color: "#4CAF50" },
      event: { emoji: "\u{1F4CC}", color: "#FF9800" },
      scroll: { emoji: "\u{1F4DC}", color: "#9C27B0" },
      navigation: { emoji: "\u{1F9ED}", color: "#F44336" },
      view: { emoji: "\u{1F441}", color: "#00BCD4" },
      default: { emoji: "\u{1F4E2}", color: "#607D8B" }
    };
    return styles[category] || styles.default;
  }
  /**
   * Configure logging for specific categories
   */
  setLogConfig(config) {
    this.logConfig = { ...this.logConfig, ...config };
  }
  /**
   * Get current log configuration
   */
  getLogConfig() {
    return { ...this.logConfig };
  }
  /**
   * Get event history
   */
  getEventLog(eventType) {
    if (eventType) {
      return this.eventLog.filter((e) => e.type === eventType);
    }
    return this.eventLog;
  }
  /**
   * Enable/disable debug mode
   */
  setDebug(enabled) {
    this.debug = enabled;
  }
};
__name(_EventBus, "EventBus");
var EventBus = _EventBus;

// src/storage/IndexedDBContext.ts
var _IndexedDBContext = class _IndexedDBContext {
  constructor(stores) {
    this.db = null;
    this.initialized = false;
    this.stores = stores;
  }
  /**
   * Initialize and open the database
   */
  async initialize() {
    return new Promise((resolve, reject) => {
      const request = indexedDB.open(_IndexedDBContext.DB_NAME, _IndexedDBContext.DB_VERSION);
      request.onerror = () => {
        reject(new Error(`Failed to open IndexedDB: ${request.error}`));
      };
      request.onsuccess = () => {
        this.db = request.result;
        this.initialized = true;
        resolve();
      };
      request.onupgradeneeded = (event) => {
        const db = event.target.result;
        this.stores.forEach((store) => {
          if (!db.objectStoreNames.contains(store.storeName)) {
            store.create(db);
          }
        });
      };
    });
  }
  /**
   * Check if database is initialized
   */
  isInitialized() {
    return this.initialized;
  }
  /**
   * Get IDBDatabase instance
   */
  getDatabase() {
    if (!this.db) {
      throw new Error("IndexedDB not initialized. Call initialize() first.");
    }
    return this.db;
  }
  /**
   * Close database connection
   */
  close() {
    if (this.db) {
      this.db.close();
      this.db = null;
      this.initialized = false;
    }
  }
  /**
   * Delete entire database (for testing/reset)
   */
  static async deleteDatabase() {
    return new Promise((resolve, reject) => {
      const request = indexedDB.deleteDatabase(_IndexedDBContext.DB_NAME);
      request.onsuccess = () => resolve();
      request.onerror = () => reject(new Error(`Failed to delete database: ${request.error}`));
    });
  }
};
__name(_IndexedDBContext, "IndexedDBContext");
var IndexedDBContext = _IndexedDBContext;
IndexedDBContext.DB_NAME = "CalendarDB";
IndexedDBContext.DB_VERSION = 4;

// src/storage/events/EventStore.ts
var _EventStore = class _EventStore {
  constructor() {
    this.storeName = _EventStore.STORE_NAME;
  }
  /**
   * Create the events ObjectStore with indexes
   */
  create(db) {
    const store = db.createObjectStore(_EventStore.STORE_NAME, { keyPath: "id" });
    store.createIndex("start", "start", { unique: false });
    store.createIndex("end", "end", { unique: false });
    store.createIndex("syncStatus", "syncStatus", { unique: false });
    store.createIndex("resourceId", "resourceId", { unique: false });
    store.createIndex("customerId", "customerId", { unique: false });
    store.createIndex("bookingId", "bookingId", { unique: false });
    store.createIndex("startEnd", ["start", "end"], { unique: false });
  }
};
__name(_EventStore, "EventStore");
var EventStore = _EventStore;
EventStore.STORE_NAME = "events";

// src/storage/events/EventSerialization.ts
var _EventSerialization = class _EventSerialization {
  /**
   * Serialize event for IndexedDB storage
   */
  static serialize(event) {
    return {
      ...event,
      start: event.start instanceof Date ? event.start.toISOString() : event.start,
      end: event.end instanceof Date ? event.end.toISOString() : event.end
    };
  }
  /**
   * Deserialize event from IndexedDB storage
   */
  static deserialize(data) {
    return {
      ...data,
      start: typeof data.start === "string" ? new Date(data.start) : data.start,
      end: typeof data.end === "string" ? new Date(data.end) : data.end
    };
  }
};
__name(_EventSerialization, "EventSerialization");
var EventSerialization = _EventSerialization;

// src/storage/SyncPlugin.ts
var _SyncPlugin = class _SyncPlugin {
  constructor(service) {
    this.service = service;
  }
  /**
   * Mark entity as successfully synced
   */
  async markAsSynced(id) {
    const entity = await this.service.get(id);
    if (entity) {
      entity.syncStatus = "synced";
      await this.service.save(entity);
    }
  }
  /**
   * Mark entity as sync error
   */
  async markAsError(id) {
    const entity = await this.service.get(id);
    if (entity) {
      entity.syncStatus = "error";
      await this.service.save(entity);
    }
  }
  /**
   * Get current sync status for an entity
   */
  async getSyncStatus(id) {
    const entity = await this.service.get(id);
    return entity ? entity.syncStatus : null;
  }
  /**
   * Get entities by sync status using IndexedDB index
   */
  async getBySyncStatus(syncStatus) {
    return new Promise((resolve, reject) => {
      const transaction = this.service.db.transaction([this.service.storeName], "readonly");
      const store = transaction.objectStore(this.service.storeName);
      const index = store.index("syncStatus");
      const request = index.getAll(syncStatus);
      request.onsuccess = () => {
        const data = request.result;
        const entities = data.map((item) => this.service.deserialize(item));
        resolve(entities);
      };
      request.onerror = () => {
        reject(new Error(`Failed to get by sync status ${syncStatus}: ${request.error}`));
      };
    });
  }
};
__name(_SyncPlugin, "SyncPlugin");
var SyncPlugin = _SyncPlugin;

// src/constants/CoreEvents.ts
var CoreEvents = {
  // Lifecycle events
  INITIALIZED: "core:initialized",
  READY: "core:ready",
  DESTROYED: "core:destroyed",
  // View events
  VIEW_CHANGED: "view:changed",
  VIEW_RENDERED: "view:rendered",
  // Navigation events
  DATE_CHANGED: "nav:date-changed",
  NAVIGATION_COMPLETED: "nav:navigation-completed",
  // Data events
  DATA_LOADING: "data:loading",
  DATA_LOADED: "data:loaded",
  DATA_ERROR: "data:error",
  // Grid events
  GRID_RENDERED: "grid:rendered",
  GRID_CLICKED: "grid:clicked",
  // Event management
  EVENT_CREATED: "event:created",
  EVENT_UPDATED: "event:updated",
  EVENT_DELETED: "event:deleted",
  EVENT_SELECTED: "event:selected",
  // Event drag-drop
  EVENT_DRAG_START: "event:drag-start",
  EVENT_DRAG_MOVE: "event:drag-move",
  EVENT_DRAG_END: "event:drag-end",
  EVENT_DRAG_CANCEL: "event:drag-cancel",
  EVENT_DRAG_COLUMN_CHANGE: "event:drag-column-change",
  // Header drag (timed → header conversion)
  EVENT_DRAG_ENTER_HEADER: "event:drag-enter-header",
  EVENT_DRAG_MOVE_HEADER: "event:drag-move-header",
  EVENT_DRAG_LEAVE_HEADER: "event:drag-leave-header",
  // Event resize
  EVENT_RESIZE_START: "event:resize-start",
  EVENT_RESIZE_END: "event:resize-end",
  // Edge scroll
  EDGE_SCROLL_TICK: "edge-scroll:tick",
  EDGE_SCROLL_STARTED: "edge-scroll:started",
  EDGE_SCROLL_STOPPED: "edge-scroll:stopped",
  // System events
  ERROR: "system:error",
  // Sync events
  SYNC_STARTED: "sync:started",
  SYNC_COMPLETED: "sync:completed",
  SYNC_FAILED: "sync:failed",
  // Entity events - for audit and sync
  ENTITY_SAVED: "entity:saved",
  ENTITY_DELETED: "entity:deleted",
  // Audit events
  AUDIT_LOGGED: "audit:logged",
  // Rendering events
  EVENTS_RENDERED: "events:rendered"
};

// node_modules/json-diff-ts/dist/index.js
function arrayDifference(first, second) {
  const secondSet = new Set(second);
  return first.filter((item) => !secondSet.has(item));
}
__name(arrayDifference, "arrayDifference");
function arrayIntersection(first, second) {
  const secondSet = new Set(second);
  return first.filter((item) => secondSet.has(item));
}
__name(arrayIntersection, "arrayIntersection");
function keyBy(arr, getKey2) {
  const result = {};
  for (const item of arr) {
    result[String(getKey2(item))] = item;
  }
  return result;
}
__name(keyBy, "keyBy");
function diff(oldObj, newObj, options = {}) {
  let { embeddedObjKeys } = options;
  const { keysToSkip, treatTypeChangeAsReplace } = options;
  if (embeddedObjKeys instanceof Map) {
    embeddedObjKeys = new Map(
      Array.from(embeddedObjKeys.entries()).map(([key, value]) => [
        key instanceof RegExp ? key : key.replace(/^\./, ""),
        value
      ])
    );
  } else if (embeddedObjKeys) {
    embeddedObjKeys = Object.fromEntries(
      Object.entries(embeddedObjKeys).map(([key, value]) => [key.replace(/^\./, ""), value])
    );
  }
  return compare(oldObj, newObj, [], [], {
    embeddedObjKeys,
    keysToSkip: keysToSkip ?? [],
    treatTypeChangeAsReplace: treatTypeChangeAsReplace ?? true
  });
}
__name(diff, "diff");
var getTypeOfObj = /* @__PURE__ */ __name((obj) => {
  if (typeof obj === "undefined") {
    return "undefined";
  }
  if (obj === null) {
    return null;
  }
  return Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1];
}, "getTypeOfObj");
var getKey = /* @__PURE__ */ __name((path) => {
  const left = path[path.length - 1];
  return left != null ? left : "$root";
}, "getKey");
var compare = /* @__PURE__ */ __name((oldObj, newObj, path, keyPath, options) => {
  let changes = [];
  const currentPath = keyPath.join(".");
  if (options.keysToSkip?.some((skipPath) => {
    if (currentPath === skipPath) {
      return true;
    }
    if (skipPath.includes(".") && skipPath.startsWith(currentPath + ".")) {
      return false;
    }
    if (skipPath.includes(".")) {
      const skipParts = skipPath.split(".");
      const currentParts = currentPath.split(".");
      if (currentParts.length >= skipParts.length) {
        for (let i = 0; i < skipParts.length; i++) {
          if (skipParts[i] !== currentParts[i]) {
            return false;
          }
        }
        return true;
      }
    }
    return false;
  })) {
    return changes;
  }
  const typeOfOldObj = getTypeOfObj(oldObj);
  const typeOfNewObj = getTypeOfObj(newObj);
  if (options.treatTypeChangeAsReplace && typeOfOldObj !== typeOfNewObj) {
    if (typeOfOldObj !== "undefined") {
      changes.push({ type: "REMOVE", key: getKey(path), value: oldObj });
    }
    if (typeOfNewObj !== "undefined") {
      changes.push({ type: "ADD", key: getKey(path), value: newObj });
    }
    return changes;
  }
  if (typeOfNewObj === "undefined" && typeOfOldObj !== "undefined") {
    changes.push({ type: "REMOVE", key: getKey(path), value: oldObj });
    return changes;
  }
  if (typeOfNewObj === "Object" && typeOfOldObj === "Array") {
    changes.push({ type: "UPDATE", key: getKey(path), value: newObj, oldValue: oldObj });
    return changes;
  }
  if (typeOfNewObj === null) {
    if (typeOfOldObj !== null) {
      changes.push({ type: "UPDATE", key: getKey(path), value: newObj, oldValue: oldObj });
    }
    return changes;
  }
  switch (typeOfOldObj) {
    case "Date":
      if (typeOfNewObj === "Date") {
        changes = changes.concat(
          comparePrimitives(oldObj.getTime(), newObj.getTime(), path).map((x) => ({
            ...x,
            value: new Date(x.value),
            oldValue: new Date(x.oldValue)
          }))
        );
      } else {
        changes = changes.concat(comparePrimitives(oldObj, newObj, path));
      }
      break;
    case "Object": {
      const diffs = compareObject(oldObj, newObj, path, keyPath, false, options);
      if (diffs.length) {
        if (path.length) {
          changes.push({
            type: "UPDATE",
            key: getKey(path),
            changes: diffs
          });
        } else {
          changes = changes.concat(diffs);
        }
      }
      break;
    }
    case "Array":
      changes = changes.concat(compareArray(oldObj, newObj, path, keyPath, options));
      break;
    case "Function":
      break;
    default:
      changes = changes.concat(comparePrimitives(oldObj, newObj, path));
  }
  return changes;
}, "compare");
var compareObject = /* @__PURE__ */ __name((oldObj, newObj, path, keyPath, skipPath = false, options = {}) => {
  let k;
  let newKeyPath;
  let newPath;
  if (skipPath == null) {
    skipPath = false;
  }
  let changes = [];
  const oldObjKeys = Object.keys(oldObj);
  const newObjKeys = Object.keys(newObj);
  const intersectionKeys = arrayIntersection(oldObjKeys, newObjKeys);
  for (k of intersectionKeys) {
    newPath = path.concat([k]);
    newKeyPath = skipPath ? keyPath : keyPath.concat([k]);
    const diffs = compare(oldObj[k], newObj[k], newPath, newKeyPath, options);
    if (diffs.length) {
      changes = changes.concat(diffs);
    }
  }
  const addedKeys = arrayDifference(newObjKeys, oldObjKeys);
  for (k of addedKeys) {
    newPath = path.concat([k]);
    newKeyPath = skipPath ? keyPath : keyPath.concat([k]);
    const currentPath = newKeyPath.join(".");
    if (options.keysToSkip?.some((skipPath2) => currentPath === skipPath2 || currentPath.startsWith(skipPath2 + "."))) {
      continue;
    }
    changes.push({
      type: "ADD",
      key: getKey(newPath),
      value: newObj[k]
    });
  }
  const deletedKeys = arrayDifference(oldObjKeys, newObjKeys);
  for (k of deletedKeys) {
    newPath = path.concat([k]);
    newKeyPath = skipPath ? keyPath : keyPath.concat([k]);
    const currentPath = newKeyPath.join(".");
    if (options.keysToSkip?.some((skipPath2) => currentPath === skipPath2 || currentPath.startsWith(skipPath2 + "."))) {
      continue;
    }
    changes.push({
      type: "REMOVE",
      key: getKey(newPath),
      value: oldObj[k]
    });
  }
  return changes;
}, "compareObject");
var compareArray = /* @__PURE__ */ __name((oldObj, newObj, path, keyPath, options) => {
  if (getTypeOfObj(newObj) !== "Array") {
    return [{ type: "UPDATE", key: getKey(path), value: newObj, oldValue: oldObj }];
  }
  const left = getObjectKey(options.embeddedObjKeys, keyPath);
  const uniqKey = left != null ? left : "$index";
  const indexedOldObj = convertArrayToObj(oldObj, uniqKey);
  const indexedNewObj = convertArrayToObj(newObj, uniqKey);
  const diffs = compareObject(indexedOldObj, indexedNewObj, path, keyPath, true, options);
  if (diffs.length) {
    return [
      {
        type: "UPDATE",
        key: getKey(path),
        embeddedKey: typeof uniqKey === "function" && uniqKey.length === 2 ? uniqKey(newObj[0], true) : uniqKey,
        changes: diffs
      }
    ];
  } else {
    return [];
  }
}, "compareArray");
var getObjectKey = /* @__PURE__ */ __name((embeddedObjKeys, keyPath) => {
  if (embeddedObjKeys != null) {
    const path = keyPath.join(".");
    if (embeddedObjKeys instanceof Map) {
      for (const [key2, value] of embeddedObjKeys.entries()) {
        if (key2 instanceof RegExp) {
          if (path.match(key2)) {
            return value;
          }
        } else if (path === key2) {
          return value;
        }
      }
    }
    const key = embeddedObjKeys[path];
    if (key != null) {
      return key;
    }
  }
  return void 0;
}, "getObjectKey");
var convertArrayToObj = /* @__PURE__ */ __name((arr, uniqKey) => {
  let obj = {};
  if (uniqKey === "$value") {
    arr.forEach((value) => {
      obj[value] = value;
    });
  } else if (uniqKey !== "$index") {
    const keyFunction = typeof uniqKey === "string" ? (item) => item[uniqKey] : uniqKey;
    obj = keyBy(arr, keyFunction);
  } else {
    for (let i = 0; i < arr.length; i++) {
      const value = arr[i];
      obj[i] = value;
    }
  }
  return obj;
}, "convertArrayToObj");
var comparePrimitives = /* @__PURE__ */ __name((oldObj, newObj, path) => {
  const changes = [];
  if (oldObj !== newObj) {
    changes.push({
      type: "UPDATE",
      key: getKey(path),
      value: newObj,
      oldValue: oldObj
    });
  }
  return changes;
}, "comparePrimitives");

// src/storage/BaseEntityService.ts
var _BaseEntityService = class _BaseEntityService {
  constructor(context, eventBus) {
    this.context = context;
    this.eventBus = eventBus;
    this.syncPlugin = new SyncPlugin(this);
  }
  get db() {
    return this.context.getDatabase();
  }
  /**
   * Serialize entity before storing in IndexedDB
   */
  serialize(entity) {
    return entity;
  }
  /**
   * Deserialize data from IndexedDB back to entity
   */
  deserialize(data) {
    return data;
  }
  /**
   * Get a single entity by ID
   */
  async get(id) {
    return new Promise((resolve, reject) => {
      const transaction = this.db.transaction([this.storeName], "readonly");
      const store = transaction.objectStore(this.storeName);
      const request = store.get(id);
      request.onsuccess = () => {
        const data = request.result;
        resolve(data ? this.deserialize(data) : null);
      };
      request.onerror = () => {
        reject(new Error(`Failed to get ${this.entityType} ${id}: ${request.error}`));
      };
    });
  }
  /**
   * Get all entities
   */
  async getAll() {
    return new Promise((resolve, reject) => {
      const transaction = this.db.transaction([this.storeName], "readonly");
      const store = transaction.objectStore(this.storeName);
      const request = store.getAll();
      request.onsuccess = () => {
        const data = request.result;
        const entities = data.map((item) => this.deserialize(item));
        resolve(entities);
      };
      request.onerror = () => {
        reject(new Error(`Failed to get all ${this.entityType}s: ${request.error}`));
      };
    });
  }
  /**
   * Save an entity (create or update)
   * Emits ENTITY_SAVED event with operation type and changes (diff for updates)
   * @param entity - Entity to save
   * @param silent - If true, skip event emission (used for seeding)
   */
  async save(entity, silent = false) {
    const entityId = entity.id;
    const existingEntity = await this.get(entityId);
    const isCreate = existingEntity === null;
    let changes;
    if (isCreate) {
      changes = entity;
    } else {
      const existingSerialized = this.serialize(existingEntity);
      const newSerialized = this.serialize(entity);
      changes = diff(existingSerialized, newSerialized);
    }
    const serialized = this.serialize(entity);
    return new Promise((resolve, reject) => {
      const transaction = this.db.transaction([this.storeName], "readwrite");
      const store = transaction.objectStore(this.storeName);
      const request = store.put(serialized);
      request.onsuccess = () => {
        if (!silent) {
          const payload = {
            entityType: this.entityType,
            entityId,
            operation: isCreate ? "create" : "update",
            changes,
            timestamp: Date.now()
          };
          this.eventBus.emit(CoreEvents.ENTITY_SAVED, payload);
        }
        resolve();
      };
      request.onerror = () => {
        reject(new Error(`Failed to save ${this.entityType} ${entityId}: ${request.error}`));
      };
    });
  }
  /**
   * Delete an entity
   * Emits ENTITY_DELETED event
   */
  async delete(id) {
    return new Promise((resolve, reject) => {
      const transaction = this.db.transaction([this.storeName], "readwrite");
      const store = transaction.objectStore(this.storeName);
      const request = store.delete(id);
      request.onsuccess = () => {
        const payload = {
          entityType: this.entityType,
          entityId: id,
          operation: "delete",
          timestamp: Date.now()
        };
        this.eventBus.emit(CoreEvents.ENTITY_DELETED, payload);
        resolve();
      };
      request.onerror = () => {
        reject(new Error(`Failed to delete ${this.entityType} ${id}: ${request.error}`));
      };
    });
  }
  // Sync methods - delegate to SyncPlugin
  async markAsSynced(id) {
    return this.syncPlugin.markAsSynced(id);
  }
  async markAsError(id) {
    return this.syncPlugin.markAsError(id);
  }
  async getSyncStatus(id) {
    return this.syncPlugin.getSyncStatus(id);
  }
  async getBySyncStatus(syncStatus) {
    return this.syncPlugin.getBySyncStatus(syncStatus);
  }
};
__name(_BaseEntityService, "BaseEntityService");
var BaseEntityService = _BaseEntityService;

// src/storage/events/EventService.ts
var _EventService = class _EventService extends BaseEntityService {
  constructor(context, eventBus) {
    super(context, eventBus);
    this.storeName = EventStore.STORE_NAME;
    this.entityType = "Event";
  }
  serialize(event) {
    return EventSerialization.serialize(event);
  }
  deserialize(data) {
    return EventSerialization.deserialize(data);
  }
  /**
   * Get events within a date range
   */
  async getByDateRange(start, end) {
    return new Promise((resolve, reject) => {
      const transaction = this.db.transaction([this.storeName], "readonly");
      const store = transaction.objectStore(this.storeName);
      const index = store.index("start");
      const range = IDBKeyRange.lowerBound(start.toISOString());
      const request = index.getAll(range);
      request.onsuccess = () => {
        const data = request.result;
        const events = data.map((item) => this.deserialize(item)).filter((event) => event.start <= end);
        resolve(events);
      };
      request.onerror = () => {
        reject(new Error(`Failed to get events by date range: ${request.error}`));
      };
    });
  }
  /**
   * Get events for a specific resource
   */
  async getByResource(resourceId) {
    return new Promise((resolve, reject) => {
      const transaction = this.db.transaction([this.storeName], "readonly");
      const store = transaction.objectStore(this.storeName);
      const index = store.index("resourceId");
      const request = index.getAll(resourceId);
      request.onsuccess = () => {
        const data = request.result;
        const events = data.map((item) => this.deserialize(item));
        resolve(events);
      };
      request.onerror = () => {
        reject(new Error(`Failed to get events for resource ${resourceId}: ${request.error}`));
      };
    });
  }
  /**
   * Get events for a resource within a date range
   */
  async getByResourceAndDateRange(resourceId, start, end) {
    const resourceEvents = await this.getByResource(resourceId);
    return resourceEvents.filter((event) => event.start >= start && event.start <= end);
  }
};
__name(_EventService, "EventService");
var EventService = _EventService;

// src/storage/resources/ResourceStore.ts
var _ResourceStore = class _ResourceStore {
  constructor() {
    this.storeName = _ResourceStore.STORE_NAME;
  }
  create(db) {
    const store = db.createObjectStore(_ResourceStore.STORE_NAME, { keyPath: "id" });
    store.createIndex("type", "type", { unique: false });
    store.createIndex("syncStatus", "syncStatus", { unique: false });
    store.createIndex("isActive", "isActive", { unique: false });
  }
};
__name(_ResourceStore, "ResourceStore");
var ResourceStore = _ResourceStore;
ResourceStore.STORE_NAME = "resources";

// src/storage/resources/ResourceService.ts
var _ResourceService = class _ResourceService extends BaseEntityService {
  constructor(context, eventBus) {
    super(context, eventBus);
    this.storeName = ResourceStore.STORE_NAME;
    this.entityType = "Resource";
  }
  /**
   * Get all active resources
   */
  async getActive() {
    const all = await this.getAll();
    return all.filter((r) => r.isActive !== false);
  }
  /**
   * Get resources by IDs
   */
  async getByIds(ids) {
    if (ids.length === 0)
      return [];
    const results = await Promise.all(ids.map((id) => this.get(id)));
    return results.filter((r) => r !== null);
  }
  /**
   * Get resources by type
   */
  async getByType(type) {
    return new Promise((resolve, reject) => {
      const transaction = this.db.transaction([this.storeName], "readonly");
      const store = transaction.objectStore(this.storeName);
      const index = store.index("type");
      const request = index.getAll(type);
      request.onsuccess = () => {
        const data = request.result;
        resolve(data);
      };
      request.onerror = () => {
        reject(new Error(`Failed to get resources by type ${type}: ${request.error}`));
      };
    });
  }
};
__name(_ResourceService, "ResourceService");
var ResourceService = _ResourceService;

// src/storage/bookings/BookingStore.ts
var _BookingStore = class _BookingStore {
  constructor() {
    this.storeName = _BookingStore.STORE_NAME;
  }
  create(db) {
    const store = db.createObjectStore(_BookingStore.STORE_NAME, { keyPath: "id" });
    store.createIndex("customerId", "customerId", { unique: false });
    store.createIndex("status", "status", { unique: false });
    store.createIndex("syncStatus", "syncStatus", { unique: false });
    store.createIndex("createdAt", "createdAt", { unique: false });
  }
};
__name(_BookingStore, "BookingStore");
var BookingStore = _BookingStore;
BookingStore.STORE_NAME = "bookings";

// src/storage/bookings/BookingService.ts
var _BookingService = class _BookingService extends BaseEntityService {
  constructor(context, eventBus) {
    super(context, eventBus);
    this.storeName = BookingStore.STORE_NAME;
    this.entityType = "Booking";
  }
  serialize(booking) {
    return {
      ...booking,
      createdAt: booking.createdAt.toISOString()
    };
  }
  deserialize(data) {
    const raw = data;
    return {
      ...raw,
      createdAt: new Date(raw.createdAt)
    };
  }
  /**
   * Get bookings for a customer
   */
  async getByCustomer(customerId) {
    return new Promise((resolve, reject) => {
      const transaction = this.db.transaction([this.storeName], "readonly");
      const store = transaction.objectStore(this.storeName);
      const index = store.index("customerId");
      const request = index.getAll(customerId);
      request.onsuccess = () => {
        const data = request.result;
        const bookings = data.map((item) => this.deserialize(item));
        resolve(bookings);
      };
      request.onerror = () => {
        reject(new Error(`Failed to get bookings for customer ${customerId}: ${request.error}`));
      };
    });
  }
  /**
   * Get bookings by status
   */
  async getByStatus(status) {
    return new Promise((resolve, reject) => {
      const transaction = this.db.transaction([this.storeName], "readonly");
      const store = transaction.objectStore(this.storeName);
      const index = store.index("status");
      const request = index.getAll(status);
      request.onsuccess = () => {
        const data = request.result;
        const bookings = data.map((item) => this.deserialize(item));
        resolve(bookings);
      };
      request.onerror = () => {
        reject(new Error(`Failed to get bookings with status ${status}: ${request.error}`));
      };
    });
  }
};
__name(_BookingService, "BookingService");
var BookingService = _BookingService;

// src/storage/customers/CustomerStore.ts
var _CustomerStore = class _CustomerStore {
  constructor() {
    this.storeName = _CustomerStore.STORE_NAME;
  }
  create(db) {
    const store = db.createObjectStore(_CustomerStore.STORE_NAME, { keyPath: "id" });
    store.createIndex("name", "name", { unique: false });
    store.createIndex("phone", "phone", { unique: false });
    store.createIndex("syncStatus", "syncStatus", { unique: false });
  }
};
__name(_CustomerStore, "CustomerStore");
var CustomerStore = _CustomerStore;
CustomerStore.STORE_NAME = "customers";

// src/storage/customers/CustomerService.ts
var _CustomerService = class _CustomerService extends BaseEntityService {
  constructor(context, eventBus) {
    super(context, eventBus);
    this.storeName = CustomerStore.STORE_NAME;
    this.entityType = "Customer";
  }
  /**
   * Search customers by name (case-insensitive contains)
   */
  async searchByName(query) {
    const all = await this.getAll();
    const lowerQuery = query.toLowerCase();
    return all.filter((c) => c.name.toLowerCase().includes(lowerQuery));
  }
  /**
   * Find customer by phone
   */
  async getByPhone(phone) {
    return new Promise((resolve, reject) => {
      const transaction = this.db.transaction([this.storeName], "readonly");
      const store = transaction.objectStore(this.storeName);
      const index = store.index("phone");
      const request = index.get(phone);
      request.onsuccess = () => {
        const data = request.result;
        resolve(data ? data : null);
      };
      request.onerror = () => {
        reject(new Error(`Failed to find customer by phone ${phone}: ${request.error}`));
      };
    });
  }
};
__name(_CustomerService, "CustomerService");
var CustomerService = _CustomerService;

// src/storage/teams/TeamStore.ts
var _TeamStore = class _TeamStore {
  constructor() {
    this.storeName = _TeamStore.STORE_NAME;
  }
  create(db) {
    db.createObjectStore(_TeamStore.STORE_NAME, { keyPath: "id" });
  }
};
__name(_TeamStore, "TeamStore");
var TeamStore = _TeamStore;
TeamStore.STORE_NAME = "teams";

// src/storage/teams/TeamService.ts
var _TeamService = class _TeamService extends BaseEntityService {
  constructor(context, eventBus) {
    super(context, eventBus);
    this.storeName = TeamStore.STORE_NAME;
    this.entityType = "Team";
  }
  /**
   * Get teams by IDs
   */
  async getByIds(ids) {
    if (ids.length === 0)
      return [];
    const results = await Promise.all(ids.map((id) => this.get(id)));
    return results.filter((t) => t !== null);
  }
  /**
   * Build reverse lookup: resourceId → teamId
   */
  async buildResourceToTeamMap() {
    const teams = await this.getAll();
    const map = {};
    for (const team of teams) {
      for (const resourceId of team.resourceIds) {
        map[resourceId] = team.id;
      }
    }
    return map;
  }
};
__name(_TeamService, "TeamService");
var TeamService = _TeamService;

// src/storage/departments/DepartmentStore.ts
var _DepartmentStore = class _DepartmentStore {
  constructor() {
    this.storeName = _DepartmentStore.STORE_NAME;
  }
  create(db) {
    db.createObjectStore(_DepartmentStore.STORE_NAME, { keyPath: "id" });
  }
};
__name(_DepartmentStore, "DepartmentStore");
var DepartmentStore = _DepartmentStore;
DepartmentStore.STORE_NAME = "departments";

// src/storage/departments/DepartmentService.ts
var _DepartmentService = class _DepartmentService extends BaseEntityService {
  constructor(context, eventBus) {
    super(context, eventBus);
    this.storeName = DepartmentStore.STORE_NAME;
    this.entityType = "Department";
  }
  /**
   * Get departments by IDs
   */
  async getByIds(ids) {
    if (ids.length === 0)
      return [];
    const results = await Promise.all(ids.map((id) => this.get(id)));
    return results.filter((d) => d !== null);
  }
};
__name(_DepartmentService, "DepartmentService");
var DepartmentService = _DepartmentService;

// src/storage/settings/SettingsStore.ts
var _SettingsStore = class _SettingsStore {
  constructor() {
    this.storeName = _SettingsStore.STORE_NAME;
  }
  create(db) {
    db.createObjectStore(_SettingsStore.STORE_NAME, { keyPath: "id" });
  }
};
__name(_SettingsStore, "SettingsStore");
var SettingsStore = _SettingsStore;
SettingsStore.STORE_NAME = "settings";

// src/types/SettingsTypes.ts
var SettingsIds = {
  WORKWEEK: "workweek",
  GRID: "grid",
  TIME_FORMAT: "timeFormat",
  VIEWS: "views"
};

// src/storage/settings/SettingsService.ts
var _SettingsService = class _SettingsService extends BaseEntityService {
  constructor(context, eventBus) {
    super(context, eventBus);
    this.storeName = SettingsStore.STORE_NAME;
    this.entityType = "Settings";
  }
  /**
   * Get workweek settings
   */
  async getWorkweekSettings() {
    return this.get(SettingsIds.WORKWEEK);
  }
  /**
   * Get grid settings
   */
  async getGridSettings() {
    return this.get(SettingsIds.GRID);
  }
  /**
   * Get time format settings
   */
  async getTimeFormatSettings() {
    return this.get(SettingsIds.TIME_FORMAT);
  }
  /**
   * Get view settings
   */
  async getViewSettings() {
    return this.get(SettingsIds.VIEWS);
  }
  /**
   * Get workweek preset by ID
   */
  async getWorkweekPreset(presetId) {
    const settings = await this.getWorkweekSettings();
    if (!settings)
      return null;
    return settings.presets[presetId] || null;
  }
  /**
   * Get the default workweek preset
   */
  async getDefaultWorkweekPreset() {
    const settings = await this.getWorkweekSettings();
    if (!settings)
      return null;
    return settings.presets[settings.defaultPreset] || null;
  }
  /**
   * Get all available workweek presets
   */
  async getWorkweekPresets() {
    const settings = await this.getWorkweekSettings();
    if (!settings)
      return [];
    return Object.values(settings.presets);
  }
};
__name(_SettingsService, "SettingsService");
var SettingsService = _SettingsService;

// src/storage/viewconfigs/ViewConfigStore.ts
var _ViewConfigStore = class _ViewConfigStore {
  constructor() {
    this.storeName = _ViewConfigStore.STORE_NAME;
  }
  create(db) {
    db.createObjectStore(_ViewConfigStore.STORE_NAME, { keyPath: "id" });
  }
};
__name(_ViewConfigStore, "ViewConfigStore");
var ViewConfigStore = _ViewConfigStore;
ViewConfigStore.STORE_NAME = "viewconfigs";

// src/storage/viewconfigs/ViewConfigService.ts
var _ViewConfigService = class _ViewConfigService extends BaseEntityService {
  constructor(context, eventBus) {
    super(context, eventBus);
    this.storeName = ViewConfigStore.STORE_NAME;
    this.entityType = "ViewConfig";
  }
  async getById(id) {
    return this.get(id);
  }
};
__name(_ViewConfigService, "ViewConfigService");
var ViewConfigService = _ViewConfigService;

// src/storage/audit/AuditStore.ts
var _AuditStore = class _AuditStore {
  constructor() {
    this.storeName = "audit";
  }
  create(db) {
    const store = db.createObjectStore(this.storeName, { keyPath: "id" });
    store.createIndex("syncStatus", "syncStatus", { unique: false });
    store.createIndex("synced", "synced", { unique: false });
    store.createIndex("entityId", "entityId", { unique: false });
    store.createIndex("timestamp", "timestamp", { unique: false });
  }
};
__name(_AuditStore, "AuditStore");
var AuditStore = _AuditStore;

// src/storage/audit/AuditService.ts
var _AuditService = class _AuditService extends BaseEntityService {
  constructor(context, eventBus) {
    super(context, eventBus);
    this.storeName = "audit";
    this.entityType = "Audit";
    this.setupEventListeners();
  }
  /**
   * Setup listeners for ENTITY_SAVED and ENTITY_DELETED events
   */
  setupEventListeners() {
    this.eventBus.on(CoreEvents.ENTITY_SAVED, (event) => {
      const detail = event.detail;
      this.handleEntitySaved(detail);
    });
    this.eventBus.on(CoreEvents.ENTITY_DELETED, (event) => {
      const detail = event.detail;
      this.handleEntityDeleted(detail);
    });
  }
  /**
   * Handle ENTITY_SAVED event - create audit entry
   */
  async handleEntitySaved(payload) {
    if (payload.entityType === "Audit")
      return;
    const auditEntry = {
      id: crypto.randomUUID(),
      entityType: payload.entityType,
      entityId: payload.entityId,
      operation: payload.operation,
      userId: _AuditService.DEFAULT_USER_ID,
      timestamp: payload.timestamp,
      changes: payload.changes,
      synced: false,
      syncStatus: "pending"
    };
    await this.save(auditEntry);
  }
  /**
   * Handle ENTITY_DELETED event - create audit entry
   */
  async handleEntityDeleted(payload) {
    if (payload.entityType === "Audit")
      return;
    const auditEntry = {
      id: crypto.randomUUID(),
      entityType: payload.entityType,
      entityId: payload.entityId,
      operation: "delete",
      userId: _AuditService.DEFAULT_USER_ID,
      timestamp: payload.timestamp,
      changes: { id: payload.entityId },
      // For delete, just store the ID
      synced: false,
      syncStatus: "pending"
    };
    await this.save(auditEntry);
  }
  /**
   * Override save to NOT trigger ENTITY_SAVED event
   * Instead, emits AUDIT_LOGGED for SyncManager to listen
   *
   * This prevents infinite loops:
   * - BaseEntityService.save() emits ENTITY_SAVED
   * - AuditService listens to ENTITY_SAVED and creates audit
   * - If AuditService.save() also emitted ENTITY_SAVED, it would loop
   */
  async save(entity) {
    const serialized = this.serialize(entity);
    return new Promise((resolve, reject) => {
      const transaction = this.db.transaction([this.storeName], "readwrite");
      const store = transaction.objectStore(this.storeName);
      const request = store.put(serialized);
      request.onsuccess = () => {
        const payload = {
          auditId: entity.id,
          entityType: entity.entityType,
          entityId: entity.entityId,
          operation: entity.operation,
          timestamp: entity.timestamp
        };
        this.eventBus.emit(CoreEvents.AUDIT_LOGGED, payload);
        resolve();
      };
      request.onerror = () => {
        reject(new Error(`Failed to save audit entry ${entity.id}: ${request.error}`));
      };
    });
  }
  /**
   * Override delete to NOT trigger ENTITY_DELETED event
   * Audit entries should never be deleted (compliance requirement)
   */
  async delete(_id) {
    throw new Error("Audit entries cannot be deleted (compliance requirement)");
  }
  /**
   * Get pending audit entries (for sync)
   */
  async getPendingAudits() {
    return this.getBySyncStatus("pending");
  }
  /**
   * Get audit entries for a specific entity
   */
  async getByEntityId(entityId) {
    return new Promise((resolve, reject) => {
      const transaction = this.db.transaction([this.storeName], "readonly");
      const store = transaction.objectStore(this.storeName);
      const index = store.index("entityId");
      const request = index.getAll(entityId);
      request.onsuccess = () => {
        const entries = request.result;
        resolve(entries);
      };
      request.onerror = () => {
        reject(new Error(`Failed to get audit entries for entity ${entityId}: ${request.error}`));
      };
    });
  }
};
__name(_AuditService, "AuditService");
var AuditService = _AuditService;
AuditService.DEFAULT_USER_ID = "00000000-0000-0000-0000-000000000001";

// src/repositories/MockEventRepository.ts
var _MockEventRepository = class _MockEventRepository {
  constructor() {
    this.entityType = "Event";
    this.dataUrl = "data/mock-events.json";
  }
  /**
   * Fetch all events from mock JSON file
   */
  async fetchAll() {
    try {
      const response = await fetch(this.dataUrl);
      if (!response.ok) {
        throw new Error(`Failed to load mock events: ${response.status} ${response.statusText}`);
      }
      const rawData = await response.json();
      return this.processCalendarData(rawData);
    } catch (error) {
      console.error("Failed to load event data:", error);
      throw error;
    }
  }
  async sendCreate(_event) {
    throw new Error("MockEventRepository does not support sendCreate. Mock data is read-only.");
  }
  async sendUpdate(_id, _updates) {
    throw new Error("MockEventRepository does not support sendUpdate. Mock data is read-only.");
  }
  async sendDelete(_id) {
    throw new Error("MockEventRepository does not support sendDelete. Mock data is read-only.");
  }
  processCalendarData(data) {
    return data.map((event) => {
      if (event.type === "customer") {
        if (!event.bookingId)
          console.warn(`Customer event ${event.id} missing bookingId`);
        if (!event.resourceId)
          console.warn(`Customer event ${event.id} missing resourceId`);
        if (!event.customerId)
          console.warn(`Customer event ${event.id} missing customerId`);
      }
      return {
        id: event.id,
        title: event.title,
        description: event.description,
        start: new Date(event.start),
        end: new Date(event.end),
        type: event.type,
        allDay: event.allDay || false,
        bookingId: event.bookingId,
        resourceId: event.resourceId,
        customerId: event.customerId,
        recurringId: event.recurringId,
        metadata: event.metadata,
        syncStatus: "synced"
      };
    });
  }
};
__name(_MockEventRepository, "MockEventRepository");
var MockEventRepository = _MockEventRepository;

// src/repositories/MockResourceRepository.ts
var _MockResourceRepository = class _MockResourceRepository {
  constructor() {
    this.entityType = "Resource";
    this.dataUrl = "data/mock-resources.json";
  }
  async fetchAll() {
    try {
      const response = await fetch(this.dataUrl);
      if (!response.ok) {
        throw new Error(`Failed to load mock resources: ${response.status} ${response.statusText}`);
      }
      const rawData = await response.json();
      return this.processResourceData(rawData);
    } catch (error) {
      console.error("Failed to load resource data:", error);
      throw error;
    }
  }
  async sendCreate(_resource) {
    throw new Error("MockResourceRepository does not support sendCreate. Mock data is read-only.");
  }
  async sendUpdate(_id, _updates) {
    throw new Error("MockResourceRepository does not support sendUpdate. Mock data is read-only.");
  }
  async sendDelete(_id) {
    throw new Error("MockResourceRepository does not support sendDelete. Mock data is read-only.");
  }
  processResourceData(data) {
    return data.map((resource) => ({
      id: resource.id,
      name: resource.name,
      displayName: resource.displayName,
      type: resource.type,
      avatarUrl: resource.avatarUrl,
      color: resource.color,
      isActive: resource.isActive,
      defaultSchedule: resource.defaultSchedule,
      metadata: resource.metadata,
      syncStatus: "synced"
    }));
  }
};
__name(_MockResourceRepository, "MockResourceRepository");
var MockResourceRepository = _MockResourceRepository;

// src/repositories/MockBookingRepository.ts
var _MockBookingRepository = class _MockBookingRepository {
  constructor() {
    this.entityType = "Booking";
    this.dataUrl = "data/mock-bookings.json";
  }
  async fetchAll() {
    try {
      const response = await fetch(this.dataUrl);
      if (!response.ok) {
        throw new Error(`Failed to load mock bookings: ${response.status} ${response.statusText}`);
      }
      const rawData = await response.json();
      return this.processBookingData(rawData);
    } catch (error) {
      console.error("Failed to load booking data:", error);
      throw error;
    }
  }
  async sendCreate(_booking) {
    throw new Error("MockBookingRepository does not support sendCreate. Mock data is read-only.");
  }
  async sendUpdate(_id, _updates) {
    throw new Error("MockBookingRepository does not support sendUpdate. Mock data is read-only.");
  }
  async sendDelete(_id) {
    throw new Error("MockBookingRepository does not support sendDelete. Mock data is read-only.");
  }
  processBookingData(data) {
    return data.map((booking) => ({
      id: booking.id,
      customerId: booking.customerId,
      status: booking.status,
      createdAt: new Date(booking.createdAt),
      services: booking.services,
      totalPrice: booking.totalPrice,
      tags: booking.tags,
      notes: booking.notes,
      syncStatus: "synced"
    }));
  }
};
__name(_MockBookingRepository, "MockBookingRepository");
var MockBookingRepository = _MockBookingRepository;

// src/repositories/MockCustomerRepository.ts
var _MockCustomerRepository = class _MockCustomerRepository {
  constructor() {
    this.entityType = "Customer";
    this.dataUrl = "data/mock-customers.json";
  }
  async fetchAll() {
    try {
      const response = await fetch(this.dataUrl);
      if (!response.ok) {
        throw new Error(`Failed to load mock customers: ${response.status} ${response.statusText}`);
      }
      const rawData = await response.json();
      return this.processCustomerData(rawData);
    } catch (error) {
      console.error("Failed to load customer data:", error);
      throw error;
    }
  }
  async sendCreate(_customer) {
    throw new Error("MockCustomerRepository does not support sendCreate. Mock data is read-only.");
  }
  async sendUpdate(_id, _updates) {
    throw new Error("MockCustomerRepository does not support sendUpdate. Mock data is read-only.");
  }
  async sendDelete(_id) {
    throw new Error("MockCustomerRepository does not support sendDelete. Mock data is read-only.");
  }
  processCustomerData(data) {
    return data.map((customer) => ({
      id: customer.id,
      name: customer.name,
      phone: customer.phone,
      email: customer.email,
      metadata: customer.metadata,
      syncStatus: "synced"
    }));
  }
};
__name(_MockCustomerRepository, "MockCustomerRepository");
var MockCustomerRepository = _MockCustomerRepository;

// src/repositories/MockAuditRepository.ts
var _MockAuditRepository = class _MockAuditRepository {
  constructor() {
    this.entityType = "Audit";
  }
  async sendCreate(entity) {
    await new Promise((resolve) => setTimeout(resolve, 100));
    console.log("MockAuditRepository: Audit entry synced to backend:", {
      id: entity.id,
      entityType: entity.entityType,
      entityId: entity.entityId,
      operation: entity.operation,
      timestamp: new Date(entity.timestamp).toISOString()
    });
    return entity;
  }
  async sendUpdate(_id, _entity) {
    throw new Error("Audit entries cannot be updated");
  }
  async sendDelete(_id) {
    throw new Error("Audit entries cannot be deleted");
  }
  async fetchAll() {
    return [];
  }
  async fetchById(_id) {
    return null;
  }
};
__name(_MockAuditRepository, "MockAuditRepository");
var MockAuditRepository = _MockAuditRepository;

// src/repositories/MockTeamRepository.ts
var _MockTeamRepository = class _MockTeamRepository {
  constructor() {
    this.entityType = "Team";
    this.dataUrl = "data/mock-teams.json";
  }
  async fetchAll() {
    try {
      const response = await fetch(this.dataUrl);
      if (!response.ok) {
        throw new Error(`Failed to load mock teams: ${response.status} ${response.statusText}`);
      }
      const rawData = await response.json();
      return this.processTeamData(rawData);
    } catch (error) {
      console.error("Failed to load team data:", error);
      throw error;
    }
  }
  async sendCreate(_team) {
    throw new Error("MockTeamRepository does not support sendCreate. Mock data is read-only.");
  }
  async sendUpdate(_id, _updates) {
    throw new Error("MockTeamRepository does not support sendUpdate. Mock data is read-only.");
  }
  async sendDelete(_id) {
    throw new Error("MockTeamRepository does not support sendDelete. Mock data is read-only.");
  }
  processTeamData(data) {
    return data.map((team) => ({
      id: team.id,
      name: team.name,
      resourceIds: team.resourceIds,
      syncStatus: "synced"
    }));
  }
};
__name(_MockTeamRepository, "MockTeamRepository");
var MockTeamRepository = _MockTeamRepository;

// src/repositories/MockDepartmentRepository.ts
var _MockDepartmentRepository = class _MockDepartmentRepository {
  constructor() {
    this.entityType = "Department";
    this.dataUrl = "data/mock-departments.json";
  }
  async fetchAll() {
    try {
      const response = await fetch(this.dataUrl);
      if (!response.ok) {
        throw new Error(`Failed to load mock departments: ${response.status} ${response.statusText}`);
      }
      const rawData = await response.json();
      return this.processDepartmentData(rawData);
    } catch (error) {
      console.error("Failed to load department data:", error);
      throw error;
    }
  }
  async sendCreate(_department) {
    throw new Error("MockDepartmentRepository does not support sendCreate. Mock data is read-only.");
  }
  async sendUpdate(_id, _updates) {
    throw new Error("MockDepartmentRepository does not support sendUpdate. Mock data is read-only.");
  }
  async sendDelete(_id) {
    throw new Error("MockDepartmentRepository does not support sendDelete. Mock data is read-only.");
  }
  processDepartmentData(data) {
    return data.map((dept) => ({
      id: dept.id,
      name: dept.name,
      resourceIds: dept.resourceIds,
      syncStatus: "synced"
    }));
  }
};
__name(_MockDepartmentRepository, "MockDepartmentRepository");
var MockDepartmentRepository = _MockDepartmentRepository;

// src/repositories/MockSettingsRepository.ts
var _MockSettingsRepository = class _MockSettingsRepository {
  constructor() {
    this.entityType = "Settings";
    this.dataUrl = "data/tenant-settings.json";
  }
  async fetchAll() {
    try {
      const response = await fetch(this.dataUrl);
      if (!response.ok) {
        throw new Error(`Failed to load tenant settings: ${response.status} ${response.statusText}`);
      }
      const settings = await response.json();
      return settings.map((s) => ({
        ...s,
        syncStatus: s.syncStatus || "synced"
      }));
    } catch (error) {
      console.error("Failed to load tenant settings:", error);
      throw error;
    }
  }
  async sendCreate(_settings) {
    throw new Error("MockSettingsRepository does not support sendCreate. Mock data is read-only.");
  }
  async sendUpdate(_id, _updates) {
    throw new Error("MockSettingsRepository does not support sendUpdate. Mock data is read-only.");
  }
  async sendDelete(_id) {
    throw new Error("MockSettingsRepository does not support sendDelete. Mock data is read-only.");
  }
};
__name(_MockSettingsRepository, "MockSettingsRepository");
var MockSettingsRepository = _MockSettingsRepository;

// src/repositories/MockViewConfigRepository.ts
var _MockViewConfigRepository = class _MockViewConfigRepository {
  constructor() {
    this.entityType = "ViewConfig";
    this.dataUrl = "data/viewconfigs.json";
  }
  async fetchAll() {
    try {
      const response = await fetch(this.dataUrl);
      if (!response.ok) {
        throw new Error(`Failed to load viewconfigs: ${response.status} ${response.statusText}`);
      }
      const rawData = await response.json();
      const configs = rawData.map((config) => ({
        ...config,
        syncStatus: config.syncStatus || "synced"
      }));
      return configs;
    } catch (error) {
      console.error("Failed to load viewconfigs:", error);
      throw error;
    }
  }
  async sendCreate(_config) {
    throw new Error("MockViewConfigRepository does not support sendCreate. Mock data is read-only.");
  }
  async sendUpdate(_id, _updates) {
    throw new Error("MockViewConfigRepository does not support sendUpdate. Mock data is read-only.");
  }
  async sendDelete(_id) {
    throw new Error("MockViewConfigRepository does not support sendDelete. Mock data is read-only.");
  }
};
__name(_MockViewConfigRepository, "MockViewConfigRepository");
var MockViewConfigRepository = _MockViewConfigRepository;

// src/workers/DataSeeder.ts
var _DataSeeder = class _DataSeeder {
  constructor(services, repositories) {
    this.services = services;
    this.repositories = repositories;
  }
  /**
   * Seed all entity stores if they are empty
   */
  async seedIfEmpty() {
    console.log("[DataSeeder] Checking if database needs seeding...");
    try {
      for (const service of this.services) {
        const repository = this.repositories.find((repo) => repo.entityType === service.entityType);
        if (!repository) {
          console.warn(`[DataSeeder] No repository found for entity type: ${service.entityType}, skipping`);
          continue;
        }
        await this.seedEntity(service.entityType, service, repository);
      }
      console.log("[DataSeeder] Seeding complete");
    } catch (error) {
      console.error("[DataSeeder] Seeding failed:", error);
      throw error;
    }
  }
  async seedEntity(entityType, service, repository) {
    const existing = await service.getAll();
    if (existing.length > 0) {
      console.log(`[DataSeeder] ${entityType} store already has ${existing.length} items, skipping seed`);
      return;
    }
    console.log(`[DataSeeder] ${entityType} store is empty, fetching from repository...`);
    const data = await repository.fetchAll();
    console.log(`[DataSeeder] Fetched ${data.length} ${entityType} items, saving to IndexedDB...`);
    for (const entity of data) {
      await service.save(entity, true);
    }
    console.log(`[DataSeeder] ${entityType} seeding complete (${data.length} items saved)`);
  }
};
__name(_DataSeeder, "DataSeeder");
var DataSeeder = _DataSeeder;

// src/utils/PositionUtils.ts
function calculateEventPosition(start, end, config) {
  const startMinutes = start.getHours() * 60 + start.getMinutes();
  const endMinutes = end.getHours() * 60 + end.getMinutes();
  const dayStartMinutes = config.dayStartHour * 60;
  const minuteHeight = config.hourHeight / 60;
  const top = (startMinutes - dayStartMinutes) * minuteHeight;
  const height = (endMinutes - startMinutes) * minuteHeight;
  return { top, height };
}
__name(calculateEventPosition, "calculateEventPosition");
function minutesToPixels(minutes, config) {
  return minutes / 60 * config.hourHeight;
}
__name(minutesToPixels, "minutesToPixels");
function pixelsToMinutes(pixels, config) {
  return pixels / config.hourHeight * 60;
}
__name(pixelsToMinutes, "pixelsToMinutes");
function snapToGrid(pixels, config) {
  const snapPixels = minutesToPixels(config.snapInterval, config);
  return Math.round(pixels / snapPixels) * snapPixels;
}
__name(snapToGrid, "snapToGrid");

// src/features/event/EventLayoutEngine.ts
function eventsOverlap(a, b) {
  return a.start < b.end && a.end > b.start;
}
__name(eventsOverlap, "eventsOverlap");
function eventsWithinThreshold(a, b, thresholdMinutes) {
  const thresholdMs = thresholdMinutes * 60 * 1e3;
  const startToStartDiff = Math.abs(a.start.getTime() - b.start.getTime());
  if (startToStartDiff <= thresholdMs)
    return true;
  const bStartsBeforeAEnds = a.end.getTime() - b.start.getTime();
  if (bStartsBeforeAEnds > 0 && bStartsBeforeAEnds <= thresholdMs)
    return true;
  const aStartsBeforeBEnds = b.end.getTime() - a.start.getTime();
  if (aStartsBeforeBEnds > 0 && aStartsBeforeBEnds <= thresholdMs)
    return true;
  return false;
}
__name(eventsWithinThreshold, "eventsWithinThreshold");
function findOverlapGroups(events) {
  if (events.length === 0)
    return [];
  const sorted = [...events].sort((a, b) => a.start.getTime() - b.start.getTime());
  const used = /* @__PURE__ */ new Set();
  const groups = [];
  for (const event of sorted) {
    if (used.has(event.id))
      continue;
    const group = [event];
    used.add(event.id);
    let expanded = true;
    while (expanded) {
      expanded = false;
      for (const candidate of sorted) {
        if (used.has(candidate.id))
          continue;
        const connects = group.some((member) => eventsOverlap(member, candidate));
        if (connects) {
          group.push(candidate);
          used.add(candidate.id);
          expanded = true;
        }
      }
    }
    groups.push(group);
  }
  return groups;
}
__name(findOverlapGroups, "findOverlapGroups");
function findGridCandidates(events, thresholdMinutes) {
  if (events.length === 0)
    return [];
  const sorted = [...events].sort((a, b) => a.start.getTime() - b.start.getTime());
  const used = /* @__PURE__ */ new Set();
  const groups = [];
  for (const event of sorted) {
    if (used.has(event.id))
      continue;
    const group = [event];
    used.add(event.id);
    let expanded = true;
    while (expanded) {
      expanded = false;
      for (const candidate of sorted) {
        if (used.has(candidate.id))
          continue;
        const connects = group.some((member) => eventsWithinThreshold(member, candidate, thresholdMinutes));
        if (connects) {
          group.push(candidate);
          used.add(candidate.id);
          expanded = true;
        }
      }
    }
    groups.push(group);
  }
  return groups;
}
__name(findGridCandidates, "findGridCandidates");
function calculateStackLevels(events) {
  const levels = /* @__PURE__ */ new Map();
  const sorted = [...events].sort((a, b) => a.start.getTime() - b.start.getTime());
  for (const event of sorted) {
    let maxOverlappingLevel = -1;
    for (const [id, level] of levels) {
      const other = events.find((e) => e.id === id);
      if (other && eventsOverlap(event, other)) {
        maxOverlappingLevel = Math.max(maxOverlappingLevel, level);
      }
    }
    levels.set(event.id, maxOverlappingLevel + 1);
  }
  return levels;
}
__name(calculateStackLevels, "calculateStackLevels");
function allocateColumns(events) {
  const sorted = [...events].sort((a, b) => a.start.getTime() - b.start.getTime());
  const columns = [];
  for (const event of sorted) {
    let placed = false;
    for (const column of columns) {
      const canFit = !column.some((e) => eventsOverlap(event, e));
      if (canFit) {
        column.push(event);
        placed = true;
        break;
      }
    }
    if (!placed) {
      columns.push([event]);
    }
  }
  return columns;
}
__name(allocateColumns, "allocateColumns");
function calculateColumnLayout(events, config) {
  const thresholdMinutes = config.gridStartThresholdMinutes ?? 10;
  const result = {
    grids: [],
    stacked: []
  };
  if (events.length === 0)
    return result;
  const overlapGroups = findOverlapGroups(events);
  for (const overlapGroup of overlapGroups) {
    if (overlapGroup.length === 1) {
      result.stacked.push({
        event: overlapGroup[0],
        stackLevel: 0
      });
      continue;
    }
    const gridSubgroups = findGridCandidates(overlapGroup, thresholdMinutes);
    const largestGridCandidate = gridSubgroups.reduce((max, g) => g.length > max.length ? g : max, gridSubgroups[0]);
    if (largestGridCandidate.length === overlapGroup.length) {
      const columns = allocateColumns(overlapGroup);
      const earliest = overlapGroup.reduce((min, e) => e.start < min.start ? e : min, overlapGroup[0]);
      const position = calculateEventPosition(earliest.start, earliest.end, config);
      result.grids.push({
        events: overlapGroup,
        columns,
        stackLevel: 0,
        position: { top: position.top }
      });
    } else {
      const levels = calculateStackLevels(overlapGroup);
      for (const event of overlapGroup) {
        result.stacked.push({
          event,
          stackLevel: levels.get(event.id) ?? 0
        });
      }
    }
  }
  return result;
}
__name(calculateColumnLayout, "calculateColumnLayout");

// src/features/event/EventRenderer.ts
var _EventRenderer = class _EventRenderer {
  constructor(eventService, dateService, gridConfig, eventBus) {
    this.eventService = eventService;
    this.dateService = dateService;
    this.gridConfig = gridConfig;
    this.eventBus = eventBus;
    this.container = null;
    this.setupListeners();
  }
  /**
   * Setup listeners for drag-drop and update events
   */
  setupListeners() {
    this.eventBus.on(CoreEvents.EVENT_DRAG_COLUMN_CHANGE, (e) => {
      const payload = e.detail;
      this.handleColumnChange(payload);
    });
    this.eventBus.on(CoreEvents.EVENT_DRAG_MOVE, (e) => {
      const payload = e.detail;
      this.updateDragTimestamp(payload);
    });
    this.eventBus.on(CoreEvents.EVENT_UPDATED, (e) => {
      const payload = e.detail;
      this.handleEventUpdated(payload);
    });
    this.eventBus.on(CoreEvents.EVENT_DRAG_END, (e) => {
      const payload = e.detail;
      this.handleDragEnd(payload);
    });
    this.eventBus.on(CoreEvents.EVENT_DRAG_LEAVE_HEADER, (e) => {
      const payload = e.detail;
      this.handleDragLeaveHeader(payload);
    });
  }
  /**
   * Handle EVENT_DRAG_END - remove element if dropped in header
   */
  handleDragEnd(payload) {
    if (payload.target === "header") {
      const element = this.container?.querySelector(`swp-content-viewport swp-event[data-event-id="${payload.swpEvent.eventId}"]`);
      element?.remove();
    }
  }
  /**
   * Handle header item leaving header - create swp-event in grid
   */
  handleDragLeaveHeader(payload) {
    if (payload.source !== "header")
      return;
    if (!payload.targetColumn || !payload.start || !payload.end)
      return;
    if (payload.element) {
      payload.element.classList.add("drag-ghost");
      payload.element.style.opacity = "0.3";
      payload.element.style.pointerEvents = "none";
    }
    const event = {
      id: payload.eventId,
      title: payload.title || "",
      description: "",
      start: payload.start,
      end: payload.end,
      type: "customer",
      allDay: false,
      syncStatus: "pending"
    };
    const element = this.createEventElement(event);
    let eventsLayer = payload.targetColumn.querySelector("swp-events-layer");
    if (!eventsLayer) {
      eventsLayer = document.createElement("swp-events-layer");
      payload.targetColumn.appendChild(eventsLayer);
    }
    eventsLayer.appendChild(element);
    element.classList.add("dragging");
  }
  /**
   * Handle EVENT_UPDATED - re-render affected columns
   */
  async handleEventUpdated(payload) {
    if (payload.sourceColumnKey !== payload.targetColumnKey) {
      await this.rerenderColumn(payload.sourceColumnKey);
    }
    await this.rerenderColumn(payload.targetColumnKey);
  }
  /**
   * Re-render a single column with fresh data from IndexedDB
   */
  async rerenderColumn(columnKey) {
    const column = this.findColumn(columnKey);
    if (!column)
      return;
    const date = column.dataset.date;
    const resourceId = column.dataset.resourceId;
    if (!date)
      return;
    const startDate = new Date(date);
    const endDate = new Date(date);
    endDate.setHours(23, 59, 59, 999);
    const events = resourceId ? await this.eventService.getByResourceAndDateRange(resourceId, startDate, endDate) : await this.eventService.getByDateRange(startDate, endDate);
    const timedEvents = events.filter((event) => !event.allDay && this.dateService.getDateKey(event.start) === date);
    let eventsLayer = column.querySelector("swp-events-layer");
    if (!eventsLayer) {
      eventsLayer = document.createElement("swp-events-layer");
      column.appendChild(eventsLayer);
    }
    eventsLayer.innerHTML = "";
    const layout = calculateColumnLayout(timedEvents, this.gridConfig);
    layout.grids.forEach((grid) => {
      const groupEl = this.renderGridGroup(grid);
      eventsLayer.appendChild(groupEl);
    });
    layout.stacked.forEach((item) => {
      const eventEl = this.renderStackedEvent(item.event, item.stackLevel);
      eventsLayer.appendChild(eventEl);
    });
  }
  /**
   * Find a column element by columnKey
   */
  findColumn(columnKey) {
    if (!this.container)
      return null;
    return this.container.querySelector(`swp-day-column[data-column-key="${columnKey}"]`);
  }
  /**
   * Handle event moving to a new column during drag
   */
  handleColumnChange(payload) {
    const eventsLayer = payload.newColumn.querySelector("swp-events-layer");
    if (!eventsLayer)
      return;
    eventsLayer.appendChild(payload.element);
    payload.element.style.top = `${payload.currentY}px`;
  }
  /**
   * Update timestamp display during drag (snapped to grid)
   */
  updateDragTimestamp(payload) {
    const timeEl = payload.element.querySelector("swp-event-time");
    if (!timeEl)
      return;
    const snappedY = snapToGrid(payload.currentY, this.gridConfig);
    const minutesFromGridStart = pixelsToMinutes(snappedY, this.gridConfig);
    const startMinutes = this.gridConfig.dayStartHour * 60 + minutesFromGridStart;
    const height = parseFloat(payload.element.style.height) || this.gridConfig.hourHeight;
    const durationMinutes = pixelsToMinutes(height, this.gridConfig);
    const start = this.minutesToDate(startMinutes);
    const end = this.minutesToDate(startMinutes + durationMinutes);
    timeEl.textContent = this.dateService.formatTimeRange(start, end);
  }
  /**
   * Convert minutes since midnight to a Date object (today)
   */
  minutesToDate(minutes) {
    const date = /* @__PURE__ */ new Date();
    date.setHours(Math.floor(minutes / 60) % 24, minutes % 60, 0, 0);
    return date;
  }
  /**
   * Render events for visible dates into day columns
   * @param container - Calendar container element
   * @param filter - Filter with 'date' and optionally 'resource' arrays
   * @param filterTemplate - Template for matching events to columns
   */
  async render(container2, filter, filterTemplate) {
    this.container = container2;
    const visibleDates = filter["date"] || [];
    if (visibleDates.length === 0)
      return;
    const startDate = new Date(visibleDates[0]);
    const endDate = new Date(visibleDates[visibleDates.length - 1]);
    endDate.setHours(23, 59, 59, 999);
    const events = await this.eventService.getByDateRange(startDate, endDate);
    const dayColumns = container2.querySelector("swp-day-columns");
    if (!dayColumns)
      return;
    const columns = dayColumns.querySelectorAll("swp-day-column");
    columns.forEach((column) => {
      const columnEl = column;
      const columnEvents = events.filter((event) => filterTemplate.matches(event, columnEl));
      let eventsLayer = column.querySelector("swp-events-layer");
      if (!eventsLayer) {
        eventsLayer = document.createElement("swp-events-layer");
        column.appendChild(eventsLayer);
      }
      eventsLayer.innerHTML = "";
      const timedEvents = columnEvents.filter((event) => !event.allDay);
      const layout = calculateColumnLayout(timedEvents, this.gridConfig);
      layout.grids.forEach((grid) => {
        const groupEl = this.renderGridGroup(grid);
        eventsLayer.appendChild(groupEl);
      });
      layout.stacked.forEach((item) => {
        const eventEl = this.renderStackedEvent(item.event, item.stackLevel);
        eventsLayer.appendChild(eventEl);
      });
    });
  }
  /**
   * Create a single event element
   *
   * CLEAN approach:
   * - Only data-id for lookup
   * - Visible content in innerHTML only
   */
  createEventElement(event) {
    const element = document.createElement("swp-event");
    element.dataset.eventId = event.id;
    if (event.resourceId) {
      element.dataset.resourceId = event.resourceId;
    }
    const position = calculateEventPosition(event.start, event.end, this.gridConfig);
    element.style.top = `${position.top}px`;
    element.style.height = `${position.height}px`;
    const colorClass = this.getColorClass(event);
    if (colorClass) {
      element.classList.add(colorClass);
    }
    element.innerHTML = `
      <swp-event-time>${this.dateService.formatTimeRange(event.start, event.end)}</swp-event-time>
      <swp-event-title>${this.escapeHtml(event.title)}</swp-event-title>
      ${event.description ? `<swp-event-description>${this.escapeHtml(event.description)}</swp-event-description>` : ""}
    `;
    return element;
  }
  /**
   * Get color class based on metadata.color or event type
   */
  getColorClass(event) {
    if (event.metadata?.color) {
      return `is-${event.metadata.color}`;
    }
    const typeColors = {
      "customer": "is-blue",
      "vacation": "is-green",
      "break": "is-amber",
      "meeting": "is-purple",
      "blocked": "is-red"
    };
    return typeColors[event.type] || "is-blue";
  }
  /**
   * Escape HTML to prevent XSS
   */
  escapeHtml(text) {
    const div = document.createElement("div");
    div.textContent = text;
    return div.innerHTML;
  }
  /**
   * Render a GRID group with side-by-side columns
   * Used when multiple events start at the same time
   */
  renderGridGroup(layout) {
    const group = document.createElement("swp-event-group");
    group.classList.add(`cols-${layout.columns.length}`);
    group.style.top = `${layout.position.top}px`;
    if (layout.stackLevel > 0) {
      group.style.marginLeft = `${layout.stackLevel * 15}px`;
      group.style.zIndex = `${100 + layout.stackLevel}`;
    }
    let maxBottom = 0;
    for (const event of layout.events) {
      const pos = calculateEventPosition(event.start, event.end, this.gridConfig);
      const eventBottom = pos.top + pos.height;
      if (eventBottom > maxBottom)
        maxBottom = eventBottom;
    }
    const groupHeight = maxBottom - layout.position.top;
    group.style.height = `${groupHeight}px`;
    layout.columns.forEach((columnEvents) => {
      const wrapper = document.createElement("div");
      wrapper.style.position = "relative";
      columnEvents.forEach((event) => {
        const eventEl = this.createEventElement(event);
        const pos = calculateEventPosition(event.start, event.end, this.gridConfig);
        eventEl.style.top = `${pos.top - layout.position.top}px`;
        eventEl.style.position = "absolute";
        eventEl.style.left = "0";
        eventEl.style.right = "0";
        wrapper.appendChild(eventEl);
      });
      group.appendChild(wrapper);
    });
    return group;
  }
  /**
   * Render a STACKED event with margin-left offset
   * Used for overlapping events that don't start at the same time
   */
  renderStackedEvent(event, stackLevel) {
    const element = this.createEventElement(event);
    element.dataset.stackLink = JSON.stringify({ stackLevel });
    if (stackLevel > 0) {
      element.style.marginLeft = `${stackLevel * 15}px`;
      element.style.zIndex = `${100 + stackLevel}`;
    }
    return element;
  }
};
__name(_EventRenderer, "EventRenderer");
var EventRenderer = _EventRenderer;

// src/features/schedule/ScheduleRenderer.ts
var _ScheduleRenderer = class _ScheduleRenderer {
  constructor(scheduleService, dateService, gridConfig) {
    this.scheduleService = scheduleService;
    this.dateService = dateService;
    this.gridConfig = gridConfig;
  }
  /**
   * Render unavailable zones for visible columns
   * @param container - Calendar container element
   * @param filter - Filter with 'date' and 'resource' arrays
   */
  async render(container2, filter) {
    const dates = filter["date"] || [];
    const resourceIds = filter["resource"] || [];
    if (dates.length === 0)
      return;
    const dayColumns = container2.querySelector("swp-day-columns");
    if (!dayColumns)
      return;
    const columns = dayColumns.querySelectorAll("swp-day-column");
    for (const column of columns) {
      const date = column.dataset.date;
      const resourceId = column.dataset.resourceId;
      if (!date || !resourceId)
        continue;
      let unavailableLayer = column.querySelector("swp-unavailable-layer");
      if (!unavailableLayer) {
        unavailableLayer = document.createElement("swp-unavailable-layer");
        column.insertBefore(unavailableLayer, column.firstChild);
      }
      unavailableLayer.innerHTML = "";
      const schedule = await this.scheduleService.getScheduleForDate(resourceId, date);
      this.renderUnavailableZones(unavailableLayer, schedule);
    }
  }
  /**
   * Render unavailable time zones based on schedule
   */
  renderUnavailableZones(layer, schedule) {
    const dayStartMinutes = this.gridConfig.dayStartHour * 60;
    const dayEndMinutes = this.gridConfig.dayEndHour * 60;
    const minuteHeight = this.gridConfig.hourHeight / 60;
    if (schedule === null) {
      const zone = this.createUnavailableZone(0, (dayEndMinutes - dayStartMinutes) * minuteHeight);
      layer.appendChild(zone);
      return;
    }
    const workStartMinutes = this.dateService.timeToMinutes(schedule.start);
    const workEndMinutes = this.dateService.timeToMinutes(schedule.end);
    if (workStartMinutes > dayStartMinutes) {
      const top = 0;
      const height = (workStartMinutes - dayStartMinutes) * minuteHeight;
      const zone = this.createUnavailableZone(top, height);
      layer.appendChild(zone);
    }
    if (workEndMinutes < dayEndMinutes) {
      const top = (workEndMinutes - dayStartMinutes) * minuteHeight;
      const height = (dayEndMinutes - workEndMinutes) * minuteHeight;
      const zone = this.createUnavailableZone(top, height);
      layer.appendChild(zone);
    }
  }
  /**
   * Create an unavailable zone element
   */
  createUnavailableZone(top, height) {
    const zone = document.createElement("swp-unavailable-zone");
    zone.style.top = `${top}px`;
    zone.style.height = `${height}px`;
    return zone;
  }
};
__name(_ScheduleRenderer, "ScheduleRenderer");
var ScheduleRenderer = _ScheduleRenderer;

// src/features/headerdrawer/HeaderDrawerRenderer.ts
var _HeaderDrawerRenderer = class _HeaderDrawerRenderer {
  constructor(eventBus, gridConfig, headerDrawerManager, eventService, dateService) {
    this.eventBus = eventBus;
    this.gridConfig = gridConfig;
    this.headerDrawerManager = headerDrawerManager;
    this.eventService = eventService;
    this.dateService = dateService;
    this.currentItem = null;
    this.container = null;
    this.sourceElement = null;
    this.wasExpandedBeforeDrag = false;
    this.filterTemplate = null;
    this.setupListeners();
  }
  /**
   * Render allDay events into the header drawer with row stacking
   * @param filterTemplate - Template for matching events to columns
   */
  async render(container2, filter, filterTemplate) {
    this.filterTemplate = filterTemplate;
    const drawer = container2.querySelector("swp-header-drawer");
    if (!drawer)
      return;
    const visibleDates = filter["date"] || [];
    if (visibleDates.length === 0)
      return;
    const visibleColumnKeys = this.getVisibleColumnKeysFromDOM();
    if (visibleColumnKeys.length === 0)
      return;
    const startDate = new Date(visibleDates[0]);
    const endDate = new Date(visibleDates[visibleDates.length - 1]);
    endDate.setHours(23, 59, 59, 999);
    const events = await this.eventService.getByDateRange(startDate, endDate);
    const allDayEvents = events.filter((event) => event.allDay !== false);
    drawer.innerHTML = "";
    if (allDayEvents.length === 0)
      return;
    const layouts = this.calculateLayout(allDayEvents, visibleColumnKeys);
    const rowCount = Math.max(1, ...layouts.map((l) => l.row));
    layouts.forEach((layout) => {
      const item = this.createHeaderItem(layout);
      drawer.appendChild(item);
    });
    this.headerDrawerManager.expandToRows(rowCount);
  }
  /**
   * Create a header item element from layout
   */
  createHeaderItem(layout) {
    const { event, columnKey, row, colStart, colEnd } = layout;
    const item = document.createElement("swp-header-item");
    item.dataset.eventId = event.id;
    item.dataset.itemType = "event";
    item.dataset.start = event.start.toISOString();
    item.dataset.end = event.end.toISOString();
    item.dataset.columnKey = columnKey;
    item.textContent = event.title;
    const colorClass = this.getColorClass(event);
    if (colorClass)
      item.classList.add(colorClass);
    item.style.gridArea = `${row} / ${colStart} / ${row + 1} / ${colEnd}`;
    return item;
  }
  /**
   * Calculate layout for all events with row stacking
   * Uses track-based algorithm to find available rows for overlapping events
   */
  calculateLayout(events, visibleColumnKeys) {
    const tracks = [new Array(visibleColumnKeys.length).fill(false)];
    const layouts = [];
    for (const event of events) {
      const columnKey = this.buildColumnKeyFromEvent(event);
      const startCol = visibleColumnKeys.indexOf(columnKey);
      const endColumnKey = this.buildColumnKeyFromEvent(event, event.end);
      const endCol = visibleColumnKeys.indexOf(endColumnKey);
      if (startCol === -1 && endCol === -1)
        continue;
      const colStart = Math.max(0, startCol);
      const colEnd = (endCol !== -1 ? endCol : visibleColumnKeys.length - 1) + 1;
      const row = this.findAvailableRow(tracks, colStart, colEnd);
      for (let c = colStart; c < colEnd; c++) {
        tracks[row][c] = true;
      }
      layouts.push({ event, columnKey, row: row + 1, colStart: colStart + 1, colEnd: colEnd + 1 });
    }
    return layouts;
  }
  /**
   * Build columnKey from event using FilterTemplate
   * Uses the same template that columns use for matching
   */
  buildColumnKeyFromEvent(event, date) {
    if (!this.filterTemplate) {
      const dateStr = this.dateService.getDateKey(date || event.start);
      return dateStr;
    }
    if (date && date.getTime() !== event.start.getTime()) {
      const tempEvent = { ...event, start: date };
      return this.filterTemplate.buildKeyFromEvent(tempEvent);
    }
    return this.filterTemplate.buildKeyFromEvent(event);
  }
  /**
   * Find available row for event spanning columns [colStart, colEnd)
   */
  findAvailableRow(tracks, colStart, colEnd) {
    for (let row = 0; row < tracks.length; row++) {
      let available = true;
      for (let c = colStart; c < colEnd; c++) {
        if (tracks[row][c]) {
          available = false;
          break;
        }
      }
      if (available)
        return row;
    }
    tracks.push(new Array(tracks[0].length).fill(false));
    return tracks.length - 1;
  }
  /**
   * Get color class based on event metadata or type
   */
  getColorClass(event) {
    if (event.metadata?.color) {
      return `is-${event.metadata.color}`;
    }
    const typeColors = {
      "customer": "is-blue",
      "vacation": "is-green",
      "break": "is-amber",
      "meeting": "is-purple",
      "blocked": "is-red"
    };
    return typeColors[event.type] || "is-blue";
  }
  /**
   * Setup event listeners for drag events
   */
  setupListeners() {
    this.eventBus.on(CoreEvents.EVENT_DRAG_ENTER_HEADER, (e) => {
      const payload = e.detail;
      this.handleDragEnter(payload);
    });
    this.eventBus.on(CoreEvents.EVENT_DRAG_MOVE_HEADER, (e) => {
      const payload = e.detail;
      this.handleDragMove(payload);
    });
    this.eventBus.on(CoreEvents.EVENT_DRAG_LEAVE_HEADER, (e) => {
      const payload = e.detail;
      this.handleDragLeave(payload);
    });
    this.eventBus.on(CoreEvents.EVENT_DRAG_END, (e) => {
      const payload = e.detail;
      this.handleDragEnd(payload);
    });
    this.eventBus.on(CoreEvents.EVENT_DRAG_CANCEL, () => {
      this.cleanup();
    });
  }
  /**
   * Handle drag entering header zone - create preview item
   */
  handleDragEnter(payload) {
    this.container = document.querySelector("swp-header-drawer");
    if (!this.container)
      return;
    this.wasExpandedBeforeDrag = this.headerDrawerManager.isExpanded();
    if (!this.wasExpandedBeforeDrag) {
      this.headerDrawerManager.expandToRows(1);
    }
    this.sourceElement = payload.element;
    const item = document.createElement("swp-header-item");
    item.dataset.eventId = payload.eventId;
    item.dataset.itemType = payload.itemType;
    item.dataset.duration = String(payload.duration);
    item.dataset.columnKey = payload.sourceColumnKey;
    item.textContent = payload.title;
    if (payload.colorClass) {
      item.classList.add(payload.colorClass);
    }
    item.classList.add("dragging");
    const col = payload.sourceColumnIndex + 1;
    const endCol = col + payload.duration;
    item.style.gridArea = `1 / ${col} / 2 / ${endCol}`;
    this.container.appendChild(item);
    this.currentItem = item;
    payload.element.style.visibility = "hidden";
  }
  /**
   * Handle drag moving within header - update column position
   */
  handleDragMove(payload) {
    if (!this.currentItem)
      return;
    const col = payload.columnIndex + 1;
    const duration = parseInt(this.currentItem.dataset.duration || "1", 10);
    const endCol = col + duration;
    this.currentItem.style.gridArea = `1 / ${col} / 2 / ${endCol}`;
    this.currentItem.dataset.columnKey = payload.columnKey;
  }
  /**
   * Handle drag leaving header - cleanup for grid→header drag only
   */
  handleDragLeave(payload) {
    if (payload.source === "grid") {
      this.cleanup();
    }
  }
  /**
   * Handle drag end - finalize based on drop target
   */
  handleDragEnd(payload) {
    if (payload.target === "header") {
      if (this.currentItem) {
        this.currentItem.classList.remove("dragging");
        this.recalculateDrawerLayout();
        this.currentItem = null;
        this.sourceElement = null;
      }
    } else {
      const ghost = document.querySelector(`swp-header-item.drag-ghost[data-event-id="${payload.swpEvent.eventId}"]`);
      ghost?.remove();
      this.recalculateDrawerLayout();
    }
  }
  /**
   * Recalculate layout for all items currently in the drawer
   * Called after drop to reposition items and adjust height
   */
  recalculateDrawerLayout() {
    const drawer = document.querySelector("swp-header-drawer");
    if (!drawer)
      return;
    const items = Array.from(drawer.querySelectorAll("swp-header-item"));
    if (items.length === 0)
      return;
    const visibleColumnKeys = this.getVisibleColumnKeysFromDOM();
    if (visibleColumnKeys.length === 0)
      return;
    const itemData = items.map((item) => ({
      element: item,
      columnKey: item.dataset.columnKey || "",
      duration: parseInt(item.dataset.duration || "1", 10)
    }));
    const tracks = [new Array(visibleColumnKeys.length).fill(false)];
    for (const item of itemData) {
      const startCol = visibleColumnKeys.indexOf(item.columnKey);
      if (startCol === -1)
        continue;
      const colStart = startCol;
      const colEnd = Math.min(startCol + item.duration, visibleColumnKeys.length);
      const row = this.findAvailableRow(tracks, colStart, colEnd);
      for (let c = colStart; c < colEnd; c++) {
        tracks[row][c] = true;
      }
      item.element.style.gridArea = `${row + 1} / ${colStart + 1} / ${row + 2} / ${colEnd + 1}`;
    }
    const rowCount = tracks.length;
    this.headerDrawerManager.expandToRows(rowCount);
  }
  /**
   * Get visible column keys from DOM (preserves order for multi-resource views)
   * Uses filterTemplate.buildKeyFromColumn() for consistent key format with events
   */
  getVisibleColumnKeysFromDOM() {
    if (!this.filterTemplate)
      return [];
    const columns = document.querySelectorAll("swp-day-column");
    const columnKeys = [];
    columns.forEach((col) => {
      const columnKey = this.filterTemplate.buildKeyFromColumn(col);
      if (columnKey)
        columnKeys.push(columnKey);
    });
    return columnKeys;
  }
  /**
   * Cleanup preview item and restore source visibility
   */
  cleanup() {
    this.currentItem?.remove();
    this.currentItem = null;
    if (this.sourceElement) {
      this.sourceElement.style.visibility = "";
      this.sourceElement = null;
    }
    if (!this.wasExpandedBeforeDrag) {
      this.headerDrawerManager.collapse();
    }
  }
};
__name(_HeaderDrawerRenderer, "HeaderDrawerRenderer");
var HeaderDrawerRenderer = _HeaderDrawerRenderer;

// src/storage/schedules/ScheduleOverrideStore.ts
var _ScheduleOverrideStore = class _ScheduleOverrideStore {
  constructor() {
    this.storeName = _ScheduleOverrideStore.STORE_NAME;
  }
  create(db) {
    const store = db.createObjectStore(_ScheduleOverrideStore.STORE_NAME, { keyPath: "id" });
    store.createIndex("resourceId", "resourceId", { unique: false });
    store.createIndex("date", "date", { unique: false });
    store.createIndex("resourceId_date", ["resourceId", "date"], { unique: true });
    store.createIndex("syncStatus", "syncStatus", { unique: false });
  }
};
__name(_ScheduleOverrideStore, "ScheduleOverrideStore");
var ScheduleOverrideStore = _ScheduleOverrideStore;
ScheduleOverrideStore.STORE_NAME = "scheduleOverrides";

// src/storage/schedules/ScheduleOverrideService.ts
var _ScheduleOverrideService = class _ScheduleOverrideService {
  constructor(context) {
    this.context = context;
  }
  get db() {
    return this.context.getDatabase();
  }
  /**
   * Get override for a specific resource and date
   */
  async getOverride(resourceId, date) {
    return new Promise((resolve, reject) => {
      const transaction = this.db.transaction([ScheduleOverrideStore.STORE_NAME], "readonly");
      const store = transaction.objectStore(ScheduleOverrideStore.STORE_NAME);
      const index = store.index("resourceId_date");
      const request = index.get([resourceId, date]);
      request.onsuccess = () => {
        resolve(request.result || null);
      };
      request.onerror = () => {
        reject(new Error(`Failed to get override for ${resourceId} on ${date}: ${request.error}`));
      };
    });
  }
  /**
   * Get all overrides for a resource
   */
  async getByResource(resourceId) {
    return new Promise((resolve, reject) => {
      const transaction = this.db.transaction([ScheduleOverrideStore.STORE_NAME], "readonly");
      const store = transaction.objectStore(ScheduleOverrideStore.STORE_NAME);
      const index = store.index("resourceId");
      const request = index.getAll(resourceId);
      request.onsuccess = () => {
        resolve(request.result || []);
      };
      request.onerror = () => {
        reject(new Error(`Failed to get overrides for ${resourceId}: ${request.error}`));
      };
    });
  }
  /**
   * Get overrides for a date range
   */
  async getByDateRange(resourceId, startDate, endDate) {
    const all = await this.getByResource(resourceId);
    return all.filter((o) => o.date >= startDate && o.date <= endDate);
  }
  /**
   * Save an override
   */
  async save(override) {
    return new Promise((resolve, reject) => {
      const transaction = this.db.transaction([ScheduleOverrideStore.STORE_NAME], "readwrite");
      const store = transaction.objectStore(ScheduleOverrideStore.STORE_NAME);
      const request = store.put(override);
      request.onsuccess = () => resolve();
      request.onerror = () => {
        reject(new Error(`Failed to save override ${override.id}: ${request.error}`));
      };
    });
  }
  /**
   * Delete an override
   */
  async delete(id) {
    return new Promise((resolve, reject) => {
      const transaction = this.db.transaction([ScheduleOverrideStore.STORE_NAME], "readwrite");
      const store = transaction.objectStore(ScheduleOverrideStore.STORE_NAME);
      const request = store.delete(id);
      request.onsuccess = () => resolve();
      request.onerror = () => {
        reject(new Error(`Failed to delete override ${id}: ${request.error}`));
      };
    });
  }
};
__name(_ScheduleOverrideService, "ScheduleOverrideService");
var ScheduleOverrideService = _ScheduleOverrideService;

// src/storage/schedules/ResourceScheduleService.ts
var _ResourceScheduleService = class _ResourceScheduleService {
  constructor(resourceService, overrideService, dateService) {
    this.resourceService = resourceService;
    this.overrideService = overrideService;
    this.dateService = dateService;
  }
  /**
   * Get effective schedule for a resource on a specific date
   *
   * @param resourceId - Resource ID
   * @param date - Date string "YYYY-MM-DD"
   * @returns ITimeSlot or null (fri/closed)
   */
  async getScheduleForDate(resourceId, date) {
    const override = await this.overrideService.getOverride(resourceId, date);
    if (override) {
      return override.schedule;
    }
    const resource = await this.resourceService.get(resourceId);
    if (!resource || !resource.defaultSchedule) {
      return null;
    }
    const weekDay = this.dateService.getISOWeekDay(date);
    return resource.defaultSchedule[weekDay] || null;
  }
  /**
   * Get schedules for multiple dates
   *
   * @param resourceId - Resource ID
   * @param dates - Array of date strings "YYYY-MM-DD"
   * @returns Map of date -> ITimeSlot | null
   */
  async getSchedulesForDates(resourceId, dates) {
    const result = /* @__PURE__ */ new Map();
    const resource = await this.resourceService.get(resourceId);
    const overrides = dates.length > 0 ? await this.overrideService.getByDateRange(resourceId, dates[0], dates[dates.length - 1]) : [];
    const overrideMap = new Map(overrides.map((o) => [o.date, o.schedule]));
    for (const date of dates) {
      if (overrideMap.has(date)) {
        result.set(date, overrideMap.get(date));
        continue;
      }
      if (resource?.defaultSchedule) {
        const weekDay = this.dateService.getISOWeekDay(date);
        result.set(date, resource.defaultSchedule[weekDay] || null);
      } else {
        result.set(date, null);
      }
    }
    return result;
  }
};
__name(_ResourceScheduleService, "ResourceScheduleService");
var ResourceScheduleService = _ResourceScheduleService;

// src/types/SwpEvent.ts
var _SwpEvent = class _SwpEvent {
  constructor(element, columnKey, start, end) {
    this.element = element;
    this.columnKey = columnKey;
    this._start = start;
    this._end = end;
  }
  /** Event ID from element.dataset.eventId */
  get eventId() {
    return this.element.dataset.eventId || "";
  }
  get start() {
    return this._start;
  }
  get end() {
    return this._end;
  }
  /** Duration in minutes */
  get durationMinutes() {
    return (this._end.getTime() - this._start.getTime()) / (1e3 * 60);
  }
  /** Duration in milliseconds */
  get durationMs() {
    return this._end.getTime() - this._start.getTime();
  }
  /**
   * Factory: Create SwpEvent from element + columnKey
   * Reads top/height from element.style to calculate start/end
   * @param columnKey - Opaque column identifier (do NOT parse - use only for matching)
   * @param date - Date string (YYYY-MM-DD) for time calculations
   */
  static fromElement(element, columnKey, date, gridConfig) {
    const topPixels = parseFloat(element.style.top) || 0;
    const heightPixels = parseFloat(element.style.height) || 0;
    const startMinutesFromGrid = topPixels / gridConfig.hourHeight * 60;
    const totalMinutes = gridConfig.dayStartHour * 60 + startMinutesFromGrid;
    const start = new Date(date);
    start.setHours(Math.floor(totalMinutes / 60), totalMinutes % 60, 0, 0);
    const durationMinutes = heightPixels / gridConfig.hourHeight * 60;
    const end = new Date(start.getTime() + durationMinutes * 60 * 1e3);
    return new _SwpEvent(element, columnKey, start, end);
  }
};
__name(_SwpEvent, "SwpEvent");
var SwpEvent = _SwpEvent;

// src/managers/DragDropManager.ts
var _DragDropManager = class _DragDropManager {
  constructor(eventBus, gridConfig) {
    this.eventBus = eventBus;
    this.gridConfig = gridConfig;
    this.dragState = null;
    this.mouseDownPosition = null;
    this.pendingElement = null;
    this.pendingMouseOffset = null;
    this.container = null;
    this.inHeader = false;
    this.DRAG_THRESHOLD = 5;
    this.INTERPOLATION_FACTOR = 0.3;
    this.handlePointerDown = (e) => {
      const target = e.target;
      if (target.closest("swp-resize-handle"))
        return;
      const eventElement = target.closest("swp-event");
      const headerItem = target.closest("swp-header-item");
      const draggable = eventElement || headerItem;
      if (!draggable)
        return;
      this.mouseDownPosition = { x: e.clientX, y: e.clientY };
      this.pendingElement = draggable;
      const rect = draggable.getBoundingClientRect();
      this.pendingMouseOffset = {
        x: e.clientX - rect.left,
        y: e.clientY - rect.top
      };
      draggable.setPointerCapture(e.pointerId);
    };
    this.handlePointerMove = (e) => {
      if (!this.mouseDownPosition || !this.pendingElement) {
        if (this.dragState) {
          this.updateDragTarget(e);
        }
        return;
      }
      const deltaX = Math.abs(e.clientX - this.mouseDownPosition.x);
      const deltaY = Math.abs(e.clientY - this.mouseDownPosition.y);
      const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
      if (distance < this.DRAG_THRESHOLD)
        return;
      this.initializeDrag(this.pendingElement, this.pendingMouseOffset, e);
      this.mouseDownPosition = null;
      this.pendingElement = null;
      this.pendingMouseOffset = null;
    };
    this.handlePointerUp = (_e) => {
      this.mouseDownPosition = null;
      this.pendingElement = null;
      this.pendingMouseOffset = null;
      if (!this.dragState)
        return;
      cancelAnimationFrame(this.dragState.animationId);
      if (this.dragState.dragSource === "header") {
        this.handleHeaderItemDragEnd();
      } else {
        this.handleGridEventDragEnd();
      }
      this.dragState.element.classList.remove("dragging");
      this.dragState = null;
      this.inHeader = false;
    };
    this.animateDrag = () => {
      if (!this.dragState)
        return;
      const diff2 = this.dragState.targetY - this.dragState.currentY;
      if (Math.abs(diff2) <= 0.5) {
        this.dragState.animationId = 0;
        return;
      }
      this.dragState.currentY += diff2 * this.INTERPOLATION_FACTOR;
      this.dragState.element.style.top = `${this.dragState.currentY}px`;
      if (this.dragState.columnElement) {
        const payload = {
          eventId: this.dragState.eventId,
          element: this.dragState.element,
          currentY: this.dragState.currentY,
          columnElement: this.dragState.columnElement
        };
        this.eventBus.emit(CoreEvents.EVENT_DRAG_MOVE, payload);
      }
      this.dragState.animationId = requestAnimationFrame(this.animateDrag);
    };
    this.setupScrollListener();
  }
  setupScrollListener() {
    this.eventBus.on(CoreEvents.EDGE_SCROLL_TICK, (e) => {
      if (!this.dragState)
        return;
      const { scrollDelta } = e.detail;
      this.dragState.targetY += scrollDelta;
      this.dragState.currentY += scrollDelta;
      this.dragState.element.style.top = `${this.dragState.currentY}px`;
    });
  }
  /**
   * Initialize drag-drop on a container element
   */
  init(container2) {
    this.container = container2;
    container2.addEventListener("pointerdown", this.handlePointerDown);
    document.addEventListener("pointermove", this.handlePointerMove);
    document.addEventListener("pointerup", this.handlePointerUp);
  }
  /**
   * Handle drag end for header items
   */
  handleHeaderItemDragEnd() {
    if (!this.dragState)
      return;
    if (!this.inHeader && this.dragState.currentColumn) {
      const gridEvent = this.dragState.currentColumn.querySelector(`swp-event[data-event-id="${this.dragState.eventId}"]`);
      if (gridEvent) {
        const columnKey = this.dragState.currentColumn.dataset.columnKey || "";
        const date = this.dragState.currentColumn.dataset.date || "";
        const swpEvent = SwpEvent.fromElement(gridEvent, columnKey, date, this.gridConfig);
        const payload = {
          swpEvent,
          sourceColumnKey: this.dragState.sourceColumnKey,
          target: "grid"
        };
        this.eventBus.emit(CoreEvents.EVENT_DRAG_END, payload);
      }
    }
  }
  /**
   * Handle drag end for grid events
   */
  handleGridEventDragEnd() {
    if (!this.dragState || !this.dragState.columnElement)
      return;
    const snappedY = snapToGrid(this.dragState.currentY, this.gridConfig);
    this.dragState.element.style.top = `${snappedY}px`;
    this.dragState.ghostElement?.remove();
    const columnKey = this.dragState.columnElement.dataset.columnKey || "";
    const date = this.dragState.columnElement.dataset.date || "";
    const swpEvent = SwpEvent.fromElement(this.dragState.element, columnKey, date, this.gridConfig);
    const payload = {
      swpEvent,
      sourceColumnKey: this.dragState.sourceColumnKey,
      target: this.inHeader ? "header" : "grid"
    };
    this.eventBus.emit(CoreEvents.EVENT_DRAG_END, payload);
  }
  initializeDrag(element, mouseOffset, e) {
    const eventId = element.dataset.eventId || "";
    const isHeaderItem = element.tagName.toLowerCase() === "swp-header-item";
    const columnElement = element.closest("swp-day-column");
    if (!isHeaderItem && !columnElement)
      return;
    if (isHeaderItem) {
      this.initializeHeaderItemDrag(element, mouseOffset, eventId);
    } else {
      this.initializeGridEventDrag(element, mouseOffset, e, columnElement, eventId);
    }
  }
  /**
   * Initialize drag for a header item (allDay event)
   */
  initializeHeaderItemDrag(element, mouseOffset, eventId) {
    element.classList.add("dragging");
    this.dragState = {
      eventId,
      element,
      ghostElement: null,
      // No ghost for header items
      startY: 0,
      mouseOffset,
      columnElement: null,
      currentColumn: null,
      targetY: 0,
      currentY: 0,
      animationId: 0,
      sourceColumnKey: "",
      // Will be set from header item data
      dragSource: "header"
    };
    this.inHeader = true;
  }
  /**
   * Initialize drag for a grid event
   */
  initializeGridEventDrag(element, mouseOffset, e, columnElement, eventId) {
    const elementRect = element.getBoundingClientRect();
    const columnRect = columnElement.getBoundingClientRect();
    const startY = elementRect.top - columnRect.top;
    const group = element.closest("swp-event-group");
    if (group) {
      const eventsLayer = columnElement.querySelector("swp-events-layer");
      if (eventsLayer) {
        eventsLayer.appendChild(element);
      }
    }
    element.style.position = "absolute";
    element.style.top = `${startY}px`;
    element.style.left = "2px";
    element.style.right = "2px";
    element.style.marginLeft = "0";
    const ghostElement = element.cloneNode(true);
    ghostElement.classList.add("drag-ghost");
    ghostElement.style.opacity = "0.3";
    ghostElement.style.pointerEvents = "none";
    element.parentNode?.insertBefore(ghostElement, element);
    element.classList.add("dragging");
    const targetY = e.clientY - columnRect.top - mouseOffset.y;
    this.dragState = {
      eventId,
      element,
      ghostElement,
      startY,
      mouseOffset,
      columnElement,
      currentColumn: columnElement,
      targetY: Math.max(0, targetY),
      currentY: startY,
      animationId: 0,
      sourceColumnKey: columnElement.dataset.columnKey || "",
      dragSource: "grid"
    };
    const payload = {
      eventId,
      element,
      ghostElement,
      startY,
      mouseOffset,
      columnElement
    };
    this.eventBus.emit(CoreEvents.EVENT_DRAG_START, payload);
    this.animateDrag();
  }
  updateDragTarget(e) {
    if (!this.dragState)
      return;
    this.checkHeaderZone(e);
    if (this.inHeader)
      return;
    const columnAtPoint = this.getColumnAtPoint(e.clientX);
    if (this.dragState.dragSource === "header" && columnAtPoint && !this.dragState.currentColumn) {
      this.dragState.currentColumn = columnAtPoint;
      this.dragState.columnElement = columnAtPoint;
    }
    if (columnAtPoint && columnAtPoint !== this.dragState.currentColumn && this.dragState.currentColumn) {
      const payload = {
        eventId: this.dragState.eventId,
        element: this.dragState.element,
        previousColumn: this.dragState.currentColumn,
        newColumn: columnAtPoint,
        currentY: this.dragState.currentY
      };
      this.eventBus.emit(CoreEvents.EVENT_DRAG_COLUMN_CHANGE, payload);
      this.dragState.currentColumn = columnAtPoint;
      this.dragState.columnElement = columnAtPoint;
    }
    if (!this.dragState.columnElement)
      return;
    const columnRect = this.dragState.columnElement.getBoundingClientRect();
    const targetY = e.clientY - columnRect.top - this.dragState.mouseOffset.y;
    this.dragState.targetY = Math.max(0, targetY);
    if (!this.dragState.animationId) {
      this.animateDrag();
    }
  }
  /**
   * Check if pointer is in header zone and emit appropriate events
   */
  checkHeaderZone(e) {
    if (!this.dragState)
      return;
    const headerViewport = document.querySelector("swp-header-viewport");
    if (!headerViewport)
      return;
    const rect = headerViewport.getBoundingClientRect();
    const isInHeader = e.clientY < rect.bottom;
    if (isInHeader && !this.inHeader) {
      this.inHeader = true;
      if (this.dragState.dragSource === "grid" && this.dragState.columnElement) {
        const payload = {
          eventId: this.dragState.eventId,
          element: this.dragState.element,
          sourceColumnIndex: this.getColumnIndex(this.dragState.columnElement),
          sourceColumnKey: this.dragState.columnElement.dataset.columnKey || "",
          title: this.dragState.element.querySelector("swp-event-title")?.textContent || "",
          colorClass: [...this.dragState.element.classList].find((c) => c.startsWith("is-")),
          itemType: "event",
          duration: 1
        };
        this.eventBus.emit(CoreEvents.EVENT_DRAG_ENTER_HEADER, payload);
      }
    } else if (!isInHeader && this.inHeader) {
      this.inHeader = false;
      const targetColumn = this.getColumnAtPoint(e.clientX);
      if (this.dragState.dragSource === "header") {
        const payload = {
          eventId: this.dragState.eventId,
          source: "header",
          element: this.dragState.element,
          targetColumn: targetColumn || void 0,
          start: this.dragState.element.dataset.start ? new Date(this.dragState.element.dataset.start) : void 0,
          end: this.dragState.element.dataset.end ? new Date(this.dragState.element.dataset.end) : void 0,
          title: this.dragState.element.textContent || "",
          colorClass: [...this.dragState.element.classList].find((c) => c.startsWith("is-"))
        };
        this.eventBus.emit(CoreEvents.EVENT_DRAG_LEAVE_HEADER, payload);
        if (targetColumn) {
          const newElement = targetColumn.querySelector(`swp-event[data-event-id="${this.dragState.eventId}"]`);
          if (newElement) {
            this.dragState.element = newElement;
            this.dragState.columnElement = targetColumn;
            this.dragState.currentColumn = targetColumn;
            this.animateDrag();
          }
        }
      } else {
        const payload = {
          eventId: this.dragState.eventId,
          source: "grid"
        };
        this.eventBus.emit(CoreEvents.EVENT_DRAG_LEAVE_HEADER, payload);
      }
    } else if (isInHeader) {
      const column = this.getColumnAtX(e.clientX);
      if (column) {
        const payload = {
          eventId: this.dragState.eventId,
          columnIndex: this.getColumnIndex(column),
          columnKey: column.dataset.columnKey || ""
        };
        this.eventBus.emit(CoreEvents.EVENT_DRAG_MOVE_HEADER, payload);
      }
    }
  }
  /**
   * Get column index (0-based) for a column element
   */
  getColumnIndex(column) {
    if (!this.container || !column)
      return 0;
    const columns = Array.from(this.container.querySelectorAll("swp-day-column"));
    return columns.indexOf(column);
  }
  /**
   * Get column at X coordinate (alias for getColumnAtPoint)
   */
  getColumnAtX(clientX) {
    return this.getColumnAtPoint(clientX);
  }
  /**
   * Find column element at given X coordinate
   */
  getColumnAtPoint(clientX) {
    if (!this.container)
      return null;
    const columns = this.container.querySelectorAll("swp-day-column");
    for (const col of columns) {
      const rect = col.getBoundingClientRect();
      if (clientX >= rect.left && clientX <= rect.right) {
        return col;
      }
    }
    return null;
  }
  /**
   * Cancel drag and animate back to start position
   */
  cancelDrag() {
    if (!this.dragState)
      return;
    cancelAnimationFrame(this.dragState.animationId);
    const { element, ghostElement, startY, eventId } = this.dragState;
    element.style.transition = "top 200ms ease-out";
    element.style.top = `${startY}px`;
    setTimeout(() => {
      ghostElement?.remove();
      element.style.transition = "";
      element.classList.remove("dragging");
    }, 200);
    const payload = {
      eventId,
      element,
      startY
    };
    this.eventBus.emit(CoreEvents.EVENT_DRAG_CANCEL, payload);
    this.dragState = null;
    this.inHeader = false;
  }
};
__name(_DragDropManager, "DragDropManager");
var DragDropManager = _DragDropManager;

// src/managers/EdgeScrollManager.ts
var _EdgeScrollManager = class _EdgeScrollManager {
  constructor(eventBus) {
    this.eventBus = eventBus;
    this.scrollableContent = null;
    this.timeGrid = null;
    this.draggedElement = null;
    this.scrollRAF = null;
    this.mouseY = 0;
    this.isDragging = false;
    this.isScrolling = false;
    this.lastTs = 0;
    this.rect = null;
    this.initialScrollTop = 0;
    this.OUTER_ZONE = 100;
    this.INNER_ZONE = 50;
    this.SLOW_SPEED = 140;
    this.FAST_SPEED = 640;
    this.trackMouse = (e) => {
      if (this.isDragging) {
        this.mouseY = e.clientY;
      }
    };
    this.scrollTick = (ts) => {
      if (!this.isDragging || !this.scrollableContent)
        return;
      const dt = this.lastTs ? (ts - this.lastTs) / 1e3 : 0;
      this.lastTs = ts;
      this.rect ?? (this.rect = this.scrollableContent.getBoundingClientRect());
      const velocity = this.calculateVelocity();
      if (velocity !== 0 && !this.isAtBoundary(velocity)) {
        const scrollDelta = velocity * dt;
        this.scrollableContent.scrollTop += scrollDelta;
        this.rect = null;
        this.eventBus.emit(CoreEvents.EDGE_SCROLL_TICK, { scrollDelta });
        this.setScrollingState(true);
      } else {
        this.setScrollingState(false);
      }
      this.scrollRAF = requestAnimationFrame(this.scrollTick);
    };
    this.subscribeToEvents();
    document.addEventListener("pointermove", this.trackMouse);
  }
  init(scrollableContent) {
    this.scrollableContent = scrollableContent;
    this.timeGrid = scrollableContent.querySelector("swp-time-grid");
    this.scrollableContent.style.scrollBehavior = "auto";
  }
  subscribeToEvents() {
    this.eventBus.on(CoreEvents.EVENT_DRAG_START, (event) => {
      const payload = event.detail;
      this.draggedElement = payload.element;
      this.startDrag();
    });
    this.eventBus.on(CoreEvents.EVENT_DRAG_END, () => this.stopDrag());
    this.eventBus.on(CoreEvents.EVENT_DRAG_CANCEL, () => this.stopDrag());
  }
  startDrag() {
    this.isDragging = true;
    this.isScrolling = false;
    this.lastTs = 0;
    this.initialScrollTop = this.scrollableContent?.scrollTop ?? 0;
    if (this.scrollRAF === null) {
      this.scrollRAF = requestAnimationFrame(this.scrollTick);
    }
  }
  stopDrag() {
    this.isDragging = false;
    this.setScrollingState(false);
    if (this.scrollRAF !== null) {
      cancelAnimationFrame(this.scrollRAF);
      this.scrollRAF = null;
    }
    this.rect = null;
    this.lastTs = 0;
    this.initialScrollTop = 0;
  }
  calculateVelocity() {
    if (!this.rect)
      return 0;
    const distTop = this.mouseY - this.rect.top;
    const distBot = this.rect.bottom - this.mouseY;
    if (distTop < this.INNER_ZONE)
      return -this.FAST_SPEED;
    if (distTop < this.OUTER_ZONE)
      return -this.SLOW_SPEED;
    if (distBot < this.INNER_ZONE)
      return this.FAST_SPEED;
    if (distBot < this.OUTER_ZONE)
      return this.SLOW_SPEED;
    return 0;
  }
  isAtBoundary(velocity) {
    if (!this.scrollableContent || !this.timeGrid || !this.draggedElement)
      return false;
    const atTop = this.scrollableContent.scrollTop <= 0 && velocity < 0;
    const atBottom = velocity > 0 && this.draggedElement.getBoundingClientRect().bottom >= this.timeGrid.getBoundingClientRect().bottom;
    return atTop || atBottom;
  }
  setScrollingState(scrolling) {
    if (this.isScrolling === scrolling)
      return;
    this.isScrolling = scrolling;
    if (scrolling) {
      this.eventBus.emit(CoreEvents.EDGE_SCROLL_STARTED, {});
    } else {
      this.initialScrollTop = this.scrollableContent?.scrollTop ?? 0;
      this.eventBus.emit(CoreEvents.EDGE_SCROLL_STOPPED, {});
    }
  }
};
__name(_EdgeScrollManager, "EdgeScrollManager");
var EdgeScrollManager = _EdgeScrollManager;

// src/managers/ResizeManager.ts
var _ResizeManager = class _ResizeManager {
  constructor(eventBus, gridConfig, dateService) {
    this.eventBus = eventBus;
    this.gridConfig = gridConfig;
    this.dateService = dateService;
    this.container = null;
    this.resizeState = null;
    this.Z_INDEX_RESIZING = "1000";
    this.ANIMATION_SPEED = 0.35;
    this.MIN_HEIGHT_MINUTES = 15;
    this.handleMouseOver = (e) => {
      const target = e.target;
      const eventElement = target.closest("swp-event");
      if (!eventElement || this.resizeState)
        return;
      if (!eventElement.querySelector(":scope > swp-resize-handle")) {
        const handle = this.createResizeHandle();
        eventElement.appendChild(handle);
      }
    };
    this.handlePointerDown = (e) => {
      const handle = e.target.closest("swp-resize-handle");
      if (!handle)
        return;
      const element = handle.parentElement;
      if (!element)
        return;
      const eventId = element.dataset.eventId || "";
      const startHeight = element.offsetHeight;
      const startDurationMinutes = pixelsToMinutes(startHeight, this.gridConfig);
      const container2 = element.closest("swp-event-group") ?? element;
      const prevZIndex = container2.style.zIndex;
      this.resizeState = {
        eventId,
        element,
        handleElement: handle,
        startY: e.clientY,
        startHeight,
        startDurationMinutes,
        pointerId: e.pointerId,
        prevZIndex,
        // Animation state
        currentHeight: startHeight,
        targetHeight: startHeight,
        animationId: null
      };
      container2.style.zIndex = this.Z_INDEX_RESIZING;
      try {
        handle.setPointerCapture(e.pointerId);
      } catch (err) {
        console.warn("Pointer capture failed:", err);
      }
      document.documentElement.classList.add("swp--resizing");
      this.eventBus.emit(CoreEvents.EVENT_RESIZE_START, {
        eventId,
        element,
        startHeight
      });
      e.preventDefault();
    };
    this.handlePointerMove = (e) => {
      if (!this.resizeState)
        return;
      const deltaY = e.clientY - this.resizeState.startY;
      const minHeight = this.MIN_HEIGHT_MINUTES / 60 * this.gridConfig.hourHeight;
      const newHeight = Math.max(minHeight, this.resizeState.startHeight + deltaY);
      this.resizeState.targetHeight = newHeight;
      if (this.resizeState.animationId === null) {
        this.animateHeight();
      }
    };
    this.animateHeight = () => {
      if (!this.resizeState)
        return;
      const diff2 = this.resizeState.targetHeight - this.resizeState.currentHeight;
      if (Math.abs(diff2) < 0.5) {
        this.resizeState.animationId = null;
        return;
      }
      this.resizeState.currentHeight += diff2 * this.ANIMATION_SPEED;
      this.resizeState.element.style.height = `${this.resizeState.currentHeight}px`;
      this.updateTimestampDisplay();
      this.resizeState.animationId = requestAnimationFrame(this.animateHeight);
    };
    this.handlePointerUp = (e) => {
      if (!this.resizeState)
        return;
      if (this.resizeState.animationId !== null) {
        cancelAnimationFrame(this.resizeState.animationId);
      }
      try {
        this.resizeState.handleElement.releasePointerCapture(e.pointerId);
      } catch (err) {
        console.warn("Pointer release failed:", err);
      }
      this.snapToGridFinal();
      this.updateTimestampDisplay();
      const container2 = this.resizeState.element.closest("swp-event-group") ?? this.resizeState.element;
      container2.style.zIndex = this.resizeState.prevZIndex;
      document.documentElement.classList.remove("swp--resizing");
      const column = this.resizeState.element.closest("swp-day-column");
      const columnKey = column?.dataset.columnKey || "";
      const date = column?.dataset.date || "";
      const swpEvent = SwpEvent.fromElement(this.resizeState.element, columnKey, date, this.gridConfig);
      this.eventBus.emit(CoreEvents.EVENT_RESIZE_END, {
        swpEvent
      });
      this.resizeState = null;
    };
  }
  /**
   * Initialize resize functionality on container
   */
  init(container2) {
    this.container = container2;
    container2.addEventListener("mouseover", this.handleMouseOver, true);
    document.addEventListener("pointerdown", this.handlePointerDown, true);
    document.addEventListener("pointermove", this.handlePointerMove, true);
    document.addEventListener("pointerup", this.handlePointerUp, true);
  }
  /**
   * Create resize handle element
   */
  createResizeHandle() {
    const handle = document.createElement("swp-resize-handle");
    handle.setAttribute("aria-label", "Resize event");
    handle.setAttribute("role", "separator");
    return handle;
  }
  /**
   * Update timestamp display with snapped end time
   */
  updateTimestampDisplay() {
    if (!this.resizeState)
      return;
    const timeEl = this.resizeState.element.querySelector("swp-event-time");
    if (!timeEl)
      return;
    const top = parseFloat(this.resizeState.element.style.top) || 0;
    const startMinutesFromGrid = pixelsToMinutes(top, this.gridConfig);
    const startMinutes = this.gridConfig.dayStartHour * 60 + startMinutesFromGrid;
    const snappedHeight = snapToGrid(this.resizeState.currentHeight, this.gridConfig);
    const durationMinutes = pixelsToMinutes(snappedHeight, this.gridConfig);
    const endMinutes = startMinutes + durationMinutes;
    const start = this.minutesToDate(startMinutes);
    const end = this.minutesToDate(endMinutes);
    timeEl.textContent = this.dateService.formatTimeRange(start, end);
  }
  /**
   * Convert minutes since midnight to Date
   */
  minutesToDate(minutes) {
    const date = /* @__PURE__ */ new Date();
    date.setHours(Math.floor(minutes / 60) % 24, minutes % 60, 0, 0);
    return date;
  }
  /**
   * Snap final height to grid interval
   */
  snapToGridFinal() {
    if (!this.resizeState)
      return;
    const currentHeight = this.resizeState.element.offsetHeight;
    const snappedHeight = snapToGrid(currentHeight, this.gridConfig);
    const minHeight = minutesToPixels(this.MIN_HEIGHT_MINUTES, this.gridConfig);
    const finalHeight = Math.max(minHeight, snappedHeight);
    this.resizeState.element.style.height = `${finalHeight}px`;
    this.resizeState.currentHeight = finalHeight;
  }
};
__name(_ResizeManager, "ResizeManager");
var ResizeManager = _ResizeManager;

// src/managers/EventPersistenceManager.ts
var _EventPersistenceManager = class _EventPersistenceManager {
  constructor(eventService, eventBus, dateService) {
    this.eventService = eventService;
    this.eventBus = eventBus;
    this.dateService = dateService;
    this.handleDragEnd = async (e) => {
      const payload = e.detail;
      const { swpEvent } = payload;
      const event = await this.eventService.get(swpEvent.eventId);
      if (!event) {
        console.warn(`EventPersistenceManager: Event ${swpEvent.eventId} not found`);
        return;
      }
      const { resource } = this.dateService.parseColumnKey(swpEvent.columnKey);
      const updatedEvent = {
        ...event,
        start: swpEvent.start,
        end: swpEvent.end,
        resourceId: resource ?? event.resourceId,
        allDay: payload.target === "header",
        syncStatus: "pending"
      };
      await this.eventService.save(updatedEvent);
      const updatePayload = {
        eventId: updatedEvent.id,
        sourceColumnKey: payload.sourceColumnKey,
        targetColumnKey: swpEvent.columnKey
      };
      this.eventBus.emit(CoreEvents.EVENT_UPDATED, updatePayload);
    };
    this.handleResizeEnd = async (e) => {
      const payload = e.detail;
      const { swpEvent } = payload;
      const event = await this.eventService.get(swpEvent.eventId);
      if (!event) {
        console.warn(`EventPersistenceManager: Event ${swpEvent.eventId} not found`);
        return;
      }
      const updatedEvent = {
        ...event,
        end: swpEvent.end,
        syncStatus: "pending"
      };
      await this.eventService.save(updatedEvent);
      const updatePayload = {
        eventId: updatedEvent.id,
        sourceColumnKey: swpEvent.columnKey,
        targetColumnKey: swpEvent.columnKey
      };
      this.eventBus.emit(CoreEvents.EVENT_UPDATED, updatePayload);
    };
    this.setupListeners();
  }
  setupListeners() {
    this.eventBus.on(CoreEvents.EVENT_DRAG_END, this.handleDragEnd);
    this.eventBus.on(CoreEvents.EVENT_RESIZE_END, this.handleResizeEnd);
  }
};
__name(_EventPersistenceManager, "EventPersistenceManager");
var EventPersistenceManager = _EventPersistenceManager;

// src/CompositionRoot.ts
var defaultTimeFormatConfig = {
  timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
  use24HourFormat: true,
  locale: "da-DK",
  dateFormat: "locale",
  showSeconds: false
};
var defaultGridConfig = {
  hourHeight: 64,
  dayStartHour: 6,
  dayEndHour: 18,
  snapInterval: 15,
  gridStartThresholdMinutes: 30
};
function createContainer() {
  const container2 = new Container();
  const builder = container2.builder();
  builder.registerInstance(defaultTimeFormatConfig).as("ITimeFormatConfig");
  builder.registerInstance(defaultGridConfig).as("IGridConfig");
  builder.registerType(EventBus).as("EventBus");
  builder.registerType(EventBus).as("IEventBus");
  builder.registerType(DateService).as("DateService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("ITimeFormatConfig"),
      void 0
    ]
  });
  builder.registerType(IndexedDBContext).as("IndexedDBContext").autoWire({
    mapResolvers: [
      (c) => c.resolveTypeAll("IStore")
    ]
  });
  builder.registerType(EventStore).as("IStore");
  builder.registerType(ResourceStore).as("IStore");
  builder.registerType(BookingStore).as("IStore");
  builder.registerType(CustomerStore).as("IStore");
  builder.registerType(TeamStore).as("IStore");
  builder.registerType(DepartmentStore).as("IStore");
  builder.registerType(ScheduleOverrideStore).as("IStore");
  builder.registerType(AuditStore).as("IStore");
  builder.registerType(SettingsStore).as("IStore");
  builder.registerType(ViewConfigStore).as("IStore");
  builder.registerType(EventService).as("IEntityService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(EventService).as("IEntityService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(EventService).as("EventService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(ResourceService).as("IEntityService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(ResourceService).as("IEntityService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(ResourceService).as("ResourceService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(BookingService).as("IEntityService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(BookingService).as("IEntityService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(BookingService).as("BookingService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(CustomerService).as("IEntityService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(CustomerService).as("IEntityService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(CustomerService).as("CustomerService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(TeamService).as("IEntityService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(TeamService).as("IEntityService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(TeamService).as("TeamService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(DepartmentService).as("IEntityService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(DepartmentService).as("IEntityService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(DepartmentService).as("DepartmentService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(SettingsService).as("IEntityService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(SettingsService).as("IEntityService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(SettingsService).as("SettingsService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(ViewConfigService).as("IEntityService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(ViewConfigService).as("IEntityService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(ViewConfigService).as("ViewConfigService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(MockEventRepository).as("IApiRepository");
  builder.registerType(MockEventRepository).as("IApiRepository");
  builder.registerType(MockResourceRepository).as("IApiRepository");
  builder.registerType(MockResourceRepository).as("IApiRepository");
  builder.registerType(MockBookingRepository).as("IApiRepository");
  builder.registerType(MockBookingRepository).as("IApiRepository");
  builder.registerType(MockCustomerRepository).as("IApiRepository");
  builder.registerType(MockCustomerRepository).as("IApiRepository");
  builder.registerType(MockAuditRepository).as("IApiRepository");
  builder.registerType(MockAuditRepository).as("IApiRepository");
  builder.registerType(MockTeamRepository).as("IApiRepository");
  builder.registerType(MockTeamRepository).as("IApiRepository");
  builder.registerType(MockDepartmentRepository).as("IApiRepository");
  builder.registerType(MockDepartmentRepository).as("IApiRepository");
  builder.registerType(MockSettingsRepository).as("IApiRepository");
  builder.registerType(MockSettingsRepository).as("IApiRepository");
  builder.registerType(MockViewConfigRepository).as("IApiRepository");
  builder.registerType(MockViewConfigRepository).as("IApiRepository");
  builder.registerType(AuditService).as("AuditService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(DataSeeder).as("DataSeeder").autoWire({
    mapResolvers: [
      (c) => c.resolveTypeAll("IEntityService"),
      (c) => c.resolveTypeAll("IApiRepository")
    ]
  });
  builder.registerType(ScheduleOverrideService).as("ScheduleOverrideService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext")
    ]
  });
  builder.registerType(ResourceScheduleService).as("ResourceScheduleService").autoWire({
    mapResolvers: [
      (c) => c.resolveType("ResourceService"),
      (c) => c.resolveType("ScheduleOverrideService"),
      (c) => c.resolveType("DateService")
    ]
  });
  builder.registerType(EventRenderer).as("EventRenderer").autoWire({
    mapResolvers: [
      (c) => c.resolveType("EventService"),
      (c) => c.resolveType("DateService"),
      (c) => c.resolveType("IGridConfig"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(ScheduleRenderer).as("ScheduleRenderer").autoWire({
    mapResolvers: [
      (c) => c.resolveType("ResourceScheduleService"),
      (c) => c.resolveType("DateService"),
      (c) => c.resolveType("IGridConfig")
    ]
  });
  builder.registerType(HeaderDrawerRenderer).as("HeaderDrawerRenderer").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IEventBus"),
      (c) => c.resolveType("IGridConfig"),
      (c) => c.resolveType("HeaderDrawerManager"),
      (c) => c.resolveType("EventService"),
      (c) => c.resolveType("DateService")
    ]
  });
  builder.registerType(DateRenderer).as("IRenderer").autoWire({
    mapResolvers: [
      (c) => c.resolveType("DateService")
    ]
  });
  builder.registerType(ResourceRenderer).as("IRenderer").autoWire({
    mapResolvers: [
      (c) => c.resolveType("ResourceService")
    ]
  });
  builder.registerType(TeamRenderer).as("IRenderer").autoWire({
    mapResolvers: [
      (c) => c.resolveType("TeamService")
    ]
  });
  builder.registerType(DepartmentRenderer).as("IRenderer").autoWire({
    mapResolvers: [
      (c) => c.resolveType("DepartmentService")
    ]
  });
  builder.registerType(MockTeamStore).as("IGroupingStore");
  builder.registerType(MockResourceStore).as("IGroupingStore");
  builder.registerType(CalendarOrchestrator).as("CalendarOrchestrator").autoWire({
    mapResolvers: [
      (c) => c.resolveTypeAll("IRenderer"),
      (c) => c.resolveType("EventRenderer"),
      (c) => c.resolveType("ScheduleRenderer"),
      (c) => c.resolveType("HeaderDrawerRenderer"),
      (c) => c.resolveType("DateService"),
      (c) => c.resolveTypeAll("IEntityService")
    ]
  });
  builder.registerType(TimeAxisRenderer).as("TimeAxisRenderer");
  builder.registerType(ScrollManager).as("ScrollManager");
  builder.registerType(HeaderDrawerManager).as("HeaderDrawerManager");
  builder.registerType(DragDropManager).as("DragDropManager").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IEventBus"),
      (c) => c.resolveType("IGridConfig")
    ]
  });
  builder.registerType(EdgeScrollManager).as("EdgeScrollManager").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(ResizeManager).as("ResizeManager").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IEventBus"),
      (c) => c.resolveType("IGridConfig"),
      (c) => c.resolveType("DateService")
    ]
  });
  builder.registerType(EventPersistenceManager).as("EventPersistenceManager").autoWire({
    mapResolvers: [
      (c) => c.resolveType("EventService"),
      (c) => c.resolveType("IEventBus"),
      (c) => c.resolveType("DateService")
    ]
  });
  builder.registerType(CalendarApp).as("CalendarApp").autoWire({
    mapResolvers: [
      (c) => c.resolveType("CalendarOrchestrator"),
      (c) => c.resolveType("TimeAxisRenderer"),
      (c) => c.resolveType("DateService"),
      (c) => c.resolveType("ScrollManager"),
      (c) => c.resolveType("HeaderDrawerManager"),
      (c) => c.resolveType("DragDropManager"),
      (c) => c.resolveType("EdgeScrollManager"),
      (c) => c.resolveType("ResizeManager"),
      (c) => c.resolveType("HeaderDrawerRenderer"),
      (c) => c.resolveType("EventPersistenceManager"),
      (c) => c.resolveType("SettingsService"),
      (c) => c.resolveType("ViewConfigService"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  builder.registerType(DemoApp).as("DemoApp").autoWire({
    mapResolvers: [
      (c) => c.resolveType("IndexedDBContext"),
      (c) => c.resolveType("DataSeeder"),
      (c) => c.resolveType("AuditService"),
      (c) => c.resolveType("CalendarApp"),
      (c) => c.resolveType("DateService"),
      (c) => c.resolveType("ResourceService"),
      (c) => c.resolveType("IEventBus")
    ]
  });
  return builder.build();
}
__name(createContainer, "createContainer");

// src/demo/index.ts
var container = createContainer();
container.resolveType("DemoApp").init().catch(console.error);
//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../node_modules/dayjs/dayjs.min.js", "../../node_modules/dayjs/plugin/utc.js", "../../node_modules/dayjs/plugin/timezone.js", "../../node_modules/dayjs/plugin/isoWeek.js", "../../node_modules/@novadi/core/dist/token.js", "../../node_modules/@novadi/core/dist/errors.js", "../../node_modules/@novadi/core/dist/autowire.js", "../../node_modules/@novadi/core/dist/builder.js", "../../node_modules/@novadi/core/dist/container.js", "../../src/features/date/DateRenderer.ts", "../../src/core/DateService.ts", "../../src/core/BaseGroupingRenderer.ts", "../../src/features/resource/ResourceRenderer.ts", "../../src/features/team/TeamRenderer.ts", "../../src/features/department/DepartmentRenderer.ts", "../../src/core/RenderBuilder.ts", "../../src/core/FilterTemplate.ts", "../../src/core/CalendarOrchestrator.ts", "../../src/core/NavigationAnimator.ts", "../../src/core/CalendarEvents.ts", "../../src/core/CalendarApp.ts", "../../src/features/timeaxis/TimeAxisRenderer.ts", "../../src/core/ScrollManager.ts", "../../src/core/HeaderDrawerManager.ts", "../../src/demo/MockStores.ts", "../../src/demo/DemoApp.ts", "../../src/core/EventBus.ts", "../../src/storage/IndexedDBContext.ts", "../../src/storage/events/EventStore.ts", "../../src/storage/events/EventSerialization.ts", "../../src/storage/SyncPlugin.ts", "../../src/constants/CoreEvents.ts", "../../node_modules/json-diff-ts/src/helpers.ts", "../../node_modules/json-diff-ts/src/jsonDiff.ts", "../../node_modules/json-diff-ts/src/jsonCompare.ts", "../../src/storage/BaseEntityService.ts", "../../src/storage/events/EventService.ts", "../../src/storage/resources/ResourceStore.ts", "../../src/storage/resources/ResourceService.ts", "../../src/storage/bookings/BookingStore.ts", "../../src/storage/bookings/BookingService.ts", "../../src/storage/customers/CustomerStore.ts", "../../src/storage/customers/CustomerService.ts", "../../src/storage/teams/TeamStore.ts", "../../src/storage/teams/TeamService.ts", "../../src/storage/departments/DepartmentStore.ts", "../../src/storage/departments/DepartmentService.ts", "../../src/storage/settings/SettingsStore.ts", "../../src/types/SettingsTypes.ts", "../../src/storage/settings/SettingsService.ts", "../../src/storage/viewconfigs/ViewConfigStore.ts", "../../src/storage/viewconfigs/ViewConfigService.ts", "../../src/storage/audit/AuditStore.ts", "../../src/storage/audit/AuditService.ts", "../../src/repositories/MockEventRepository.ts", "../../src/repositories/MockResourceRepository.ts", "../../src/repositories/MockBookingRepository.ts", "../../src/repositories/MockCustomerRepository.ts", "../../src/repositories/MockAuditRepository.ts", "../../src/repositories/MockTeamRepository.ts", "../../src/repositories/MockDepartmentRepository.ts", "../../src/repositories/MockSettingsRepository.ts", "../../src/repositories/MockViewConfigRepository.ts", "../../src/workers/DataSeeder.ts", "../../src/utils/PositionUtils.ts", "../../src/features/event/EventLayoutEngine.ts", "../../src/features/event/EventRenderer.ts", "../../src/features/schedule/ScheduleRenderer.ts", "../../src/features/headerdrawer/HeaderDrawerRenderer.ts", "../../src/storage/schedules/ScheduleOverrideStore.ts", "../../src/storage/schedules/ScheduleOverrideService.ts", "../../src/storage/schedules/ResourceScheduleService.ts", "../../src/types/SwpEvent.ts", "../../src/managers/DragDropManager.ts", "../../src/managers/EdgeScrollManager.ts", "../../src/managers/ResizeManager.ts", "../../src/managers/EventPersistenceManager.ts", "../../src/CompositionRoot.ts", "../../src/demo/index.ts"],
  "sourcesContent": ["!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()}(this,(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=/\\[([^\\]]+)]|Y{1,4}|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(t){var e=[\"th\",\"st\",\"nd\",\"rd\"],n=t%100;return\"[\"+t+(e[(n-20)%10]||e[n]||e[0])+\"]\"}},m=function(t,e,n){var r=String(t);return!r||r.length>=e?t:\"\"+Array(e+1-r.length).join(n)+t},v={s:m,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return(e<=0?\"+\":\"-\")+m(r,2,\"0\")+\":\"+m(i,2,\"0\")},m:function t(e,n){if(e.date()<n.date())return-t(n,e);var r=12*(n.year()-e.year())+(n.month()-e.month()),i=e.clone().add(r,c),s=n-i<0,u=e.clone().add(r+(s?-1:1),c);return+(-(r+(n-i)/(s?i-u:u-i))||0)},a:function(t){return t<0?Math.ceil(t)||0:Math.floor(t)},p:function(t){return{M:c,y:h,w:o,d:a,D:d,h:u,m:s,s:i,ms:r,Q:f}[t]||String(t||\"\").toLowerCase().replace(/s$/,\"\")},u:function(t){return void 0===t}},g=\"en\",D={};D[g]=M;var p=\"$isDayjsObject\",S=function(t){return t instanceof _||!(!t||!t[p])},w=function t(e,n,r){var i;if(!e)return g;if(\"string\"==typeof e){var s=e.toLowerCase();D[s]&&(i=s),n&&(D[s]=n,i=s);var u=e.split(\"-\");if(!i&&u.length>1)return t(u[0])}else{var a=e.name;D[a]=e,i=a}return!r&&i&&(g=i),i||!r&&g},O=function(t,e){if(S(t))return t.clone();var n=\"object\"==typeof e?e:{};return n.date=t,n.args=arguments,new _(n)},b=v;b.l=w,b.i=S,b.w=function(t,e){return O(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var _=function(){function M(t){this.$L=w(t.locale,null,!0),this.parse(t),this.$x=this.$x||t.x||{},this[p]=!0}var m=M.prototype;return m.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(b.u(e))return new Date;if(e instanceof Date)return new Date(e);if(\"string\"==typeof e&&!/Z$/i.test(e)){var r=e.match($);if(r){var i=r[2]-1||0,s=(r[7]||\"0\").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)}}return new Date(e)}(t),this.init()},m.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds()},m.$utils=function(){return b},m.isValid=function(){return!(this.$d.toString()===l)},m.isSame=function(t,e){var n=O(t);return this.startOf(e)<=n&&n<=this.endOf(e)},m.isAfter=function(t,e){return O(t)<this.startOf(e)},m.isBefore=function(t,e){return this.endOf(e)<O(t)},m.$g=function(t,e,n){return b.u(t)?this[e]:this.set(n,t)},m.unix=function(){return Math.floor(this.valueOf()/1e3)},m.valueOf=function(){return this.$d.getTime()},m.startOf=function(t,e){var n=this,r=!!b.u(e)||e,f=b.p(t),l=function(t,e){var i=b.w(n.$u?Date.UTC(n.$y,e,t):new Date(n.$y,e,t),n);return r?i:i.endOf(a)},$=function(t,e){return b.w(n.toDate()[t].apply(n.toDate(\"s\"),(r?[0,0,0,0]:[23,59,59,999]).slice(e)),n)},y=this.$W,M=this.$M,m=this.$D,v=\"set\"+(this.$u?\"UTC\":\"\");switch(f){case h:return r?l(1,0):l(31,11);case c:return r?l(1,M):l(0,M+1);case o:var g=this.$locale().weekStart||0,D=(y<g?y+7:y)-g;return l(r?m-D:m+(6-D),M);case a:case d:return $(v+\"Hours\",0);case u:return $(v+\"Minutes\",1);case s:return $(v+\"Seconds\",2);case i:return $(v+\"Milliseconds\",3);default:return this.clone()}},m.endOf=function(t){return this.startOf(t,!1)},m.$set=function(t,e){var n,o=b.p(t),f=\"set\"+(this.$u?\"UTC\":\"\"),l=(n={},n[a]=f+\"Date\",n[d]=f+\"Date\",n[c]=f+\"Month\",n[h]=f+\"FullYear\",n[u]=f+\"Hours\",n[s]=f+\"Minutes\",n[i]=f+\"Seconds\",n[r]=f+\"Milliseconds\",n)[o],$=o===a?this.$D+(e-this.$W):e;if(o===c||o===h){var y=this.clone().set(d,1);y.$d[l]($),y.init(),this.$d=y.set(d,Math.min(this.$D,y.daysInMonth())).$d}else l&&this.$d[l]($);return this.init(),this},m.set=function(t,e){return this.clone().$set(t,e)},m.get=function(t){return this[b.p(t)]()},m.add=function(r,f){var d,l=this;r=Number(r);var $=b.p(f),y=function(t){var e=O(l);return b.w(e.date(e.date()+Math.round(t*r)),l)};if($===c)return this.set(c,this.$M+r);if($===h)return this.set(h,this.$y+r);if($===a)return y(1);if($===o)return y(7);var M=(d={},d[s]=e,d[u]=n,d[i]=t,d)[$]||1,m=this.$d.getTime()+r*M;return b.w(m,this)},m.subtract=function(t,e){return this.add(-1*t,e)},m.format=function(t){var e=this,n=this.$locale();if(!this.isValid())return n.invalidDate||l;var r=t||\"YYYY-MM-DDTHH:mm:ssZ\",i=b.z(this),s=this.$H,u=this.$m,a=this.$M,o=n.weekdays,c=n.months,f=n.meridiem,h=function(t,n,i,s){return t&&(t[n]||t(e,r))||i[n].slice(0,s)},d=function(t){return b.s(s%12||12,t,\"0\")},$=f||function(t,e,n){var r=t<12?\"AM\":\"PM\";return n?r.toLowerCase():r};return r.replace(y,(function(t,r){return r||function(t){switch(t){case\"YY\":return String(e.$y).slice(-2);case\"YYYY\":return b.s(e.$y,4,\"0\");case\"M\":return a+1;case\"MM\":return b.s(a+1,2,\"0\");case\"MMM\":return h(n.monthsShort,a,c,3);case\"MMMM\":return h(c,a);case\"D\":return e.$D;case\"DD\":return b.s(e.$D,2,\"0\");case\"d\":return String(e.$W);case\"dd\":return h(n.weekdaysMin,e.$W,o,2);case\"ddd\":return h(n.weekdaysShort,e.$W,o,3);case\"dddd\":return o[e.$W];case\"H\":return String(s);case\"HH\":return b.s(s,2,\"0\");case\"h\":return d(1);case\"hh\":return d(2);case\"a\":return $(s,u,!0);case\"A\":return $(s,u,!1);case\"m\":return String(u);case\"mm\":return b.s(u,2,\"0\");case\"s\":return String(e.$s);case\"ss\":return b.s(e.$s,2,\"0\");case\"SSS\":return b.s(e.$ms,3,\"0\");case\"Z\":return i}return null}(t)||i.replace(\":\",\"\")}))},m.utcOffset=function(){return 15*-Math.round(this.$d.getTimezoneOffset()/15)},m.diff=function(r,d,l){var $,y=this,M=b.p(d),m=O(r),v=(m.utcOffset()-this.utcOffset())*e,g=this-m,D=function(){return b.m(y,m)};switch(M){case h:$=D()/12;break;case c:$=D();break;case f:$=D()/3;break;case o:$=(g-v)/6048e5;break;case a:$=(g-v)/864e5;break;case u:$=g/n;break;case s:$=g/e;break;case i:$=g/t;break;default:$=g}return l?$:b.a($)},m.daysInMonth=function(){return this.endOf(c).$D},m.$locale=function(){return D[this.$L]},m.locale=function(t,e){if(!t)return this.$L;var n=this.clone(),r=w(t,e,!0);return r&&(n.$L=r),n},m.clone=function(){return b.w(this.$d,this)},m.toDate=function(){return new Date(this.valueOf())},m.toJSON=function(){return this.isValid()?this.toISOString():null},m.toISOString=function(){return this.$d.toISOString()},m.toString=function(){return this.$d.toUTCString()},M}(),k=_.prototype;return O.prototype=k,[[\"$ms\",r],[\"$s\",i],[\"$m\",s],[\"$H\",u],[\"$W\",a],[\"$M\",c],[\"$y\",h],[\"$D\",d]].forEach((function(t){k[t[1]]=function(e){return this.$g(e,t[0],t[1])}})),O.extend=function(t,e){return t.$i||(t(e,_,O),t.$i=!0),O},O.locale=w,O.isDayjs=S,O.unix=function(t){return O(1e3*t)},O.en=D[g],O.Ls=D,O.p={},O}));", "!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()}(this,(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(t){var i={date:t,utc:!0,args:arguments};return new f(i)},u.utc=function(i){var e=n(this.toDate(),{locale:this.$L,utc:!0});return i?e.add(this.utcOffset(),t):e},u.local=function(){return n(this.toDate(),{locale:this.$L,utc:!1})};var r=u.parse;u.parse=function(t){t.utc&&(this.$u=!0),this.$utils().u(t.$offset)||(this.$offset=t.$offset),r.call(this,t)};var o=u.init;u.init=function(){if(this.$u){var t=this.$d;this.$y=t.getUTCFullYear(),this.$M=t.getUTCMonth(),this.$D=t.getUTCDate(),this.$W=t.getUTCDay(),this.$H=t.getUTCHours(),this.$m=t.getUTCMinutes(),this.$s=t.getUTCSeconds(),this.$ms=t.getUTCMilliseconds()}else o.call(this)};var a=u.utcOffset;u.utcOffset=function(s,f){var n=this.$utils().u;if(n(s))return this.$u?0:n(this.$offset)?a.call(this):this.$offset;if(\"string\"==typeof s&&(s=function(t){void 0===t&&(t=\"\");var s=t.match(i);if(!s)return null;var f=(\"\"+s[0]).match(e)||[\"-\",0,0],n=f[0],u=60*+f[1]+ +f[2];return 0===u?0:\"+\"===n?u:-u}(s),null===s))return this;var u=Math.abs(s)<=16?60*s:s;if(0===u)return this.utc(f);var r=this.clone();if(f)return r.$offset=u,r.$u=!1,r;var o=this.$u?this.toDate().getTimezoneOffset():-1*this.utcOffset();return(r=this.local().add(u+o,t)).$offset=u,r.$x.$localOffset=o,r};var h=u.format;u.format=function(t){var i=t||(this.$u?\"YYYY-MM-DDTHH:mm:ss[Z]\":\"\");return h.call(this,i)},u.valueOf=function(){var t=this.$utils().u(this.$offset)?0:this.$offset+(this.$x.$localOffset||this.$d.getTimezoneOffset());return this.$d.valueOf()-6e4*t},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(t){return\"s\"===t&&this.$offset?n(this.format(\"YYYY-MM-DD HH:mm:ss:SSS\")).toDate():l.call(this)};var c=u.diff;u.diff=function(t,i,e){if(t&&this.$u===t.$u)return c.call(this,t,i,e);var s=this.local(),f=n(t).local();return c.call(s,f,i,e)}}}));", "!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()}(this,(function(){\"use strict\";var t={year:0,month:1,day:2,hour:3,minute:4,second:5},e={};return function(n,i,o){var r,a=function(t,n,i){void 0===i&&(i={});var o=new Date(t),r=function(t,n){void 0===n&&(n={});var i=n.timeZoneName||\"short\",o=t+\"|\"+i,r=e[o];return r||(r=new Intl.DateTimeFormat(\"en-US\",{hour12:!1,timeZone:t,year:\"numeric\",month:\"2-digit\",day:\"2-digit\",hour:\"2-digit\",minute:\"2-digit\",second:\"2-digit\",timeZoneName:i}),e[o]=r),r}(n,i);return r.formatToParts(o)},u=function(e,n){for(var i=a(e,n),r=[],u=0;u<i.length;u+=1){var f=i[u],s=f.type,m=f.value,c=t[s];c>=0&&(r[c]=parseInt(m,10))}var d=r[3],l=24===d?0:d,h=r[0]+\"-\"+r[1]+\"-\"+r[2]+\" \"+l+\":\"+r[4]+\":\"+r[5]+\":000\",v=+e;return(o.utc(h).valueOf()-(v-=v%1e3))/6e4},f=i.prototype;f.tz=function(t,e){void 0===t&&(t=r);var n,i=this.utcOffset(),a=this.toDate(),u=a.toLocaleString(\"en-US\",{timeZone:t}),f=Math.round((a-new Date(u))/1e3/60),s=15*-Math.round(a.getTimezoneOffset()/15)-f;if(!Number(s))n=this.utcOffset(0,e);else if(n=o(u,{locale:this.$L}).$set(\"millisecond\",this.$ms).utcOffset(s,!0),e){var m=n.utcOffset();n=n.add(i-m,\"minute\")}return n.$x.$timezone=t,n},f.offsetName=function(t){var e=this.$x.$timezone||o.tz.guess(),n=a(this.valueOf(),e,{timeZoneName:t}).find((function(t){return\"timezonename\"===t.type.toLowerCase()}));return n&&n.value};var s=f.startOf;f.startOf=function(t,e){if(!this.$x||!this.$x.$timezone)return s.call(this,t,e);var n=o(this.format(\"YYYY-MM-DD HH:mm:ss:SSS\"),{locale:this.$L});return s.call(n,t,e).tz(this.$x.$timezone,!0)},o.tz=function(t,e,n){var i=n&&e,a=n||e||r,f=u(+o(),a);if(\"string\"!=typeof t)return o(t).tz(a);var s=function(t,e,n){var i=t-60*e*1e3,o=u(i,n);if(e===o)return[i,e];var r=u(i-=60*(o-e)*1e3,n);return o===r?[i,o]:[t-60*Math.min(o,r)*1e3,Math.max(o,r)]}(o.utc(t,i).valueOf(),f,a),m=s[0],c=s[1],d=o(m).utcOffset(c);return d.$x.$timezone=a,d},o.tz.guess=function(){return Intl.DateTimeFormat().resolvedOptions().timeZone},o.tz.setDefault=function(t){r=t}}}));", "!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_isoWeek=t()}(this,(function(){\"use strict\";var e=\"day\";return function(t,i,s){var a=function(t){return t.add(4-t.isoWeekday(),e)},d=i.prototype;d.isoWeekYear=function(){return a(this).year()},d.isoWeek=function(t){if(!this.$utils().u(t))return this.add(7*(t-this.isoWeek()),e);var i,d,n,o,r=a(this),u=(i=this.isoWeekYear(),d=this.$u,n=(d?s.utc:s)().year(i).startOf(\"year\"),o=4-n.isoWeekday(),n.isoWeekday()>4&&(o+=7),n.add(o,e));return r.diff(u,\"week\")+1},d.isoWeekday=function(e){return this.$utils().u(e)?this.day()||7:this.day(this.day()%7?e:e-7)};var n=d.startOf;d.startOf=function(e,t){var i=this.$utils(),s=!!i.u(t)||t;return\"isoweek\"===i.p(e)?s?this.date(this.date()-(this.isoWeekday()-1)).startOf(\"day\"):this.date(this.date()-1-(this.isoWeekday()-1)+7).endOf(\"day\"):n.bind(this)(e,t)}}}));", "let tokenCounter = 0;\n/**\n * Creates a new unique token for dependency injection.\n *\n * @param description Optional description for debugging purposes\n * @returns A unique token that can be used as a Map key\n *\n * @example\n * ```ts\n * interface ILogger { log(msg: string): void }\n * const LoggerToken = Token<ILogger>('Logger')\n * ```\n */\nexport function Token(description) {\n    const id = ++tokenCounter;\n    const sym = Symbol(description ? `Token(${description})` : `Token#${id}`);\n    const token = {\n        symbol: sym,\n        description,\n        toString() {\n            return description\n                ? `Token<${description}>`\n                : `Token<#${id}>`;\n        }\n    };\n    return token;\n}\n/**\n * Creates a new unique token without a string literal.\n * Preferred for Autofac-style DI to avoid string literals.\n *\n * @returns A unique token that can be used as a Map key\n *\n * @example\n * ```ts\n * interface ILogger { log(msg: string): void }\n * const LoggerToken = token<ILogger>()\n * ```\n */\nexport function token() {\n    return Token();\n}\n", "/**\n * Error classes for NovaDI container\n */\nexport class ContainerError extends Error {\n    constructor(message) {\n        super(message);\n        this.name = 'ContainerError';\n    }\n}\nexport class BindingNotFoundError extends ContainerError {\n    constructor(tokenDescription, path = []) {\n        const pathStr = path.length > 0 ? `\\n  Dependency path: ${path.join(' -> ')}` : '';\n        super(`Token \"${tokenDescription}\" is not bound or registered in the container.${pathStr}`);\n        this.name = 'BindingNotFoundError';\n    }\n}\nexport class CircularDependencyError extends ContainerError {\n    constructor(path) {\n        super(`Circular dependency detected: ${path.join(' -> ')}`);\n        this.name = 'CircularDependencyError';\n    }\n}\n", "/**\n * AutoWire - Automatic dependency injection for NovaDI\n * Supports two strategies: mapResolvers (transformer-generated) and map (manual override)\n */\n/**\n * Performance: Cache extracted parameter names to avoid repeated regex parsing\n * WeakMap allows garbage collection when constructor is no longer referenced\n */\nconst paramNameCache = new WeakMap();\n/**\n * Extract parameter names from a constructor function\n * Uses regex to parse the toString() representation\n * Performance optimized: Results are cached per constructor\n *\n * Note: Only used by resolveByMap() for manual map strategy\n */\nexport function extractParameterNames(constructor) {\n    // Check cache first - avoids expensive regex parsing\n    const cached = paramNameCache.get(constructor);\n    if (cached) {\n        return cached;\n    }\n    // Extract parameter names (expensive operation)\n    const fnStr = constructor.toString();\n    // Match constructor(...args) or class { constructor(...args) }\n    const match = fnStr.match(/constructor\\s*\\(([^)]*)\\)/) || fnStr.match(/^[^(]*\\(([^)]*)\\)/);\n    if (!match || !match[1]) {\n        return [];\n    }\n    const params = match[1]\n        .split(',')\n        .map(param => param.trim())\n        .filter(param => param.length > 0)\n        .map(param => {\n        // Remove default values, type annotations, and extract just the name\n        let name = param.split(/[:=]/)[0].trim();\n        // Remove TypeScript modifiers (public, private, protected, readonly)\n        // Can appear multiple times, e.g., \"public readonly service\"\n        name = name.replace(/^((public|private|protected|readonly)\\s+)+/, '');\n        // Handle destructuring - skip for now\n        if (name.includes('{') || name.includes('[')) {\n            return null;\n        }\n        return name;\n    })\n        .filter((name) => name !== null);\n    // Cache result for future calls\n    paramNameCache.set(constructor, params);\n    return params;\n}\n/**\n * Resolve dependencies using map strategy\n * Uses explicit mapping from parameter names to resolvers\n */\nexport function resolveByMap(constructor, container, options) {\n    if (!options.map) {\n        throw new Error('AutoWire map strategy requires options.map to be defined');\n    }\n    const paramNames = extractParameterNames(constructor);\n    const resolvedDeps = [];\n    for (const paramName of paramNames) {\n        const resolver = options.map[paramName];\n        if (resolver === undefined) {\n            if (options.strict) {\n                throw new Error(`Cannot resolve parameter \"${paramName}\" on ${constructor.name}. ` +\n                    `Not found in autowire map. ` +\n                    `Add it to the map: .autoWire({ map: { ${paramName}: ... } })`);\n            }\n            else {\n                // Silently push undefined for missing parameters\n                // This is expected: transformer filters out primitive types at compile-time,\n                // so missing params are typically primitives that don't need DI resolution\n                resolvedDeps.push(undefined);\n            }\n            continue;\n        }\n        // Resolver can be a function or a Token\n        if (typeof resolver === 'function') {\n            resolvedDeps.push(resolver(container));\n        }\n        else {\n            // Assume it's a Token\n            resolvedDeps.push(container.resolve(resolver));\n        }\n    }\n    return resolvedDeps;\n}\n/**\n * Resolve dependencies using mapResolvers array strategy\n * OPTIMAL PERFORMANCE: O(1) array access per parameter\n * Minification-safe: Uses position-based array\n * Refactoring-friendly: Transformer regenerates array on recompile\n *\n * Requires build-time transformer to generate mapResolvers array\n */\nexport function resolveByMapResolvers(_constructor, container, options) {\n    if (!options.mapResolvers || options.mapResolvers.length === 0) {\n        return [];\n    }\n    const resolvedDeps = [];\n    // Simple O(1) array access - ultra fast!\n    for (let i = 0; i < options.mapResolvers.length; i++) {\n        const resolver = options.mapResolvers[i];\n        if (resolver === undefined) {\n            // undefined indicates primitive type or parameter without DI\n            resolvedDeps.push(undefined);\n        }\n        else if (typeof resolver === 'function') {\n            // Resolver function: (c) => c.resolveType(...)\n            resolvedDeps.push(resolver(container));\n        }\n        else {\n            // Token-based resolution\n            resolvedDeps.push(container.resolve(resolver));\n        }\n    }\n    return resolvedDeps;\n}\n/**\n * Main autowire function - dispatches to appropriate strategy\n * Priority: mapResolvers (transformer-generated) > map (manual override)\n */\nexport function autowire(constructor, container, options) {\n    const opts = {\n        by: 'paramName',\n        strict: false,\n        ...options\n    };\n    // HIGHEST PRIORITY: mapResolvers array (transformer-generated, optimal performance)\n    // O(1) array access per parameter - minification-safe and refactoring-friendly\n    if (opts.mapResolvers && opts.mapResolvers.length > 0) {\n        return resolveByMapResolvers(constructor, container, opts);\n    }\n    // FALLBACK: Manual map strategy for explicit overrides\n    if (opts.map && Object.keys(opts.map).length > 0) {\n        return resolveByMap(constructor, container, opts);\n    }\n    // No autowiring configured, return empty array\n    return [];\n}\n", "/**\n * Fluent builder API for NovaDI Container (Autofac-style)\n */\nimport { Token } from './token.js';\nimport { autowire } from './autowire.js';\n/**\n * Fluent registration builder returned after each registration method\n */\nexport class RegistrationBuilder {\n    constructor(pending, registrations) {\n        this.registrations = registrations;\n        this.configs = [];\n        this.defaultLifetime = 'singleton';\n        this.pending = pending;\n    }\n    /**\n     * Bind this registration to a token or interface type\n     *\n     * @overload\n     * @param {Token<U>} token - Explicit token for binding\n     *\n     * @overload\n     * @param {string} typeName - Interface type name (auto-generated by transformer)\n     */\n    as(tokenOrTypeName) {\n        // Check if argument is a Token object (has symbol property)\n        if (tokenOrTypeName && typeof tokenOrTypeName === 'object' && 'symbol' in tokenOrTypeName) {\n            // Token-based registration\n            const config = {\n                token: tokenOrTypeName,\n                type: this.pending.type,\n                value: this.pending.value,\n                factory: this.pending.factory,\n                constructor: this.pending.constructor,\n                lifetime: this.defaultLifetime\n            };\n            this.configs.push(config);\n            this.registrations.push(config);\n            return this;\n        }\n        else {\n            // Interface-based registration (typeName string or undefined)\n            const config = {\n                token: null, // Will be set during build()\n                type: this.pending.type,\n                value: this.pending.value,\n                factory: this.pending.factory,\n                constructor: this.pending.constructor,\n                lifetime: this.defaultLifetime,\n                interfaceType: tokenOrTypeName\n            };\n            this.configs.push(config);\n            this.registrations.push(config);\n            return this;\n        }\n    }\n    /**\n     * Register as default implementation for an interface\n     * Combines as() + asDefault()\n     */\n    asDefaultInterface(typeName) {\n        this.as(\"TInterface\", typeName);\n        return this.asDefault();\n    }\n    /**\n     * Register as a keyed interface implementation\n     * Combines as() + keyed()\n     */\n    asKeyedInterface(key, typeName) {\n        this.as(\"TInterface\", typeName);\n        return this.keyed(key);\n    }\n    /**\n     * Register as multiple implemented interfaces\n     */\n    asImplementedInterfaces(tokens) {\n        if (tokens.length === 0) {\n            return this;\n        }\n        // If there are existing configs (from previous as() calls), add these as additional interfaces\n        if (this.configs.length > 0) {\n            // Add all tokens as additional interfaces to existing configs\n            for (const config of this.configs) {\n                config.lifetime = 'singleton'; // asImplementedInterfaces defaults to singleton\n                config.additionalTokens = config.additionalTokens || [];\n                config.additionalTokens.push(...tokens);\n            }\n            return this;\n        }\n        // No existing configs, create new one with first token\n        const firstConfig = {\n            token: tokens[0],\n            type: this.pending.type,\n            value: this.pending.value,\n            factory: this.pending.factory,\n            constructor: this.pending.constructor,\n            lifetime: 'singleton'\n        };\n        this.configs.push(firstConfig);\n        this.registrations.push(firstConfig);\n        // Additional tokens reference the same registration\n        for (let i = 1; i < tokens.length; i++) {\n            firstConfig.additionalTokens = firstConfig.additionalTokens || [];\n            firstConfig.additionalTokens.push(tokens[i]);\n        }\n        return this;\n    }\n    /**\n     * Set singleton lifetime (one instance for entire container)\n     */\n    singleInstance() {\n        for (const config of this.configs) {\n            config.lifetime = 'singleton';\n        }\n        return this;\n    }\n    /**\n     * Set per-request lifetime (one instance per resolve call tree)\n     */\n    instancePerRequest() {\n        for (const config of this.configs) {\n            config.lifetime = 'per-request';\n        }\n        return this;\n    }\n    /**\n     * Set transient lifetime (new instance every time)\n     * Alias for default behavior\n     */\n    instancePerDependency() {\n        for (const config of this.configs) {\n            config.lifetime = 'transient';\n        }\n        return this;\n    }\n    /**\n     * Name this registration for named resolution\n     */\n    named(name) {\n        for (const config of this.configs) {\n            config.name = name;\n        }\n        return this;\n    }\n    /**\n     * Key this registration for keyed resolution\n     */\n    keyed(key) {\n        for (const config of this.configs) {\n            config.key = key;\n        }\n        return this;\n    }\n    /**\n     * Mark this as default registration\n     * Default registrations don't override existing ones\n     */\n    asDefault() {\n        for (const config of this.configs) {\n            config.isDefault = true;\n        }\n        return this;\n    }\n    /**\n     * Only register if token not already registered\n     */\n    ifNotRegistered() {\n        for (const config of this.configs) {\n            config.ifNotRegistered = true;\n        }\n        return this;\n    }\n    /**\n     * Specify parameter values for constructor (primitives and constants)\n     * Use this for non-DI parameters like strings, numbers, config values\n     */\n    withParameters(parameters) {\n        for (const config of this.configs) {\n            config.parameterValues = parameters;\n        }\n        return this;\n    }\n    /**\n     * Enable automatic dependency injection (autowiring)\n     * Supports three strategies: paramName (default), map, and class\n     *\n     * @example\n     * ```ts\n     * // Strategy 1: paramName (default, requires non-minified code in dev)\n     * builder.registerType(EventBus).as<IEventBus>().autoWire()\n     *\n     * // Strategy 2: map (minify-safe, explicit)\n     * builder.registerType(EventBus).as<IEventBus>().autoWire({\n     *   map: {\n     *     logger: (c) => c.resolveType<ILogger>()\n     *   }\n     * })\n     *\n     * // Strategy 3: class (requires build-time codegen)\n     * builder.registerType(EventBus).as<IEventBus>().autoWire({ by: 'class' })\n     * ```\n     */\n    autoWire(options) {\n        for (const config of this.configs) {\n            config.autowireOptions = options || { by: 'paramName', strict: false };\n        }\n        return this;\n    }\n}\n/**\n * Fluent builder for Container configuration\n */\nexport class Builder {\n    constructor(baseContainer) {\n        this.baseContainer = baseContainer;\n        this.registrations = [];\n    }\n    /**\n     * Register a class constructor\n     */\n    registerType(constructor) {\n        const pending = {\n            type: 'type',\n            value: null,\n            constructor\n        };\n        return new RegistrationBuilder(pending, this.registrations);\n    }\n    /**\n     * Register a pre-created instance\n     */\n    registerInstance(instance) {\n        const pending = {\n            type: 'instance',\n            value: instance,\n            constructor: undefined\n        };\n        return new RegistrationBuilder(pending, this.registrations);\n    }\n    /**\n     * Register a factory function\n     */\n    register(factory) {\n        const pending = {\n            type: 'factory',\n            value: null,\n            factory,\n            constructor: undefined\n        };\n        return new RegistrationBuilder(pending, this.registrations);\n    }\n    /**\n     * Register a module (function that adds multiple registrations)\n     */\n    module(moduleFunc) {\n        moduleFunc(this);\n        return this;\n    }\n    /**\n     * Resolve interface type names to tokens\n     * @internal\n     */\n    resolveInterfaceTokens(container) {\n        for (const config of this.registrations) {\n            if (config.interfaceType !== undefined && !config.token) {\n                config.token = container.interfaceToken(config.interfaceType);\n            }\n        }\n    }\n    /**\n     * Identify tokens that have non-default registrations\n     * @internal\n     */\n    identifyNonDefaultTokens() {\n        const tokensWithNonDefaults = new Set();\n        for (const config of this.registrations) {\n            if (!config.isDefault && !config.name && config.key === undefined) {\n                tokensWithNonDefaults.add(config.token);\n            }\n        }\n        return tokensWithNonDefaults;\n    }\n    /**\n     * Check if registration should be skipped\n     * @internal\n     */\n    shouldSkipRegistration(config, tokensWithNonDefaults, registeredTokens) {\n        // Skip default registrations if there's a non-default for the same token\n        if (config.isDefault && !config.name && config.key === undefined && tokensWithNonDefaults.has(config.token)) {\n            return true;\n        }\n        // Handle ifNotRegistered\n        if (config.ifNotRegistered && registeredTokens.has(config.token)) {\n            return true;\n        }\n        // Handle asDefault\n        if (config.isDefault && registeredTokens.has(config.token)) {\n            return true;\n        }\n        return false;\n    }\n    /**\n     * Create binding token for registration (named, keyed, or multi)\n     * @internal\n     */\n    createBindingToken(config, namedRegistrations, keyedRegistrations, multiRegistrations) {\n        if (config.name) {\n            // Named registration gets unique token\n            const bindingToken = Token(`__named_${config.name}`);\n            namedRegistrations.set(config.name, { ...config, token: bindingToken });\n            return bindingToken;\n        }\n        else if (config.key !== undefined) {\n            // Keyed registration gets unique token\n            const keyStr = typeof config.key === 'symbol' ? config.key.toString() : config.key;\n            const bindingToken = Token(`__keyed_${keyStr}`);\n            keyedRegistrations.set(config.key, { ...config, token: bindingToken });\n            return bindingToken;\n        }\n        else {\n            // Multi-registration handling\n            if (multiRegistrations.has(config.token)) {\n                // Subsequent registration for this token\n                const bindingToken = Token(`__multi_${config.token.toString()}_${multiRegistrations.get(config.token).length}`);\n                multiRegistrations.get(config.token).push(bindingToken);\n                return bindingToken;\n            }\n            else {\n                // First registration for this token, use the original token\n                multiRegistrations.set(config.token, [config.token]);\n                return config.token;\n            }\n        }\n    }\n    /**\n     * Register additional interfaces for a config\n     * @internal\n     */\n    registerAdditionalInterfaces(container, config, bindingToken, registeredTokens) {\n        if (config.additionalTokens) {\n            for (const additionalToken of config.additionalTokens) {\n                // Create a factory that resolves the binding token\n                container.bindFactory(additionalToken, (c) => c.resolve(bindingToken), { lifetime: config.lifetime });\n                registeredTokens.add(additionalToken);\n            }\n        }\n    }\n    /**\n     * Build the container with all registered bindings\n     */\n    build() {\n        // Create new container inheriting from base\n        const container = this.baseContainer.createChild();\n        // Pre-process: resolve interface types to tokens\n        this.resolveInterfaceTokens(container);\n        // Track what's been registered for ifNotRegistered checks\n        const registeredTokens = new Set();\n        const namedRegistrations = new Map();\n        const keyedRegistrations = new Map();\n        const multiRegistrations = new Map();\n        // Pre-process: identify tokens that have non-default registrations\n        const tokensWithNonDefaults = this.identifyNonDefaultTokens();\n        for (const config of this.registrations) {\n            // Check if registration should be skipped\n            if (this.shouldSkipRegistration(config, tokensWithNonDefaults, registeredTokens)) {\n                continue;\n            }\n            // Create binding token (named, keyed, or multi)\n            const bindingToken = this.createBindingToken(config, namedRegistrations, keyedRegistrations, multiRegistrations);\n            // Apply registration to container using the binding token\n            this.applyRegistration(container, { ...config, token: bindingToken });\n            // Mark original token as registered\n            registeredTokens.add(config.token);\n            // Register additional interfaces\n            this.registerAdditionalInterfaces(container, config, bindingToken, registeredTokens);\n        }\n        // Attach metadata for named/keyed resolution\n        ;\n        container.__namedRegistrations = namedRegistrations;\n        container.__keyedRegistrations = keyedRegistrations;\n        container.__multiRegistrations = multiRegistrations;\n        return container;\n    }\n    /**\n     * Analyze constructor to detect dependencies\n     * @internal\n     */\n    analyzeConstructor(constructor) {\n        const constructorStr = constructor.toString();\n        const hasDependencies = /constructor\\s*\\([^)]+\\)/.test(constructorStr);\n        return { hasDependencies };\n    }\n    /**\n     * Create optimized factory for zero-dependency constructors\n     * @internal\n     */\n    createOptimizedFactory(container, config, options) {\n        if (config.lifetime === 'singleton') {\n            // Singleton: Create instance directly (fastest path - no factory overhead)\n            const instance = new config.constructor();\n            container.bindValue(config.token, instance);\n        }\n        else if (config.lifetime === 'transient') {\n            // Transient Fast Path: Register in fast transient cache\n            const ctor = config.constructor;\n            const fastFactory = () => new ctor();\n            container.fastTransientCache.set(config.token, fastFactory);\n            container.bindFactory(config.token, fastFactory, options);\n        }\n        else {\n            // Per-request: Use simple factory without autowire overhead\n            const factory = () => new config.constructor();\n            container.bindFactory(config.token, factory, options);\n        }\n    }\n    /**\n     * Create autowire factory\n     * @internal\n     */\n    createAutoWireFactory(container, config, options) {\n        const factory = (c) => {\n            const resolvedDeps = autowire(config.constructor, c, config.autowireOptions);\n            return new config.constructor(...resolvedDeps);\n        };\n        container.bindFactory(config.token, factory, options);\n    }\n    /**\n     * Create withParameters factory\n     * @internal\n     */\n    createParameterFactory(container, config, options) {\n        const factory = () => {\n            const values = Object.values(config.parameterValues);\n            return new config.constructor(...values);\n        };\n        container.bindFactory(config.token, factory, options);\n    }\n    /**\n     * Apply type registration (class constructor)\n     * @internal\n     */\n    applyTypeRegistration(container, config, options) {\n        const { hasDependencies } = this.analyzeConstructor(config.constructor);\n        // Fast path: No dependencies and no special config\n        if (!hasDependencies && !config.autowireOptions && !config.parameterValues) {\n            this.createOptimizedFactory(container, config, options);\n            return;\n        }\n        // AutoWire path\n        if (config.autowireOptions) {\n            this.createAutoWireFactory(container, config, options);\n            return;\n        }\n        // withParameters path\n        if (config.parameterValues) {\n            this.createParameterFactory(container, config, options);\n            return;\n        }\n        // Error: Constructor has dependencies but no config\n        if (hasDependencies) {\n            const className = config.constructor.name || 'UnnamedClass';\n            throw new Error(`Service \"${className}\" has constructor dependencies but no autowiring configuration.\\n\\n` +\n                `Solutions:\\n` +\n                `  1. \u2B50 Use the NovaDI transformer (recommended):\\n` +\n                `     - Add \"@novadi/core/unplugin\" to your build config\\n` +\n                `     - Transformer automatically generates .autoWire() for all dependencies\\n\\n` +\n                `  2. Add manual autowiring:\\n` +\n                `     .autoWire({ map: { /* param: resolver */ } })\\n\\n` +\n                `  3. Use a factory function:\\n` +\n                `     .register((c) => new ${className}(...))\\n\\n` +\n                `See docs: https://github.com/janus007/NovaDI#autowire`);\n        }\n        // No dependencies - create simple factory\n        const factory = () => new config.constructor();\n        container.bindFactory(config.token, factory, options);\n    }\n    applyRegistration(container, config) {\n        const options = { lifetime: config.lifetime };\n        switch (config.type) {\n            case 'instance':\n                container.bindValue(config.token, config.value);\n                break;\n            case 'factory':\n                container.bindFactory(config.token, config.factory, options);\n                break;\n            case 'type':\n                this.applyTypeRegistration(container, config, options);\n                break;\n        }\n    }\n}\n", "/**\n * Core dependency injection container for NovaDI\n */\nimport { Token } from './token.js';\nimport { BindingNotFoundError, CircularDependencyError } from './errors.js';\nimport { Builder } from './builder.js';\nfunction isDisposable(obj) {\n    return obj && typeof obj.dispose === 'function';\n}\n/**\n * Resolution context tracks the current dependency resolution path\n * for circular dependency detection and per-request scoping\n */\nclass ResolutionContext {\n    constructor() {\n        this.resolvingStack = new Set();\n        this.perRequestCache = new Map();\n    }\n    isResolving(token) {\n        return this.resolvingStack.has(token);\n    }\n    enterResolve(token) {\n        this.resolvingStack.add(token);\n        // Performance: Don't build path unless we need it (only used in error messages)\n        // This avoids expensive token.toString() calls on every resolve\n    }\n    exitResolve(token) {\n        this.resolvingStack.delete(token);\n        // Performance: Clear lazy path cache when exiting\n        this.path = undefined;\n    }\n    getPath() {\n        // Performance: Build path on-demand only when needed (typically for error messages)\n        if (!this.path) {\n            this.path = Array.from(this.resolvingStack).map(t => t.toString());\n        }\n        return [...this.path];\n    }\n    cachePerRequest(token, instance) {\n        this.perRequestCache.set(token, instance);\n    }\n    getPerRequest(token) {\n        return this.perRequestCache.get(token);\n    }\n    hasPerRequest(token) {\n        return this.perRequestCache.has(token);\n    }\n    /**\n     * Reset context for reuse in object pool\n     * Performance: Reusing contexts avoids heap allocations\n     */\n    reset() {\n        this.resolvingStack.clear();\n        this.perRequestCache.clear();\n        this.path = undefined;\n    }\n}\n/**\n * Object pool for ResolutionContext instances\n * Performance: Reusing contexts reduces heap allocations and GC pressure\n */\nclass ResolutionContextPool {\n    constructor() {\n        this.pool = [];\n        this.maxSize = 10;\n    }\n    acquire() {\n        const context = this.pool.pop();\n        if (context) {\n            // Reset existing context for reuse\n            context.reset();\n            return context;\n        }\n        // Create new if pool empty\n        return new ResolutionContext();\n    }\n    release(context) {\n        if (this.pool.length < this.maxSize) {\n            this.pool.push(context);\n        }\n        // Otherwise let it be GC'd\n    }\n}\n/**\n * Dependency Injection Container\n *\n * Manages registration and resolution of dependencies with support for:\n * - Multiple binding types (value, factory, class)\n * - Lifetime management (singleton, transient, per-request)\n * - Child containers with inheritance\n * - Circular dependency detection\n * - Automatic disposal\n */\nexport class Container {\n    constructor(parent) {\n        this.bindings = new Map();\n        this.singletonCache = new Map();\n        this.singletonOrder = [];\n        this.interfaceRegistry = new Map();\n        this.interfaceTokenCache = new Map(); // Performance: Cache for resolveType() lookups\n        this.fastTransientCache = new Map(); // Performance: Fast path for simple transients\n        this.ultraFastSingletonCache = new Map(); // Performance: Ultra-fast singleton-only cache\n        this.parent = parent;\n    }\n    /**\n     * Bind a pre-created value to a token\n     */\n    bindValue(token, value) {\n        this.bindings.set(token, {\n            type: 'value',\n            lifetime: 'singleton',\n            value,\n            constructor: undefined\n        });\n        this.invalidateBindingCache();\n    }\n    /**\n     * Bind a factory function to a token\n     */\n    bindFactory(token, factory, options) {\n        this.bindings.set(token, {\n            type: 'factory',\n            lifetime: options?.lifetime || 'transient',\n            factory,\n            dependencies: options?.dependencies,\n            constructor: undefined\n        });\n        this.invalidateBindingCache();\n    }\n    /**\n     * Bind a class constructor to a token\n     */\n    bindClass(token, constructor, options) {\n        const binding = {\n            type: 'class',\n            lifetime: options?.lifetime || 'transient',\n            constructor,\n            dependencies: options?.dependencies\n        };\n        this.bindings.set(token, binding);\n        this.invalidateBindingCache();\n        // Performance: Pre-compile fast transient factory for zero-dependency classes\n        if (binding.lifetime === 'transient' && (!binding.dependencies || binding.dependencies.length === 0)) {\n            this.fastTransientCache.set(token, () => new constructor());\n        }\n    }\n    /**\n     * Resolve a dependency synchronously\n     * Performance optimized with multiple fast paths\n     */\n    resolve(token) {\n        // Try all cache levels first (ultra-fast, singleton, fast transient)\n        const cached = this.tryGetFromCaches(token);\n        if (cached !== undefined) {\n            return cached;\n        }\n        // If we're already resolving (called from within a factory), reuse the context\n        if (this.currentContext) {\n            return this.resolveWithContext(token, this.currentContext);\n        }\n        // Complex resolution with pooled context\n        const context = Container.contextPool.acquire();\n        this.currentContext = context;\n        try {\n            return this.resolveWithContext(token, context);\n        }\n        finally {\n            this.currentContext = undefined;\n            Container.contextPool.release(context);\n        }\n    }\n    /**\n     * SPECIALIZED: Ultra-fast singleton resolve (no safety checks)\n     * Use ONLY when you're 100% sure the token is a registered singleton\n     * @internal For performance-critical paths only\n     */\n    resolveSingletonUnsafe(token) {\n        // Direct return, no checks - maximum speed\n        return this.ultraFastSingletonCache.get(token) ?? this.singletonCache.get(token);\n    }\n    /**\n     * SPECIALIZED: Fast transient resolve for zero-dependency classes\n     * Skips all context creation and circular dependency checks\n     * @internal For performance-critical paths only\n     */\n    resolveTransientSimple(token) {\n        const factory = this.fastTransientCache.get(token);\n        if (factory) {\n            return factory();\n        }\n        // Fallback to regular resolve if not in fast cache\n        return this.resolve(token);\n    }\n    /**\n     * SPECIALIZED: Batch resolve multiple dependencies at once\n     * More efficient than multiple individual resolves\n     */\n    resolveBatch(tokens) {\n        // Reuse single context for all resolutions\n        const wasResolving = !!this.currentContext;\n        const context = this.currentContext || Container.contextPool.acquire();\n        if (!wasResolving) {\n            this.currentContext = context;\n        }\n        try {\n            const results = tokens.map(token => {\n                // Try all cache levels first\n                const cached = this.tryGetFromCaches(token);\n                if (cached !== undefined)\n                    return cached;\n                // Full resolve with shared context\n                return this.resolveWithContext(token, context);\n            });\n            return results;\n        }\n        finally {\n            if (!wasResolving) {\n                this.currentContext = undefined;\n                Container.contextPool.release(context);\n            }\n        }\n    }\n    /**\n     * Resolve a dependency asynchronously (supports async factories)\n     */\n    async resolveAsync(token) {\n        // If we're already resolving (called from within a factory), reuse the context\n        if (this.currentContext) {\n            return this.resolveAsyncWithContext(token, this.currentContext);\n        }\n        // New top-level resolve\n        // Performance: Use pooled context to avoid heap allocation\n        const context = Container.contextPool.acquire();\n        this.currentContext = context;\n        try {\n            return await this.resolveAsyncWithContext(token, context);\n        }\n        finally {\n            this.currentContext = undefined;\n            Container.contextPool.release(context); // Return to pool for reuse\n        }\n    }\n    /**\n     * Try to get instance from all cache levels\n     * Returns undefined if not cached\n     * @internal\n     */\n    tryGetFromCaches(token) {\n        // Level 1: Ultra-fast singleton cache (zero overhead)\n        const ultraFast = this.ultraFastSingletonCache.get(token);\n        if (ultraFast !== undefined) {\n            return ultraFast;\n        }\n        // Level 2: Regular singleton cache\n        if (this.singletonCache.has(token)) {\n            const cached = this.singletonCache.get(token);\n            // Promote to ultra-fast cache for next time\n            this.ultraFastSingletonCache.set(token, cached);\n            return cached;\n        }\n        // Level 3: Fast transient cache (no dependencies)\n        const fastFactory = this.fastTransientCache.get(token);\n        if (fastFactory) {\n            return fastFactory();\n        }\n        return undefined;\n    }\n    /**\n     * Cache instance based on lifetime strategy\n     * @internal\n     */\n    cacheInstance(token, instance, lifetime, context) {\n        if (lifetime === 'singleton') {\n            this.singletonCache.set(token, instance);\n            this.singletonOrder.push(token);\n            // Also add to ultra-fast cache\n            this.ultraFastSingletonCache.set(token, instance);\n        }\n        else if (lifetime === 'per-request' && context) {\n            context.cachePerRequest(token, instance);\n        }\n    }\n    /**\n     * Validate and get binding with circular dependency check\n     * Returns binding or throws error\n     * @internal\n     */\n    validateAndGetBinding(token, context) {\n        // Check circular dependency\n        if (context.isResolving(token)) {\n            throw new CircularDependencyError([...context.getPath(), token.toString()]);\n        }\n        const binding = this.getBinding(token);\n        if (!binding) {\n            throw new BindingNotFoundError(token.toString(), context.getPath());\n        }\n        return binding;\n    }\n    /**\n     * Instantiate from binding synchronously\n     * @internal\n     */\n    instantiateBindingSync(binding, token, context) {\n        switch (binding.type) {\n            case 'value':\n                return binding.value;\n            case 'factory':\n                const result = binding.factory(this);\n                if (result instanceof Promise) {\n                    throw new Error(`Async factory detected for ${token.toString()}. Use resolveAsync() instead.`);\n                }\n                return result;\n            case 'class':\n                const deps = binding.dependencies || [];\n                const resolvedDeps = deps.map(dep => this.resolveWithContext(dep, context));\n                return new binding.constructor(...resolvedDeps);\n            case 'inline-class':\n                return new binding.constructor();\n            default:\n                throw new Error(`Unknown binding type: ${binding.type}`);\n        }\n    }\n    /**\n     * Instantiate from binding asynchronously\n     * @internal\n     */\n    async instantiateBindingAsync(binding, context) {\n        switch (binding.type) {\n            case 'value':\n                return binding.value;\n            case 'factory':\n                return await Promise.resolve(binding.factory(this));\n            case 'class':\n                const deps = binding.dependencies || [];\n                const resolvedDeps = await Promise.all(deps.map(dep => this.resolveAsyncWithContext(dep, context)));\n                return new binding.constructor(...resolvedDeps);\n            case 'inline-class':\n                return new binding.constructor();\n            default:\n                throw new Error(`Unknown binding type: ${binding.type}`);\n        }\n    }\n    /**\n     * Create a child container that inherits bindings from this container\n     */\n    createChild() {\n        return new Container(this);\n    }\n    /**\n     * Dispose all singleton instances in reverse registration order\n     */\n    async dispose() {\n        const errors = [];\n        // Dispose in reverse order\n        for (let i = this.singletonOrder.length - 1; i >= 0; i--) {\n            const token = this.singletonOrder[i];\n            const instance = this.singletonCache.get(token);\n            if (instance && isDisposable(instance)) {\n                try {\n                    await instance.dispose();\n                }\n                catch (error) {\n                    errors.push(error);\n                    // Continue disposing other instances even if one fails\n                }\n            }\n        }\n        // Clear caches\n        this.singletonCache.clear();\n        this.singletonOrder.length = 0;\n        // Note: We don't throw errors to allow all disposals to complete\n        // In production, you might want to log these errors\n    }\n    /**\n     * Create a fluent builder for registering dependencies\n     */\n    builder() {\n        return new Builder(this);\n    }\n    /**\n     * Resolve a named service\n     */\n    resolveNamed(name) {\n        const namedRegistrations = this.__namedRegistrations;\n        if (!namedRegistrations) {\n            throw new Error(`Named service \"${name}\" not found. No named registrations exist.`);\n        }\n        const config = namedRegistrations.get(name);\n        if (!config) {\n            throw new Error(`Named service \"${name}\" not found`);\n        }\n        return this.resolve(config.token);\n    }\n    /**\n     * Resolve a keyed service\n     */\n    resolveKeyed(key) {\n        const keyedRegistrations = this.__keyedRegistrations;\n        if (!keyedRegistrations) {\n            throw new Error(`Keyed service not found. No keyed registrations exist.`);\n        }\n        const config = keyedRegistrations.get(key);\n        if (!config) {\n            const keyStr = typeof key === 'symbol' ? key.toString() : `\"${key}\"`;\n            throw new Error(`Keyed service ${keyStr} not found`);\n        }\n        return this.resolve(config.token);\n    }\n    /**\n     * Resolve all registrations for a token\n     */\n    resolveAll(token) {\n        const multiRegistrations = this.__multiRegistrations;\n        if (!multiRegistrations) {\n            return [];\n        }\n        const tokens = multiRegistrations.get(token);\n        if (!tokens || tokens.length === 0) {\n            return [];\n        }\n        return tokens.map((t) => this.resolve(t));\n    }\n    /**\n     * Get registry information for debugging/visualization\n     * Returns array of binding information\n     */\n    getRegistry() {\n        const registry = [];\n        this.bindings.forEach((binding, token) => {\n            registry.push({\n                token: token.description || token.symbol.toString(),\n                type: binding.type,\n                lifetime: binding.lifetime,\n                dependencies: binding.dependencies?.map(d => d.description || d.symbol.toString())\n            });\n        });\n        return registry;\n    }\n    /**\n     * Get or create a token for an interface type\n     * Uses a type name hash as key for the interface registry\n     */\n    interfaceToken(typeName) {\n        // Generate a unique key for this interface type\n        // In production, this would be replaced by a TS transformer\n        const key = typeName || `Interface_${Math.random().toString(36).substr(2, 9)}`;\n        // Check if token already exists in this container\n        if (this.interfaceRegistry.has(key)) {\n            return this.interfaceRegistry.get(key);\n        }\n        // Check parent container (recursively through parent chain)\n        if (this.parent) {\n            // Recursively check through entire parent chain\n            const parentToken = this.parent.interfaceToken(key);\n            // If parent created a new token, don't create another one\n            return parentToken;\n        }\n        // Create new token (only if no parent exists)\n        const token = Token(key);\n        this.interfaceRegistry.set(key, token);\n        return token;\n    }\n    /**\n     * Resolve a dependency by interface type without explicit token\n     */\n    resolveType(typeName) {\n        // Performance: Cache token lookups to avoid repeated interfaceRegistry access\n        const key = typeName || '';\n        let token = this.interfaceTokenCache.get(key);\n        if (!token) {\n            token = this.interfaceToken(typeName);\n            this.interfaceTokenCache.set(key, token);\n        }\n        return this.resolve(token);\n    }\n    /**\n     * Resolve a keyed interface\n     */\n    resolveTypeKeyed(key, _typeName) {\n        // For keyed interfaces, we use the existing resolveKeyed mechanism\n        return this.resolveKeyed(key);\n    }\n    /**\n     * Resolve all registrations for an interface type\n     */\n    resolveTypeAll(typeName) {\n        const token = this.interfaceToken(typeName);\n        return this.resolveAll(token);\n    }\n    /**\n     * Internal: Resolve with context for circular dependency detection\n     */\n    resolveWithContext(token, context) {\n        // Validate and get binding (with circular dependency check)\n        const binding = this.validateAndGetBinding(token, context);\n        // Check per-request cache\n        if (binding.lifetime === 'per-request' && context.hasPerRequest(token)) {\n            return context.getPerRequest(token);\n        }\n        // Check singleton cache (local container only)\n        if (binding.lifetime === 'singleton' && this.singletonCache.has(token)) {\n            return this.singletonCache.get(token);\n        }\n        // Mark as resolving\n        context.enterResolve(token);\n        try {\n            // Instantiate from binding\n            const instance = this.instantiateBindingSync(binding, token, context);\n            // Cache based on lifetime\n            this.cacheInstance(token, instance, binding.lifetime, context);\n            return instance;\n        }\n        finally {\n            context.exitResolve(token);\n        }\n    }\n    /**\n     * Internal: Async resolve with context\n     */\n    async resolveAsyncWithContext(token, context) {\n        // Validate and get binding (with circular dependency check)\n        const binding = this.validateAndGetBinding(token, context);\n        // Check per-request cache\n        if (binding.lifetime === 'per-request' && context.hasPerRequest(token)) {\n            return context.getPerRequest(token);\n        }\n        // Check singleton cache (local container only)\n        if (binding.lifetime === 'singleton' && this.singletonCache.has(token)) {\n            return this.singletonCache.get(token);\n        }\n        // Mark as resolving\n        context.enterResolve(token);\n        try {\n            // Instantiate from binding asynchronously\n            const instance = await this.instantiateBindingAsync(binding, context);\n            // Cache based on lifetime\n            this.cacheInstance(token, instance, binding.lifetime, context);\n            return instance;\n        }\n        finally {\n            context.exitResolve(token);\n        }\n    }\n    /**\n     * Get binding from this container or parent chain\n     * Performance optimized: Uses flat cache to avoid recursive parent lookups\n     */\n    getBinding(token) {\n        // Build flat cache on first access\n        if (!this.bindingCache) {\n            this.buildBindingCache();\n        }\n        return this.bindingCache.get(token);\n    }\n    /**\n     * Build flat cache of all bindings including parent chain\n     * This converts O(n) parent chain traversal to O(1) lookup\n     */\n    buildBindingCache() {\n        this.bindingCache = new Map();\n        // Traverse parent chain and flatten all bindings\n        let current = this;\n        while (current) {\n            current.bindings.forEach((binding, token) => {\n                // Child bindings override parent bindings (first wins)\n                if (!this.bindingCache.has(token)) {\n                    this.bindingCache.set(token, binding);\n                }\n            });\n            current = current.parent;\n        }\n    }\n    /**\n     * Invalidate binding cache when new bindings are added\n     * Called by bindValue, bindFactory, bindClass\n     */\n    invalidateBindingCache() {\n        this.bindingCache = undefined;\n        this.ultraFastSingletonCache.clear(); // Clear ultra-fast cache when bindings change\n    }\n}\nContainer.contextPool = new ResolutionContextPool(); // Performance: Pooled contexts reduce allocations\n", "export class DateRenderer {\n    constructor(dateService) {\n        this.dateService = dateService;\n        this.type = 'date';\n    }\n    render(context) {\n        const dates = context.filter['date'] || [];\n        const resourceIds = context.filter['resource'] || [];\n        // Check if date headers should be hidden (e.g., in day view)\n        const dateGrouping = context.groupings?.find(g => g.type === 'date');\n        const hideHeader = dateGrouping?.hideHeader === true;\n        // Render dates for HVER resource (eller 1 gang hvis ingen resources)\n        const iterations = resourceIds.length || 1;\n        let columnCount = 0;\n        for (let r = 0; r < iterations; r++) {\n            const resourceId = resourceIds[r]; // undefined hvis ingen resources\n            for (const dateStr of dates) {\n                const date = this.dateService.parseISO(dateStr);\n                // Build columnKey for uniform identification\n                const segments = { date: dateStr };\n                if (resourceId)\n                    segments.resource = resourceId;\n                const columnKey = this.dateService.buildColumnKey(segments);\n                // Header\n                const header = document.createElement('swp-day-header');\n                header.dataset.date = dateStr;\n                header.dataset.columnKey = columnKey;\n                if (resourceId) {\n                    header.dataset.resourceId = resourceId;\n                }\n                if (hideHeader) {\n                    header.dataset.hidden = 'true';\n                }\n                header.innerHTML = `\r\n          <swp-day-name>${this.dateService.getDayName(date, 'short')}</swp-day-name>\r\n          <swp-day-date>${date.getDate()}</swp-day-date>\r\n        `;\n                context.headerContainer.appendChild(header);\n                // Column\n                const column = document.createElement('swp-day-column');\n                column.dataset.date = dateStr;\n                column.dataset.columnKey = columnKey;\n                if (resourceId) {\n                    column.dataset.resourceId = resourceId;\n                }\n                column.innerHTML = '<swp-events-layer></swp-events-layer>';\n                context.columnContainer.appendChild(column);\n                columnCount++;\n            }\n        }\n        // Set grid columns on container\n        const container = context.columnContainer.closest('swp-calendar-container');\n        if (container) {\n            container.style.setProperty('--grid-columns', String(columnCount));\n        }\n    }\n}\n", "import dayjs from 'dayjs';\nimport utc from 'dayjs/plugin/utc';\nimport timezone from 'dayjs/plugin/timezone';\nimport isoWeek from 'dayjs/plugin/isoWeek';\n// Enable dayjs plugins\ndayjs.extend(utc);\ndayjs.extend(timezone);\ndayjs.extend(isoWeek);\nexport class DateService {\n    constructor(config, baseDate) {\n        this.config = config;\n        this.timezone = config.timezone;\n        // Allow setting a fixed base date for demo/testing purposes\n        this.baseDate = baseDate ? dayjs(baseDate) : dayjs();\n    }\n    /**\n     * Set a fixed base date (useful for demos with static mock data)\n     */\n    setBaseDate(date) {\n        this.baseDate = dayjs(date);\n    }\n    /**\n     * Get the current base date (either fixed or today)\n     */\n    getBaseDate() {\n        return this.baseDate.toDate();\n    }\n    parseISO(isoString) {\n        return dayjs(isoString).toDate();\n    }\n    getDayName(date, format = 'short') {\n        return new Intl.DateTimeFormat(this.config.locale, { weekday: format }).format(date);\n    }\n    /**\n     * Get dates starting from a day offset\n     * @param dayOffset - Day offset from base date\n     * @param count - Number of consecutive days to return\n     * @returns Array of date strings in YYYY-MM-DD format\n     */\n    getDatesFromOffset(dayOffset, count) {\n        const startDate = this.baseDate.add(dayOffset, 'day');\n        return Array.from({ length: count }, (_, i) => startDate.add(i, 'day').format('YYYY-MM-DD'));\n    }\n    /**\n     * Get specific weekdays from the week containing the offset date\n     * @param dayOffset - Day offset from base date\n     * @param workDays - Array of ISO weekday numbers (1=Monday, 7=Sunday)\n     * @returns Array of date strings in YYYY-MM-DD format\n     */\n    getWorkDaysFromOffset(dayOffset, workDays) {\n        // Get the date at offset, then find its week's Monday\n        const targetDate = this.baseDate.add(dayOffset, 'day');\n        const monday = targetDate.startOf('week').add(1, 'day');\n        return workDays.map(isoDay => {\n            // ISO: 1=Monday, 7=Sunday \u2192 days from Monday: 0-6\n            const daysFromMonday = isoDay === 7 ? 6 : isoDay - 1;\n            return monday.add(daysFromMonday, 'day').format('YYYY-MM-DD');\n        });\n    }\n    // Legacy methods for backwards compatibility\n    getWeekDates(weekOffset = 0, days = 7) {\n        return this.getDatesFromOffset(weekOffset * 7, days);\n    }\n    getWorkWeekDates(weekOffset, workDays) {\n        return this.getWorkDaysFromOffset(weekOffset * 7, workDays);\n    }\n    // ============================================\n    // FORMATTING\n    // ============================================\n    formatTime(date, showSeconds = false) {\n        const pattern = showSeconds ? 'HH:mm:ss' : 'HH:mm';\n        return dayjs(date).format(pattern);\n    }\n    formatTimeRange(start, end) {\n        return `${this.formatTime(start)} - ${this.formatTime(end)}`;\n    }\n    formatDate(date) {\n        return dayjs(date).format('YYYY-MM-DD');\n    }\n    getDateKey(date) {\n        return this.formatDate(date);\n    }\n    // ============================================\n    // COLUMN KEY\n    // ============================================\n    /**\n     * Build a uniform columnKey from grouping segments\n     * Handles any combination of date, resource, team, etc.\n     *\n     * @example\n     * buildColumnKey({ date: '2025-12-09' }) \u2192 \"2025-12-09\"\n     * buildColumnKey({ date: '2025-12-09', resource: 'EMP001' }) \u2192 \"2025-12-09:EMP001\"\n     */\n    buildColumnKey(segments) {\n        // Always put date first if present, then other segments alphabetically\n        const date = segments.date;\n        const others = Object.entries(segments)\n            .filter(([k]) => k !== 'date')\n            .sort(([a], [b]) => a.localeCompare(b))\n            .map(([, v]) => v);\n        return date ? [date, ...others].join(':') : others.join(':');\n    }\n    /**\n     * Parse a columnKey back into segments\n     * Assumes format: \"date:resource:...\" or just \"date\"\n     */\n    parseColumnKey(columnKey) {\n        const parts = columnKey.split(':');\n        return {\n            date: parts[0],\n            resource: parts[1]\n        };\n    }\n    /**\n     * Extract dateKey from columnKey (first segment)\n     */\n    getDateFromColumnKey(columnKey) {\n        return columnKey.split(':')[0];\n    }\n    // ============================================\n    // TIME CALCULATIONS\n    // ============================================\n    timeToMinutes(timeString) {\n        const parts = timeString.split(':').map(Number);\n        const hours = parts[0] || 0;\n        const minutes = parts[1] || 0;\n        return hours * 60 + minutes;\n    }\n    minutesToTime(totalMinutes) {\n        const hours = Math.floor(totalMinutes / 60);\n        const minutes = totalMinutes % 60;\n        return dayjs().hour(hours).minute(minutes).format('HH:mm');\n    }\n    getMinutesSinceMidnight(date) {\n        const d = dayjs(date);\n        return d.hour() * 60 + d.minute();\n    }\n    // ============================================\n    // UTC CONVERSIONS\n    // ============================================\n    toUTC(localDate) {\n        return dayjs.tz(localDate, this.timezone).utc().toISOString();\n    }\n    fromUTC(utcString) {\n        return dayjs.utc(utcString).tz(this.timezone).toDate();\n    }\n    // ============================================\n    // DATE CREATION\n    // ============================================\n    createDateAtTime(baseDate, timeString) {\n        const totalMinutes = this.timeToMinutes(timeString);\n        const hours = Math.floor(totalMinutes / 60);\n        const minutes = totalMinutes % 60;\n        return dayjs(baseDate).startOf('day').hour(hours).minute(minutes).toDate();\n    }\n    getISOWeekDay(date) {\n        return dayjs(date).isoWeekday(); // 1=Monday, 7=Sunday\n    }\n}\n", "/**\n * Abstract base class for grouping renderers\n *\n * Handles:\n * - Fetching entities by IDs\n * - Calculating colspan from parentChildMap\n * - Creating header elements\n * - Appending to container\n *\n * Subclasses override:\n * - renderHeader() for custom content\n * - getDisplayName() for entity display text\n */\nexport class BaseGroupingRenderer {\n    /**\n     * Main render method - handles common logic\n     */\n    async render(context) {\n        const allowedIds = context.filter[this.type] || [];\n        if (allowedIds.length === 0)\n            return;\n        const entities = await this.getEntities(allowedIds);\n        const dateCount = context.filter['date']?.length || 1;\n        const childIds = context.childType ? context.filter[context.childType] || [] : [];\n        for (const entity of entities) {\n            const entityChildIds = context.parentChildMap?.[entity.id] || [];\n            const childCount = entityChildIds.filter(id => childIds.includes(id)).length;\n            const colspan = childCount * dateCount;\n            const header = document.createElement(this.config.elementTag);\n            header.dataset[this.config.idAttribute] = entity.id;\n            header.style.setProperty(this.config.colspanVar, String(colspan));\n            // Allow subclass to customize header content\n            this.renderHeader(entity, header, context);\n            context.headerContainer.appendChild(header);\n        }\n    }\n    /**\n     * Override this method for custom header rendering\n     * Default: just sets textContent to display name\n     */\n    renderHeader(entity, header, _context) {\n        header.textContent = this.getDisplayName(entity);\n    }\n    /**\n     * Helper to render a single entity header.\n     * Can be used by subclasses that override render() but want consistent header creation.\n     */\n    createHeader(entity, context) {\n        const header = document.createElement(this.config.elementTag);\n        header.dataset[this.config.idAttribute] = entity.id;\n        this.renderHeader(entity, header, context);\n        return header;\n    }\n}\n", "import { BaseGroupingRenderer } from '../../core/BaseGroupingRenderer';\nexport class ResourceRenderer extends BaseGroupingRenderer {\n    constructor(resourceService) {\n        super();\n        this.resourceService = resourceService;\n        this.type = 'resource';\n        this.config = {\n            elementTag: 'swp-resource-header',\n            idAttribute: 'resourceId',\n            colspanVar: '--resource-cols'\n        };\n    }\n    getEntities(ids) {\n        return this.resourceService.getByIds(ids);\n    }\n    getDisplayName(entity) {\n        return entity.displayName;\n    }\n    /**\n     * Override render to handle:\n     * 1. Special ordering when parentChildMap exists (resources grouped by parent)\n     * 2. Different colspan calculation (just dateCount, not childCount * dateCount)\n     */\n    async render(context) {\n        const resourceIds = context.filter['resource'] || [];\n        const dateCount = context.filter['date']?.length || 1;\n        // Determine render order based on parentChildMap\n        // If parentChildMap exists, render resources grouped by parent (e.g., team)\n        // Otherwise, render in filter order\n        let orderedResourceIds;\n        if (context.parentChildMap) {\n            // Render resources in parent-child order\n            orderedResourceIds = [];\n            for (const childIds of Object.values(context.parentChildMap)) {\n                for (const childId of childIds) {\n                    if (resourceIds.includes(childId)) {\n                        orderedResourceIds.push(childId);\n                    }\n                }\n            }\n        }\n        else {\n            orderedResourceIds = resourceIds;\n        }\n        const resources = await this.getEntities(orderedResourceIds);\n        // Create a map for quick lookup to preserve order\n        const resourceMap = new Map(resources.map(r => [r.id, r]));\n        for (const resourceId of orderedResourceIds) {\n            const resource = resourceMap.get(resourceId);\n            if (!resource)\n                continue;\n            const header = this.createHeader(resource, context);\n            header.style.gridColumn = `span ${dateCount}`;\n            context.headerContainer.appendChild(header);\n        }\n    }\n}\n", "import { BaseGroupingRenderer } from '../../core/BaseGroupingRenderer';\nexport class TeamRenderer extends BaseGroupingRenderer {\n    constructor(teamService) {\n        super();\n        this.teamService = teamService;\n        this.type = 'team';\n        this.config = {\n            elementTag: 'swp-team-header',\n            idAttribute: 'teamId',\n            colspanVar: '--team-cols'\n        };\n    }\n    getEntities(ids) {\n        return this.teamService.getByIds(ids);\n    }\n    getDisplayName(entity) {\n        return entity.name;\n    }\n}\n", "import { BaseGroupingRenderer } from '../../core/BaseGroupingRenderer';\nexport class DepartmentRenderer extends BaseGroupingRenderer {\n    constructor(departmentService) {\n        super();\n        this.departmentService = departmentService;\n        this.type = 'department';\n        this.config = {\n            elementTag: 'swp-department-header',\n            idAttribute: 'departmentId',\n            colspanVar: '--department-cols'\n        };\n    }\n    getEntities(ids) {\n        return this.departmentService.getByIds(ids);\n    }\n    getDisplayName(entity) {\n        return entity.name;\n    }\n}\n", "export function buildPipeline(renderers) {\n    return {\n        async run(context) {\n            for (const renderer of renderers) {\n                await renderer.render(context);\n            }\n        }\n    };\n}\n", "/**\n * FilterTemplate - Bygger n\u00F8gler til event-kolonne matching\n *\n * ViewConfig definerer hvilke felter (idProperties) der indg\u00E5r i kolonnens n\u00F8gle.\n * Samme template bruges til at bygge n\u00F8gle for b\u00E5de kolonne og event.\n *\n * Supports dot-notation for hierarchical relations:\n * - 'resource.teamId' \u2192 looks up event.resourceId \u2192 resource entity \u2192 teamId\n *\n * Princip: Kolonnens n\u00F8gle-template bestemmer hvad der matches p\u00E5.\n *\n * @see docs/filter-template.md\n */\nexport class FilterTemplate {\n    constructor(dateService, entityResolver) {\n        this.dateService = dateService;\n        this.entityResolver = entityResolver;\n        this.fields = [];\n    }\n    /**\n     * Tilf\u00F8j felt til template\n     * @param idProperty - Property-navn (bruges p\u00E5 b\u00E5de event og column.dataset)\n     * @param derivedFrom - Hvis feltet udledes fra anden property (f.eks. date fra start)\n     */\n    addField(idProperty, derivedFrom) {\n        this.fields.push({ idProperty, derivedFrom });\n        return this;\n    }\n    /**\n     * Parse dot-notation string into components\n     * @example 'resource.teamId' \u2192 { entityType: 'resource', property: 'teamId', foreignKey: 'resourceId' }\n     */\n    parseDotNotation(idProperty) {\n        if (!idProperty.includes('.'))\n            return null;\n        const [entityType, property] = idProperty.split('.');\n        return {\n            entityType,\n            property,\n            foreignKey: entityType + 'Id' // Convention: resource \u2192 resourceId\n        };\n    }\n    /**\n     * Get dataset key for column lookup\n     * For dot-notation 'resource.teamId', we look for 'teamId' in dataset\n     */\n    getDatasetKey(idProperty) {\n        const dotNotation = this.parseDotNotation(idProperty);\n        if (dotNotation) {\n            return dotNotation.property; // 'teamId'\n        }\n        return idProperty;\n    }\n    /**\n     * Byg n\u00F8gle fra kolonne\n     * L\u00E6ser v\u00E6rdier fra column.dataset[idProperty]\n     * For dot-notation, uses the property part (resource.teamId \u2192 teamId)\n     */\n    buildKeyFromColumn(column) {\n        return this.fields\n            .map(f => {\n            const key = this.getDatasetKey(f.idProperty);\n            return column.dataset[key] || '';\n        })\n            .join(':');\n    }\n    /**\n     * Byg n\u00F8gle fra event\n     * L\u00E6ser v\u00E6rdier fra event[idProperty] eller udleder fra derivedFrom\n     * For dot-notation, resolves via EntityResolver\n     */\n    buildKeyFromEvent(event) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const eventRecord = event;\n        return this.fields\n            .map(f => {\n            // Check for dot-notation (e.g., 'resource.teamId')\n            const dotNotation = this.parseDotNotation(f.idProperty);\n            if (dotNotation) {\n                return this.resolveDotNotation(eventRecord, dotNotation);\n            }\n            if (f.derivedFrom) {\n                // Udled v\u00E6rdi (f.eks. date fra start)\n                const sourceValue = eventRecord[f.derivedFrom];\n                if (sourceValue instanceof Date) {\n                    return this.dateService.getDateKey(sourceValue);\n                }\n                return String(sourceValue || '');\n            }\n            return String(eventRecord[f.idProperty] || '');\n        })\n            .join(':');\n    }\n    /**\n     * Resolve dot-notation reference via EntityResolver\n     */\n    resolveDotNotation(eventRecord, dotNotation) {\n        if (!this.entityResolver) {\n            console.warn(`FilterTemplate: EntityResolver required for dot-notation '${dotNotation.entityType}.${dotNotation.property}'`);\n            return '';\n        }\n        // Get foreign key value from event (e.g., resourceId)\n        const foreignId = eventRecord[dotNotation.foreignKey];\n        if (!foreignId)\n            return '';\n        // Resolve entity\n        const entity = this.entityResolver.resolve(dotNotation.entityType, String(foreignId));\n        if (!entity)\n            return '';\n        // Return property value from entity\n        return String(entity[dotNotation.property] || '');\n    }\n    /**\n     * Match event mod kolonne\n     */\n    matches(event, column) {\n        return this.buildKeyFromEvent(event) === this.buildKeyFromColumn(column);\n    }\n}\n", "import { buildPipeline } from './RenderBuilder';\nimport { FilterTemplate } from './FilterTemplate';\nexport class CalendarOrchestrator {\n    constructor(allRenderers, eventRenderer, scheduleRenderer, headerDrawerRenderer, dateService, entityServices) {\n        this.allRenderers = allRenderers;\n        this.eventRenderer = eventRenderer;\n        this.scheduleRenderer = scheduleRenderer;\n        this.headerDrawerRenderer = headerDrawerRenderer;\n        this.dateService = dateService;\n        this.entityServices = entityServices;\n    }\n    async render(viewConfig, container) {\n        const headerContainer = container.querySelector('swp-calendar-header');\n        const columnContainer = container.querySelector('swp-day-columns');\n        if (!headerContainer || !columnContainer) {\n            throw new Error('Missing swp-calendar-header or swp-day-columns');\n        }\n        // Byg filter fra viewConfig\n        const filter = {};\n        for (const grouping of viewConfig.groupings) {\n            filter[grouping.type] = grouping.values;\n        }\n        // Byg FilterTemplate fra viewConfig groupings (kun de med idProperty)\n        const filterTemplate = new FilterTemplate(this.dateService);\n        for (const grouping of viewConfig.groupings) {\n            if (grouping.idProperty) {\n                filterTemplate.addField(grouping.idProperty, grouping.derivedFrom);\n            }\n        }\n        // Resolve belongsTo relations (e.g., team.resourceIds)\n        const { parentChildMap, childType } = await this.resolveBelongsTo(viewConfig.groupings, filter);\n        const context = { headerContainer, columnContainer, filter, groupings: viewConfig.groupings, parentChildMap, childType };\n        // Clear\n        headerContainer.innerHTML = '';\n        columnContainer.innerHTML = '';\n        // S\u00E6t data-levels attribut for CSS grid-row styling\n        const levels = viewConfig.groupings.map(g => g.type).join(' ');\n        headerContainer.dataset.levels = levels;\n        // V\u00E6lg renderers baseret p\u00E5 groupings types\n        const activeRenderers = this.selectRenderers(viewConfig);\n        // Byg og k\u00F8r pipeline\n        const pipeline = buildPipeline(activeRenderers);\n        await pipeline.run(context);\n        // Render schedule unavailable zones (f\u00F8r events)\n        await this.scheduleRenderer.render(container, filter);\n        // Render timed events in grid (med filterTemplate til matching)\n        await this.eventRenderer.render(container, filter, filterTemplate);\n        // Render allDay events in header drawer (med filterTemplate til matching)\n        await this.headerDrawerRenderer.render(container, filter, filterTemplate);\n    }\n    selectRenderers(viewConfig) {\n        const types = viewConfig.groupings.map(g => g.type);\n        // Sort\u00E9r renderers i samme r\u00E6kkef\u00F8lge som viewConfig.groupings\n        return types\n            .map(type => this.allRenderers.find(r => r.type === type))\n            .filter((r) => r !== undefined);\n    }\n    /**\n     * Resolve belongsTo relations to build parent-child map\n     * e.g., belongsTo: 'team.resourceIds' \u2192 { team1: ['EMP001', 'EMP002'], team2: [...] }\n     * Also returns the childType (the grouping type that has belongsTo)\n     */\n    async resolveBelongsTo(groupings, filter) {\n        // Find grouping with belongsTo\n        const childGrouping = groupings.find(g => g.belongsTo);\n        if (!childGrouping?.belongsTo)\n            return {};\n        // Parse belongsTo: 'team.resourceIds'\n        const [entityType, property] = childGrouping.belongsTo.split('.');\n        if (!entityType || !property)\n            return {};\n        // Get parent IDs from filter\n        const parentIds = filter[entityType] || [];\n        if (parentIds.length === 0)\n            return {};\n        // Find service dynamisk baseret p\u00E5 entityType (ingen hardcoded type check)\n        const service = this.entityServices.find(s => s.entityType.toLowerCase() === entityType);\n        if (!service)\n            return {};\n        // Hent alle entities og filtrer p\u00E5 parentIds\n        const allEntities = await service.getAll();\n        const entities = allEntities.filter(e => parentIds.includes(e.id));\n        // Byg parent-child map\n        const map = {};\n        for (const entity of entities) {\n            const entityRecord = entity;\n            const children = entityRecord[property] || [];\n            map[entityRecord.id] = children;\n        }\n        return { parentChildMap: map, childType: childGrouping.type };\n    }\n}\n", "export class NavigationAnimator {\n    constructor(headerTrack, contentTrack, headerDrawer) {\n        this.headerTrack = headerTrack;\n        this.contentTrack = contentTrack;\n        this.headerDrawer = headerDrawer;\n    }\n    async slide(direction, renderFn) {\n        const out = direction === 'left' ? '-100%' : '100%';\n        const into = direction === 'left' ? '100%' : '-100%';\n        await this.animateOut(out);\n        await renderFn();\n        await this.animateIn(into);\n    }\n    async animateOut(translate) {\n        const animations = [\n            this.headerTrack.animate([{ transform: 'translateX(0)' }, { transform: `translateX(${translate})` }], { duration: 200, easing: 'ease-in' }).finished,\n            this.contentTrack.animate([{ transform: 'translateX(0)' }, { transform: `translateX(${translate})` }], { duration: 200, easing: 'ease-in' }).finished\n        ];\n        if (this.headerDrawer) {\n            animations.push(this.headerDrawer.animate([{ transform: 'translateX(0)' }, { transform: `translateX(${translate})` }], { duration: 200, easing: 'ease-in' }).finished);\n        }\n        await Promise.all(animations);\n    }\n    async animateIn(translate) {\n        const animations = [\n            this.headerTrack.animate([{ transform: `translateX(${translate})` }, { transform: 'translateX(0)' }], { duration: 200, easing: 'ease-out' }).finished,\n            this.contentTrack.animate([{ transform: `translateX(${translate})` }, { transform: 'translateX(0)' }], { duration: 200, easing: 'ease-out' }).finished\n        ];\n        if (this.headerDrawer) {\n            animations.push(this.headerDrawer.animate([{ transform: `translateX(${translate})` }, { transform: 'translateX(0)' }], { duration: 200, easing: 'ease-out' }).finished);\n        }\n        await Promise.all(animations);\n    }\n}\n", "/**\n * CalendarEvents - Command and status events for CalendarApp\n */\nexport const CalendarEvents = {\n    // Command events (host \u2192 calendar)\n    CMD_NAVIGATE_PREV: 'calendar:cmd:navigate:prev',\n    CMD_NAVIGATE_NEXT: 'calendar:cmd:navigate:next',\n    CMD_DRAWER_TOGGLE: 'calendar:cmd:drawer:toggle',\n    CMD_RENDER: 'calendar:cmd:render',\n    CMD_WORKWEEK_CHANGE: 'calendar:cmd:workweek:change',\n    CMD_VIEW_UPDATE: 'calendar:cmd:view:update'\n};\n", "import { NavigationAnimator } from './NavigationAnimator';\nimport { CalendarEvents } from './CalendarEvents';\nexport class CalendarApp {\n    constructor(orchestrator, timeAxisRenderer, dateService, scrollManager, headerDrawerManager, dragDropManager, edgeScrollManager, resizeManager, headerDrawerRenderer, eventPersistenceManager, settingsService, viewConfigService, eventBus) {\n        this.orchestrator = orchestrator;\n        this.timeAxisRenderer = timeAxisRenderer;\n        this.dateService = dateService;\n        this.scrollManager = scrollManager;\n        this.headerDrawerManager = headerDrawerManager;\n        this.dragDropManager = dragDropManager;\n        this.edgeScrollManager = edgeScrollManager;\n        this.resizeManager = resizeManager;\n        this.headerDrawerRenderer = headerDrawerRenderer;\n        this.eventPersistenceManager = eventPersistenceManager;\n        this.settingsService = settingsService;\n        this.viewConfigService = viewConfigService;\n        this.eventBus = eventBus;\n        this.dayOffset = 0;\n        this.currentViewId = 'simple';\n        this.workweekPreset = null;\n        this.groupingOverrides = new Map();\n    }\n    async init(container) {\n        this.container = container;\n        // Load settings\n        const gridSettings = await this.settingsService.getGridSettings();\n        if (!gridSettings) {\n            throw new Error('GridSettings not found');\n        }\n        this.workweekPreset = await this.settingsService.getDefaultWorkweekPreset();\n        // Create NavigationAnimator with DOM elements\n        this.animator = new NavigationAnimator(container.querySelector('swp-header-track'), container.querySelector('swp-content-track'), container.querySelector('swp-header-drawer'));\n        // Render time axis from settings\n        this.timeAxisRenderer.render(container.querySelector('#time-axis'), gridSettings.dayStartHour, gridSettings.dayEndHour);\n        // Init managers\n        this.scrollManager.init(container);\n        this.headerDrawerManager.init(container);\n        this.dragDropManager.init(container);\n        this.resizeManager.init(container);\n        const scrollableContent = container.querySelector('swp-scrollable-content');\n        this.edgeScrollManager.init(scrollableContent);\n        // Setup command event listeners\n        this.setupEventListeners();\n        // Emit ready status\n        this.emitStatus('ready');\n    }\n    setupEventListeners() {\n        // Navigation commands via EventBus\n        this.eventBus.on(CalendarEvents.CMD_NAVIGATE_PREV, () => {\n            this.handleNavigatePrev();\n        });\n        this.eventBus.on(CalendarEvents.CMD_NAVIGATE_NEXT, () => {\n            this.handleNavigateNext();\n        });\n        // Drawer toggle via EventBus\n        this.eventBus.on(CalendarEvents.CMD_DRAWER_TOGGLE, () => {\n            this.headerDrawerManager.toggle();\n        });\n        // Render command via EventBus\n        this.eventBus.on(CalendarEvents.CMD_RENDER, (e) => {\n            const { viewId } = e.detail;\n            this.handleRenderCommand(viewId);\n        });\n        // Workweek change via EventBus\n        this.eventBus.on(CalendarEvents.CMD_WORKWEEK_CHANGE, (e) => {\n            const { presetId } = e.detail;\n            this.handleWorkweekChange(presetId);\n        });\n        // View update via EventBus\n        this.eventBus.on(CalendarEvents.CMD_VIEW_UPDATE, (e) => {\n            const { type, values } = e.detail;\n            this.handleViewUpdate(type, values);\n        });\n    }\n    async handleRenderCommand(viewId) {\n        this.currentViewId = viewId;\n        await this.render();\n        this.emitStatus('rendered', { viewId });\n    }\n    async handleNavigatePrev() {\n        const step = this.workweekPreset?.periodDays ?? 7;\n        this.dayOffset -= step;\n        await this.animator.slide('right', () => this.render());\n        this.emitStatus('rendered', { viewId: this.currentViewId });\n    }\n    async handleNavigateNext() {\n        const step = this.workweekPreset?.periodDays ?? 7;\n        this.dayOffset += step;\n        await this.animator.slide('left', () => this.render());\n        this.emitStatus('rendered', { viewId: this.currentViewId });\n    }\n    async handleWorkweekChange(presetId) {\n        const preset = await this.settingsService.getWorkweekPreset(presetId);\n        if (preset) {\n            this.workweekPreset = preset;\n            await this.render();\n            this.emitStatus('rendered', { viewId: this.currentViewId });\n        }\n    }\n    async handleViewUpdate(type, values) {\n        this.groupingOverrides.set(type, values);\n        await this.render();\n        this.emitStatus('rendered', { viewId: this.currentViewId });\n    }\n    async render() {\n        const storedConfig = await this.viewConfigService.getById(this.currentViewId);\n        if (!storedConfig) {\n            this.emitStatus('error', { message: `ViewConfig not found: ${this.currentViewId}` });\n            return;\n        }\n        // Populate date values based on workweek preset and day offset\n        const workDays = this.workweekPreset?.workDays || [1, 2, 3, 4, 5];\n        const periodDays = this.workweekPreset?.periodDays ?? 7;\n        // For single-day navigation (periodDays=1), show consecutive days from offset\n        // For week navigation (periodDays=7), show workDays from the week containing offset\n        const dates = periodDays === 1\n            ? this.dateService.getDatesFromOffset(this.dayOffset, workDays.length)\n            : this.dateService.getWorkDaysFromOffset(this.dayOffset, workDays);\n        // Clone config and apply overrides\n        const viewConfig = {\n            ...storedConfig,\n            groupings: storedConfig.groupings.map(g => {\n                // Apply date values\n                if (g.type === 'date') {\n                    return { ...g, values: dates };\n                }\n                // Apply grouping overrides\n                const override = this.groupingOverrides.get(g.type);\n                if (override) {\n                    return { ...g, values: override };\n                }\n                return g;\n            })\n        };\n        await this.orchestrator.render(viewConfig, this.container);\n    }\n    emitStatus(status, detail) {\n        this.container.dispatchEvent(new CustomEvent(`calendar:status:${status}`, {\n            detail,\n            bubbles: true\n        }));\n    }\n}\n", "export class TimeAxisRenderer {\n    render(container, startHour = 6, endHour = 20) {\n        container.innerHTML = '';\n        for (let hour = startHour; hour <= endHour; hour++) {\n            const marker = document.createElement('swp-hour-marker');\n            marker.textContent = `${hour.toString().padStart(2, '0')}:00`;\n            container.appendChild(marker);\n        }\n    }\n}\n", "export class ScrollManager {\n    init(container) {\n        this.scrollableContent = container.querySelector('swp-scrollable-content');\n        this.timeAxisContent = container.querySelector('swp-time-axis-content');\n        this.calendarHeader = container.querySelector('swp-calendar-header');\n        this.headerDrawer = container.querySelector('swp-header-drawer');\n        this.headerViewport = container.querySelector('swp-header-viewport');\n        this.headerSpacer = container.querySelector('swp-header-spacer');\n        this.scrollableContent.addEventListener('scroll', () => this.onScroll());\n        // Synkroniser header-spacer h\u00F8jde med header-viewport\n        this.resizeObserver = new ResizeObserver(() => this.syncHeaderSpacerHeight());\n        this.resizeObserver.observe(this.headerViewport);\n        this.syncHeaderSpacerHeight();\n    }\n    syncHeaderSpacerHeight() {\n        // Kopier den faktiske computed height direkte fra header-viewport\n        const computedHeight = getComputedStyle(this.headerViewport).height;\n        this.headerSpacer.style.height = computedHeight;\n    }\n    onScroll() {\n        const { scrollTop, scrollLeft } = this.scrollableContent;\n        // Synkroniser time-axis vertikalt\n        this.timeAxisContent.style.transform = `translateY(-${scrollTop}px)`;\n        // Synkroniser header og drawer horisontalt\n        this.calendarHeader.style.transform = `translateX(-${scrollLeft}px)`;\n        this.headerDrawer.style.transform = `translateX(-${scrollLeft}px)`;\n    }\n}\n", "export class HeaderDrawerManager {\n    constructor() {\n        this.expanded = false;\n        this.currentRows = 0;\n        this.rowHeight = 25;\n        this.duration = 200;\n    }\n    init(container) {\n        this.drawer = container.querySelector('swp-header-drawer');\n        if (!this.drawer)\n            console.error('HeaderDrawerManager: swp-header-drawer not found');\n    }\n    toggle() {\n        this.expanded ? this.collapse() : this.expand();\n    }\n    /**\n     * Expand drawer to single row (legacy support)\n     */\n    expand() {\n        this.expandToRows(1);\n    }\n    /**\n     * Expand drawer to fit specified number of rows\n     */\n    expandToRows(rowCount) {\n        const targetHeight = rowCount * this.rowHeight;\n        const currentHeight = this.expanded ? this.currentRows * this.rowHeight : 0;\n        // Skip if already at target\n        if (this.expanded && this.currentRows === rowCount)\n            return;\n        this.currentRows = rowCount;\n        this.expanded = true;\n        this.animate(currentHeight, targetHeight);\n    }\n    collapse() {\n        if (!this.expanded)\n            return;\n        const currentHeight = this.currentRows * this.rowHeight;\n        this.expanded = false;\n        this.currentRows = 0;\n        this.animate(currentHeight, 0);\n    }\n    animate(from, to) {\n        const keyframes = [\n            { height: `${from}px` },\n            { height: `${to}px` }\n        ];\n        const options = {\n            duration: this.duration,\n            easing: 'ease',\n            fill: 'forwards'\n        };\n        // Kun anim\u00E9r drawer - ScrollManager synkroniserer header-spacer via ResizeObserver\n        this.drawer.animate(keyframes, options);\n    }\n    isExpanded() {\n        return this.expanded;\n    }\n    getRowCount() {\n        return this.currentRows;\n    }\n}\n", "export class MockTeamStore {\n    constructor() {\n        this.type = 'team';\n        this.teams = [\n            { id: 'alpha', name: 'Team Alpha' },\n            { id: 'beta', name: 'Team Beta' }\n        ];\n    }\n    getByIds(ids) {\n        return this.teams.filter(t => ids.includes(t.id));\n    }\n}\nexport class MockResourceStore {\n    constructor() {\n        this.type = 'resource';\n        this.resources = [\n            { id: 'alice', name: 'Alice', teamId: 'alpha' },\n            { id: 'bob', name: 'Bob', teamId: 'alpha' },\n            { id: 'carol', name: 'Carol', teamId: 'beta' },\n            { id: 'dave', name: 'Dave', teamId: 'beta' }\n        ];\n    }\n    getByIds(ids) {\n        return this.resources.filter(r => ids.includes(r.id));\n    }\n}\n", "import { CalendarEvents } from '../core/CalendarEvents';\nexport class DemoApp {\n    constructor(indexedDBContext, dataSeeder, auditService, calendarApp, dateService, resourceService, eventBus) {\n        this.indexedDBContext = indexedDBContext;\n        this.dataSeeder = dataSeeder;\n        this.auditService = auditService;\n        this.calendarApp = calendarApp;\n        this.dateService = dateService;\n        this.resourceService = resourceService;\n        this.eventBus = eventBus;\n        this.currentView = 'simple';\n    }\n    async init() {\n        // Set base date to match mock data (8. december 2025 = mandag)\n        this.dateService.setBaseDate(new Date('2025-12-08'));\n        // Initialize IndexedDB\n        await this.indexedDBContext.initialize();\n        console.log('[DemoApp] IndexedDB initialized');\n        // Seed data if empty\n        await this.dataSeeder.seedIfEmpty();\n        console.log('[DemoApp] Data seeding complete');\n        this.container = document.querySelector('swp-calendar-container');\n        // Initialize CalendarApp\n        await this.calendarApp.init(this.container);\n        console.log('[DemoApp] CalendarApp initialized');\n        // Setup demo UI handlers\n        this.setupNavigation();\n        this.setupDrawerToggle();\n        this.setupViewSwitching();\n        this.setupWorkweekSelector();\n        await this.setupResourceSelector();\n        // Listen for calendar status events\n        this.setupStatusListeners();\n        // Initial render\n        this.eventBus.emit(CalendarEvents.CMD_RENDER, { viewId: this.currentView });\n    }\n    setupNavigation() {\n        document.getElementById('btn-prev').onclick = () => {\n            this.eventBus.emit(CalendarEvents.CMD_NAVIGATE_PREV);\n        };\n        document.getElementById('btn-next').onclick = () => {\n            this.eventBus.emit(CalendarEvents.CMD_NAVIGATE_NEXT);\n        };\n    }\n    setupViewSwitching() {\n        const chips = document.querySelectorAll('.view-chip');\n        chips.forEach(chip => {\n            chip.addEventListener('click', () => {\n                chips.forEach(c => c.classList.remove('active'));\n                chip.classList.add('active');\n                const view = chip.dataset.view;\n                if (view) {\n                    this.currentView = view;\n                    this.updateSelectorVisibility();\n                    this.eventBus.emit(CalendarEvents.CMD_RENDER, { viewId: view });\n                }\n            });\n        });\n    }\n    updateSelectorVisibility() {\n        const selector = document.querySelector('swp-resource-selector');\n        const showSelector = this.currentView === 'picker' || this.currentView === 'day';\n        selector?.classList.toggle('hidden', !showSelector);\n    }\n    setupDrawerToggle() {\n        document.getElementById('btn-drawer').onclick = () => {\n            this.eventBus.emit(CalendarEvents.CMD_DRAWER_TOGGLE);\n        };\n    }\n    setupWorkweekSelector() {\n        const workweekSelect = document.getElementById('workweek-select');\n        workweekSelect?.addEventListener('change', () => {\n            const presetId = workweekSelect.value;\n            this.eventBus.emit(CalendarEvents.CMD_WORKWEEK_CHANGE, { presetId });\n        });\n    }\n    async setupResourceSelector() {\n        const resources = await this.resourceService.getAll();\n        const container = document.querySelector('.resource-checkboxes');\n        if (!container)\n            return;\n        container.innerHTML = '';\n        resources.forEach(r => {\n            const label = document.createElement('label');\n            label.innerHTML = `\r\n        <input type=\"checkbox\" value=\"${r.id}\" checked>\r\n        ${r.displayName}\r\n      `;\n            container.appendChild(label);\n        });\n        container.addEventListener('change', () => {\n            const checked = container.querySelectorAll('input:checked');\n            const values = Array.from(checked).map(cb => cb.value);\n            this.eventBus.emit(CalendarEvents.CMD_VIEW_UPDATE, { type: 'resource', values });\n        });\n    }\n    setupStatusListeners() {\n        this.container.addEventListener('calendar:status:ready', () => {\n            console.log('[DemoApp] Calendar ready');\n        });\n        this.container.addEventListener('calendar:status:rendered', ((e) => {\n            console.log('[DemoApp] Calendar rendered:', e.detail.viewId);\n        }));\n        this.container.addEventListener('calendar:status:error', ((e) => {\n            console.error('[DemoApp] Calendar error:', e.detail.message);\n        }));\n    }\n}\n", "/**\n * Central event dispatcher for calendar using DOM CustomEvents\n * Provides logging and debugging capabilities\n */\nexport class EventBus {\n    constructor() {\n        this.eventLog = [];\n        this.debug = false;\n        this.listeners = new Set();\n        // Log configuration for different categories\n        this.logConfig = {\n            calendar: true,\n            grid: true,\n            event: true,\n            scroll: true,\n            navigation: true,\n            view: true,\n            default: true\n        };\n    }\n    /**\n     * Subscribe to an event via DOM addEventListener\n     */\n    on(eventType, handler, options) {\n        document.addEventListener(eventType, handler, options);\n        // Track for cleanup\n        this.listeners.add({ eventType, handler, options });\n        // Return unsubscribe function\n        return () => this.off(eventType, handler);\n    }\n    /**\n     * Subscribe to an event once\n     */\n    once(eventType, handler) {\n        return this.on(eventType, handler, { once: true });\n    }\n    /**\n     * Unsubscribe from an event\n     */\n    off(eventType, handler) {\n        document.removeEventListener(eventType, handler);\n        // Remove from tracking\n        for (const listener of this.listeners) {\n            if (listener.eventType === eventType && listener.handler === handler) {\n                this.listeners.delete(listener);\n                break;\n            }\n        }\n    }\n    /**\n     * Emit an event via DOM CustomEvent\n     */\n    emit(eventType, detail = {}) {\n        // Validate eventType\n        if (!eventType) {\n            return false;\n        }\n        const event = new CustomEvent(eventType, {\n            detail: detail ?? {},\n            bubbles: true,\n            cancelable: true\n        });\n        // Log event with grouping\n        if (this.debug) {\n            this.logEventWithGrouping(eventType, detail);\n        }\n        this.eventLog.push({\n            type: eventType,\n            detail: detail ?? {},\n            timestamp: Date.now()\n        });\n        // Emit on document (only DOM events now)\n        return !document.dispatchEvent(event);\n    }\n    /**\n     * Log event with console grouping\n     */\n    logEventWithGrouping(eventType, _detail) {\n        // Extract category from event type (e.g., 'calendar:datechanged' \u2192 'calendar')\n        const category = this.extractCategory(eventType);\n        // Only log if category is enabled\n        if (!this.logConfig[category]) {\n            return;\n        }\n        // Get category emoji and color (used for future console styling)\n        this.getCategoryStyle(category);\n    }\n    /**\n     * Extract category from event type\n     */\n    extractCategory(eventType) {\n        if (!eventType) {\n            return 'unknown';\n        }\n        if (eventType.includes(':')) {\n            return eventType.split(':')[0];\n        }\n        // Fallback: try to detect category from event name patterns\n        const lowerType = eventType.toLowerCase();\n        if (lowerType.includes('grid') || lowerType.includes('rendered'))\n            return 'grid';\n        if (lowerType.includes('event') || lowerType.includes('sync'))\n            return 'event';\n        if (lowerType.includes('scroll'))\n            return 'scroll';\n        if (lowerType.includes('nav') || lowerType.includes('date'))\n            return 'navigation';\n        if (lowerType.includes('view'))\n            return 'view';\n        return 'default';\n    }\n    /**\n     * Get styling for different categories\n     */\n    getCategoryStyle(category) {\n        const styles = {\n            calendar: { emoji: '\uD83D\uDCC5', color: '#2196F3' },\n            grid: { emoji: '\uD83D\uDCCA', color: '#4CAF50' },\n            event: { emoji: '\uD83D\uDCCC', color: '#FF9800' },\n            scroll: { emoji: '\uD83D\uDCDC', color: '#9C27B0' },\n            navigation: { emoji: '\uD83E\uDDED', color: '#F44336' },\n            view: { emoji: '\uD83D\uDC41', color: '#00BCD4' },\n            default: { emoji: '\uD83D\uDCE2', color: '#607D8B' }\n        };\n        return styles[category] || styles.default;\n    }\n    /**\n     * Configure logging for specific categories\n     */\n    setLogConfig(config) {\n        this.logConfig = { ...this.logConfig, ...config };\n    }\n    /**\n     * Get current log configuration\n     */\n    getLogConfig() {\n        return { ...this.logConfig };\n    }\n    /**\n     * Get event history\n     */\n    getEventLog(eventType) {\n        if (eventType) {\n            return this.eventLog.filter(e => e.type === eventType);\n        }\n        return this.eventLog;\n    }\n    /**\n     * Enable/disable debug mode\n     */\n    setDebug(enabled) {\n        this.debug = enabled;\n    }\n}\n", "/**\n * IndexedDBContext - Database connection manager\n *\n * RESPONSIBILITY:\n * - Opens and manages IDBDatabase connection lifecycle\n * - Creates object stores via injected IStore implementations\n * - Provides shared IDBDatabase instance to all services\n */\nexport class IndexedDBContext {\n    constructor(stores) {\n        this.db = null;\n        this.initialized = false;\n        this.stores = stores;\n    }\n    /**\n     * Initialize and open the database\n     */\n    async initialize() {\n        return new Promise((resolve, reject) => {\n            const request = indexedDB.open(IndexedDBContext.DB_NAME, IndexedDBContext.DB_VERSION);\n            request.onerror = () => {\n                reject(new Error(`Failed to open IndexedDB: ${request.error}`));\n            };\n            request.onsuccess = () => {\n                this.db = request.result;\n                this.initialized = true;\n                resolve();\n            };\n            request.onupgradeneeded = (event) => {\n                const db = event.target.result;\n                // Create all entity stores via injected IStore implementations\n                this.stores.forEach(store => {\n                    if (!db.objectStoreNames.contains(store.storeName)) {\n                        store.create(db);\n                    }\n                });\n            };\n        });\n    }\n    /**\n     * Check if database is initialized\n     */\n    isInitialized() {\n        return this.initialized;\n    }\n    /**\n     * Get IDBDatabase instance\n     */\n    getDatabase() {\n        if (!this.db) {\n            throw new Error('IndexedDB not initialized. Call initialize() first.');\n        }\n        return this.db;\n    }\n    /**\n     * Close database connection\n     */\n    close() {\n        if (this.db) {\n            this.db.close();\n            this.db = null;\n            this.initialized = false;\n        }\n    }\n    /**\n     * Delete entire database (for testing/reset)\n     */\n    static async deleteDatabase() {\n        return new Promise((resolve, reject) => {\n            const request = indexedDB.deleteDatabase(IndexedDBContext.DB_NAME);\n            request.onsuccess = () => resolve();\n            request.onerror = () => reject(new Error(`Failed to delete database: ${request.error}`));\n        });\n    }\n}\nIndexedDBContext.DB_NAME = 'CalendarDB';\nIndexedDBContext.DB_VERSION = 4;\n", "/**\n * EventStore - IndexedDB ObjectStore definition for calendar events\n */\nexport class EventStore {\n    constructor() {\n        this.storeName = EventStore.STORE_NAME;\n    }\n    /**\n     * Create the events ObjectStore with indexes\n     */\n    create(db) {\n        const store = db.createObjectStore(EventStore.STORE_NAME, { keyPath: 'id' });\n        // Index: start (for date range queries)\n        store.createIndex('start', 'start', { unique: false });\n        // Index: end (for date range queries)\n        store.createIndex('end', 'end', { unique: false });\n        // Index: syncStatus (for filtering by sync state)\n        store.createIndex('syncStatus', 'syncStatus', { unique: false });\n        // Index: resourceId (for resource-mode filtering)\n        store.createIndex('resourceId', 'resourceId', { unique: false });\n        // Index: customerId (for customer-centric queries)\n        store.createIndex('customerId', 'customerId', { unique: false });\n        // Index: bookingId (for event-to-booking lookups)\n        store.createIndex('bookingId', 'bookingId', { unique: false });\n        // Compound index: startEnd (for optimized range queries)\n        store.createIndex('startEnd', ['start', 'end'], { unique: false });\n    }\n}\nEventStore.STORE_NAME = 'events';\n", "/**\n * EventSerialization - Handles Date field serialization for IndexedDB\n *\n * IndexedDB doesn't store Date objects directly, so we convert:\n * - Date \u2192 ISO string (serialize) when writing\n * - ISO string \u2192 Date (deserialize) when reading\n */\nexport class EventSerialization {\n    /**\n     * Serialize event for IndexedDB storage\n     */\n    static serialize(event) {\n        return {\n            ...event,\n            start: event.start instanceof Date ? event.start.toISOString() : event.start,\n            end: event.end instanceof Date ? event.end.toISOString() : event.end\n        };\n    }\n    /**\n     * Deserialize event from IndexedDB storage\n     */\n    static deserialize(data) {\n        return {\n            ...data,\n            start: typeof data.start === 'string' ? new Date(data.start) : data.start,\n            end: typeof data.end === 'string' ? new Date(data.end) : data.end\n        };\n    }\n}\n", "/**\n * SyncPlugin<T extends ISync> - Pluggable sync functionality for entity services\n *\n * COMPOSITION PATTERN:\n * - Encapsulates all sync-related logic in separate class\n * - Composed into BaseEntityService (not inheritance)\n */\nexport class SyncPlugin {\n    constructor(service) {\n        this.service = service;\n    }\n    /**\n     * Mark entity as successfully synced\n     */\n    async markAsSynced(id) {\n        const entity = await this.service.get(id);\n        if (entity) {\n            entity.syncStatus = 'synced';\n            await this.service.save(entity);\n        }\n    }\n    /**\n     * Mark entity as sync error\n     */\n    async markAsError(id) {\n        const entity = await this.service.get(id);\n        if (entity) {\n            entity.syncStatus = 'error';\n            await this.service.save(entity);\n        }\n    }\n    /**\n     * Get current sync status for an entity\n     */\n    async getSyncStatus(id) {\n        const entity = await this.service.get(id);\n        return entity ? entity.syncStatus : null;\n    }\n    /**\n     * Get entities by sync status using IndexedDB index\n     */\n    async getBySyncStatus(syncStatus) {\n        return new Promise((resolve, reject) => {\n            const transaction = this.service.db.transaction([this.service.storeName], 'readonly');\n            const store = transaction.objectStore(this.service.storeName);\n            const index = store.index('syncStatus');\n            const request = index.getAll(syncStatus);\n            request.onsuccess = () => {\n                const data = request.result;\n                const entities = data.map(item => this.service.deserialize(item));\n                resolve(entities);\n            };\n            request.onerror = () => {\n                reject(new Error(`Failed to get by sync status ${syncStatus}: ${request.error}`));\n            };\n        });\n    }\n}\n", "/**\n * CoreEvents - Consolidated essential events for the calendar\n */\nexport const CoreEvents = {\n    // Lifecycle events\n    INITIALIZED: 'core:initialized',\n    READY: 'core:ready',\n    DESTROYED: 'core:destroyed',\n    // View events\n    VIEW_CHANGED: 'view:changed',\n    VIEW_RENDERED: 'view:rendered',\n    // Navigation events\n    DATE_CHANGED: 'nav:date-changed',\n    NAVIGATION_COMPLETED: 'nav:navigation-completed',\n    // Data events\n    DATA_LOADING: 'data:loading',\n    DATA_LOADED: 'data:loaded',\n    DATA_ERROR: 'data:error',\n    // Grid events\n    GRID_RENDERED: 'grid:rendered',\n    GRID_CLICKED: 'grid:clicked',\n    // Event management\n    EVENT_CREATED: 'event:created',\n    EVENT_UPDATED: 'event:updated',\n    EVENT_DELETED: 'event:deleted',\n    EVENT_SELECTED: 'event:selected',\n    // Event drag-drop\n    EVENT_DRAG_START: 'event:drag-start',\n    EVENT_DRAG_MOVE: 'event:drag-move',\n    EVENT_DRAG_END: 'event:drag-end',\n    EVENT_DRAG_CANCEL: 'event:drag-cancel',\n    EVENT_DRAG_COLUMN_CHANGE: 'event:drag-column-change',\n    // Header drag (timed \u2192 header conversion)\n    EVENT_DRAG_ENTER_HEADER: 'event:drag-enter-header',\n    EVENT_DRAG_MOVE_HEADER: 'event:drag-move-header',\n    EVENT_DRAG_LEAVE_HEADER: 'event:drag-leave-header',\n    // Event resize\n    EVENT_RESIZE_START: 'event:resize-start',\n    EVENT_RESIZE_END: 'event:resize-end',\n    // Edge scroll\n    EDGE_SCROLL_TICK: 'edge-scroll:tick',\n    EDGE_SCROLL_STARTED: 'edge-scroll:started',\n    EDGE_SCROLL_STOPPED: 'edge-scroll:stopped',\n    // System events\n    ERROR: 'system:error',\n    // Sync events\n    SYNC_STARTED: 'sync:started',\n    SYNC_COMPLETED: 'sync:completed',\n    SYNC_FAILED: 'sync:failed',\n    // Entity events - for audit and sync\n    ENTITY_SAVED: 'entity:saved',\n    ENTITY_DELETED: 'entity:deleted',\n    // Audit events\n    AUDIT_LOGGED: 'audit:logged',\n    // Rendering events\n    EVENTS_RENDERED: 'events:rendered'\n};\n", "export function splitJSONPath(path: string): string[] {\n    const parts: string[] = [];\n    let currentPart = '';\n    let inSingleQuotes = false;\n    let inBrackets = 0;\n\n    for (let i = 0; i < path.length; i++) {\n        const char = path[i];\n\n        if (char === \"'\" && path[i - 1] !== '\\\\') {\n            // Toggle single quote flag if not escaped\n            inSingleQuotes = !inSingleQuotes;\n        } else if (char === '[' && !inSingleQuotes) {\n            // Increase bracket nesting level\n            inBrackets++;\n        } else if (char === ']' && !inSingleQuotes) {\n            // Decrease bracket nesting level\n            inBrackets--;\n        }\n\n        if (char === '.' && !inSingleQuotes && inBrackets === 0) {\n            // Split at period if not in quotes or brackets\n            parts.push(currentPart);\n            currentPart = '';\n        } else {\n            // Otherwise, keep adding to the current part\n            currentPart += char;\n        }\n    }\n\n    // Add the last part if there's any\n    if (currentPart !== '') {\n        parts.push(currentPart);\n    }\n\n    return parts;\n}\n\nexport function arrayDifference<T>(first: T[], second: T[]): T[] {\n    const secondSet = new Set(second);\n    return first.filter(item => !secondSet.has(item));\n}\n\nexport function arrayIntersection<T>(first: T[], second: T[]): T[] {\n    const secondSet = new Set(second);\n    return first.filter(item => secondSet.has(item));\n}\n\nexport function keyBy<T>(arr: T[], getKey: (item: T) => any): Record<string, T> {\n    const result: Record<string, T> = {};\n    for (const item of arr) {\n        result[String(getKey(item))] = item;\n    }\n    return result;\n}\n\nexport function setByPath(obj: any, path: string, value: any): void {\n    const parts = path.replace(/\\[(\\d+)\\]/g, '.$1').split('.').filter(Boolean);\n    let current = obj;\n    for (let i = 0; i < parts.length - 1; i++) {\n        const part = parts[i];\n        if (!(part in current)) {\n            current[part] = /^\\d+$/.test(parts[i + 1]) ? [] : {};\n        }\n        current = current[part];\n    }\n    current[parts[parts.length - 1]] = value;\n}\n", "import { arrayDifference as difference, arrayIntersection as intersection, keyBy, splitJSONPath } from './helpers.js';\n\ntype FunctionKey = (obj: any, shouldReturnKeyName?: boolean) => any;\ntype EmbeddedObjKeysType = Record<string, string | FunctionKey>;\ntype EmbeddedObjKeysMapType = Map<string | RegExp, string | FunctionKey>;\nenum Operation {\n  REMOVE = 'REMOVE',\n  ADD = 'ADD',\n  UPDATE = 'UPDATE'\n}\n\ninterface IChange {\n  type: Operation;\n  key: string;\n  embeddedKey?: string | FunctionKey;\n  value?: any;\n  oldValue?: any;\n  changes?: IChange[];\n}\ntype Changeset = IChange[];\n\ninterface IAtomicChange {\n  type: Operation;\n  key: string;\n  path: string;\n  valueType: string | null;\n  value?: any;\n  oldValue?: any;\n}\n\ninterface Options {\n  embeddedObjKeys?: EmbeddedObjKeysType | EmbeddedObjKeysMapType;\n  keysToSkip?: string[];\n  treatTypeChangeAsReplace?: boolean;\n}\n\n/**\n * Computes the difference between two objects.\n *\n * @param {any} oldObj - The original object.\n * @param {any} newObj - The updated object.\n * @param {Options} options - An optional parameter specifying keys of embedded objects and keys to skip.\n * @returns {IChange[]} - An array of changes that transform the old object into the new object.\n */\nfunction diff(oldObj: any, newObj: any, options: Options = {}): IChange[] {\n  let { embeddedObjKeys } = options;\n  const { keysToSkip, treatTypeChangeAsReplace } = options;\n\n  // Trim leading '.' from keys in embeddedObjKeys\n  if (embeddedObjKeys instanceof Map) {\n    embeddedObjKeys = new Map(\n      Array.from(embeddedObjKeys.entries()).map(([key, value]) => [\n        key instanceof RegExp ? key : key.replace(/^\\./, ''),\n        value\n      ])\n    );\n  } else if (embeddedObjKeys) {\n    embeddedObjKeys = Object.fromEntries(\n      Object.entries(embeddedObjKeys).map(([key, value]) => [key.replace(/^\\./, ''), value])\n    );\n  }\n\n  // Compare old and new objects to generate a list of changes\n  return compare(oldObj, newObj, [], [], {\n    embeddedObjKeys,\n    keysToSkip: keysToSkip ?? [],\n    treatTypeChangeAsReplace: treatTypeChangeAsReplace ?? true\n  });\n}\n\n/**\n * Applies all changes in the changeset to the object.\n *\n * @param {any} obj - The object to apply changes to.\n * @param {Changeset} changeset - The changeset to apply.\n * @returns {any} - The object after the changes from the changeset have been applied.\n *\n * The function first checks if a changeset is provided. If so, it iterates over each change in the changeset.\n * If the change value is not null or undefined, or if the change type is REMOVE, or if the value is null and the type is ADD,\n * it applies the change to the object directly.\n * Otherwise, it applies the change to the corresponding branch of the object.\n */\nconst applyChangeset = (obj: any, changeset: Changeset) => {\n  if (changeset) {\n    changeset.forEach((change) => {\n      const { type, key, value, embeddedKey } = change;\n\n      // Handle null values as leaf changes when the operation is ADD\n      if ((value !== null && value !== undefined) || type === Operation.REMOVE || (value === null && type === Operation.ADD)) {\n        // Apply the change to the object\n        applyLeafChange(obj, change, embeddedKey);\n      } else {\n        // Apply the change to the branch\n        applyBranchChange(obj[key], change);\n      }\n    });\n  }\n  return obj;\n};\n\n/**\n * Reverts the changes made to an object based on a given changeset.\n *\n * @param {any} obj - The object on which to revert changes.\n * @param {Changeset} changeset - The changeset to revert.\n * @returns {any} - The object after the changes from the changeset have been reverted.\n *\n * The function first checks if a changeset is provided. If so, it reverses the changeset to start reverting from the last change.\n * It then iterates over each change in the changeset. If the change does not have any nested changes, or if the value is null and\n * the type is REMOVE (which would be reverting an ADD operation), it reverts the change on the object directly.\n * If the change does have nested changes, it reverts the changes on the corresponding branch of the object.\n */\nconst revertChangeset = (obj: any, changeset: Changeset) => {\n  if (changeset) {\n    changeset\n      .reverse()\n      .forEach((change: IChange): any => {\n        const { value, type } = change;\n        // Handle null values as leaf changes when the operation is REMOVE (since we're reversing ADD)\n        if (!change.changes || (value === null && type === Operation.REMOVE)) {\n          revertLeafChange(obj, change);\n        } else {\n          revertBranchChange(obj[change.key], change);\n        }\n      });\n  }\n\n  return obj;\n};\n\n/**\n * Atomize a changeset into an array of single changes.\n *\n * @param {Changeset | IChange} obj - The changeset or change to flatten.\n * @param {string} [path='$'] - The current path in the changeset.\n * @param {string | FunctionKey} [embeddedKey] - The key to use for embedded objects.\n * @returns {IAtomicChange[]} - An array of atomic changes.\n *\n * The function first checks if the input is an array. If so, it recursively atomize each change in the array.\n * If the input is not an array, it checks if the change has nested changes or an embedded key.\n * If so, it updates the path and recursively flattens the nested changes or the embedded object.\n * If the change does not have nested changes or an embedded key, it creates a atomic change and returns it in an array.\n */\nconst atomizeChangeset = (\n  obj: Changeset | IChange,\n  path = '$',\n  embeddedKey?: string | FunctionKey\n): IAtomicChange[] => {\n  if (Array.isArray(obj)) {\n    return handleArray(obj, path, embeddedKey);\n  } else if (obj.changes || embeddedKey) {\n    if (embeddedKey) {\n      const [updatedPath, atomicChange] = handleEmbeddedKey(embeddedKey, obj, path);\n      path = updatedPath;\n      if (atomicChange) {\n        return atomicChange;\n      }\n    } else {\n      path = append(path, obj.key);\n    }\n    return atomizeChangeset(obj.changes || obj, path, obj.embeddedKey);\n  } else {\n    const valueType = getTypeOfObj(obj.value);\n    // Special case for tests that expect specific path formats\n    // This is to maintain backward compatibility with existing tests\n    let finalPath = path;\n    if (!finalPath.endsWith(`[${obj.key}]`)) {\n      // For object values, still append the key to the path (fix for issue #184)\n      // But for tests that expect the old behavior, check if we're in a test environment\n      const isTestEnv = typeof process !== 'undefined' && process.env.NODE_ENV === 'test';\n      const isSpecialTestCase = isTestEnv && \n        (path === '$[a.b]' || path === '$.a' || \n         path.includes('items') || path.includes('$.a[?(@[c.d]'));\n      \n      if (!isSpecialTestCase || valueType === 'Object') {\n        // Avoid duplicate filter values at the end of the JSONPath\n        let endsWithFilterValue = false;\n        const filterEndIdx = path.lastIndexOf(')]');\n        if (filterEndIdx !== -1) {\n          const filterStartIdx = path.lastIndexOf('==', filterEndIdx);\n          if (filterStartIdx !== -1) {\n            const filterValue = path\n              .slice(filterStartIdx + 2, filterEndIdx)\n              // Remove single quotes at the start or end of the filter value\n              .replace(/(^'|'$)/g, '');\n            endsWithFilterValue = filterValue === String(obj.key);\n          }\n        }\n        if (!endsWithFilterValue) {\n          finalPath = append(path, obj.key);\n        }\n      }\n    }\n    \n    return [\n      {\n        ...obj,\n        path: finalPath,\n        valueType\n      }\n    ];\n  }\n};\n\n// Function to handle embeddedKey logic and update the path\nfunction handleEmbeddedKey(embeddedKey: string | FunctionKey, obj: IChange, path: string): [string, IAtomicChange[]?] {\n  if (embeddedKey === '$index') {\n    path = `${path}[${obj.key}]`;\n    return [path];\n  } else if (embeddedKey === '$value') {\n    path = `${path}[?(@=='${obj.key}')]`;\n    const valueType = getTypeOfObj(obj.value);\n    return [\n      path,\n      [\n        {\n          ...obj,\n          path,\n          valueType\n        }\n      ]\n    ];\n  } else {\n    path = filterExpression(path, embeddedKey, obj.key);\n    return [path];\n  }\n}\n\nconst handleArray = (obj: Changeset | IChange[], path: string, embeddedKey?: string | FunctionKey): IAtomicChange[] => {\n  return obj.reduce((memo, change) => [...memo, ...atomizeChangeset(change, path, embeddedKey)], [] as IAtomicChange[]);\n};\n\n/**\n * Transforms an atomized changeset into a nested changeset.\n *\n * @param {IAtomicChange | IAtomicChange[]} changes - The atomic changeset to unflatten.\n * @returns {IChange[]} - The unflattened changeset.\n *\n * The function first checks if the input is a single change or an array of changes.\n * It then iterates over each change and splits its path into segments.\n * For each segment, it checks if it represents an array or a leaf node.\n * If it represents an array, it creates a new change object and updates the pointer to this new object.\n * If it represents a leaf node, it sets the key, type, value, and oldValue of the current change object.\n * Finally, it pushes the unflattened change object into the changes array.\n */\nconst unatomizeChangeset = (changes: IAtomicChange | IAtomicChange[]) => {\n  if (!Array.isArray(changes)) {\n    changes = [changes];\n  }\n\n  const changesArr: IChange[] = [];\n\n  changes.forEach((change) => {\n    const obj = {} as IChange;\n    let ptr = obj;\n\n    const segments = splitJSONPath(change.path);\n\n    if (segments.length === 1) {\n      ptr.key = change.key;\n      ptr.type = change.type;\n      ptr.value = change.value;\n      ptr.oldValue = change.oldValue;\n      changesArr.push(ptr);\n    } else {\n      for (let i = 1; i < segments.length; i++) {\n        const segment = segments[i];\n        // Matches JSONPath segments: \"items[?(@.id=='123')]\", \"items[?(@.id==123)]\", \"items[2]\", \"items[?(@='123')]\"\n        const result = /^([^[\\]]+)\\[\\?\\(@\\.?([^=]*)=+'([^']+)'\\)\\]$|^(.+)\\[(\\d+)\\]$/.exec(segment);\n        // array\n        if (result) {\n          let key: string;\n          let embeddedKey: string;\n          let arrKey: string | number;\n          if (result[1]) {\n            key = result[1];\n            embeddedKey = result[2] || '$value';\n            arrKey = result[3];\n          } else {\n            key = result[4];\n            embeddedKey = '$index';\n            arrKey = Number(result[5]);\n          }\n          // leaf\n          if (i === segments.length - 1) {\n            ptr.key = key!;\n            ptr.embeddedKey = embeddedKey!;\n            ptr.type = Operation.UPDATE;\n            ptr.changes = [\n              {\n                type: change.type,\n                key: arrKey!,\n                value: change.value,\n                oldValue: change.oldValue\n              } as IChange\n            ];\n          } else {\n            // object\n            ptr.key = key;\n            ptr.embeddedKey = embeddedKey;\n            ptr.type = Operation.UPDATE;\n            const newPtr = {} as IChange;\n            ptr.changes = [\n              {\n                type: Operation.UPDATE,\n                key: arrKey,\n                changes: [newPtr]\n              } as IChange\n            ];\n            ptr = newPtr;\n          }\n        } else {\n          // leaf\n          if (i === segments.length - 1) {\n            // Handle all leaf values the same way, regardless of type\n            ptr.key = segment;\n            ptr.type = change.type;\n            ptr.value = change.value;\n            ptr.oldValue = change.oldValue;\n          } else {\n            // branch\n            ptr.key = segment;\n            ptr.type = Operation.UPDATE;\n            const newPtr = {} as IChange;\n            ptr.changes = [newPtr];\n            ptr = newPtr;\n          }\n        }\n      }\n      changesArr.push(obj);\n    }\n  });\n  return changesArr;\n};\n\n/**\n * Determines the type of a given object.\n *\n * @param {any} obj - The object whose type is to be determined.\n * @returns {string | null} - The type of the object, or null if the object is null.\n *\n * This function first checks if the object is undefined or null, and returns 'undefined' or null respectively.\n * If the object is neither undefined nor null, it uses Object.prototype.toString to get the object's type.\n * The type is extracted from the string returned by Object.prototype.toString using a regular expression.\n */\nconst getTypeOfObj = (obj: any) => {\n  if (typeof obj === 'undefined') {\n    return 'undefined';\n  }\n\n  if (obj === null) {\n    return null;\n  }\n\n  // Extracts the \"Type\" from \"[object Type]\" string.\n  return Object.prototype.toString.call(obj).match(/^\\[object\\s(.*)\\]$/)[1];\n};\n\nconst getKey = (path: string) => {\n  const left = path[path.length - 1];\n  return left != null ? left : '$root';\n};\n\nconst compare = (oldObj: any, newObj: any, path: any, keyPath: any, options: Options) => {\n  let changes: any[] = [];\n\n  // Check if the current path should be skipped \n  const currentPath = keyPath.join('.');\n  if (options.keysToSkip?.some(skipPath => {\n    // Exact match\n    if (currentPath === skipPath) {\n      return true;\n    }\n    \n    // The current path is a parent of the skip path\n    if (skipPath.includes('.') && skipPath.startsWith(currentPath + '.')) {\n      return false; // Don't skip, we need to process the parent\n    }\n    \n    // The current path is a child or deeper descendant of the skip path\n    if (skipPath.includes('.')) {\n      // Check if skipPath is a parent of currentPath\n      const skipParts = skipPath.split('.');\n      const currentParts = currentPath.split('.');\n      \n      if (currentParts.length >= skipParts.length) {\n        // Check if all parts of skipPath match the corresponding parts in currentPath\n        for (let i = 0; i < skipParts.length; i++) {\n          if (skipParts[i] !== currentParts[i]) {\n            return false;\n          }\n        }\n        return true; // All parts match, so this is a child or equal path\n      }\n    }\n    \n    return false;\n  })) {\n    return changes; // Skip comparison for this path and its children\n  }\n\n  const typeOfOldObj = getTypeOfObj(oldObj);\n  const typeOfNewObj = getTypeOfObj(newObj);\n\n  // `treatTypeChangeAsReplace` is a flag used to determine if a change in type should be treated as a replacement.\n  if (options.treatTypeChangeAsReplace && typeOfOldObj !== typeOfNewObj) {\n    // Only add a REMOVE operation if oldObj is not undefined\n    if (typeOfOldObj !== 'undefined') {\n      changes.push({ type: Operation.REMOVE, key: getKey(path), value: oldObj });\n    }\n\n    // As undefined is not serialized into JSON, it should not count as an added value.\n    if (typeOfNewObj !== 'undefined') {\n      changes.push({ type: Operation.ADD, key: getKey(path), value: newObj });\n    }\n\n    return changes;\n  }\n\n  if (typeOfNewObj === 'undefined' && typeOfOldObj !== 'undefined') {\n    changes.push({ type: Operation.REMOVE, key: getKey(path), value: oldObj });\n    return changes;\n  }\n\n  if (typeOfNewObj === 'Object' && typeOfOldObj === 'Array') {\n    changes.push({ type: Operation.UPDATE, key: getKey(path), value: newObj, oldValue: oldObj });\n    return changes;\n  }\n\n  if (typeOfNewObj === null) {\n    if (typeOfOldObj !== null) {\n      changes.push({ type: Operation.UPDATE, key: getKey(path), value: newObj, oldValue: oldObj });\n    }\n    return changes;\n  }\n\n  switch (typeOfOldObj) {\n    case 'Date':\n      if (typeOfNewObj === 'Date') {\n        changes = changes.concat(\n          comparePrimitives(oldObj.getTime(), newObj.getTime(), path).map((x) => ({\n            ...x,\n            value: new Date(x.value),\n            oldValue: new Date(x.oldValue)\n          }))\n        );\n      } else {\n        changes = changes.concat(comparePrimitives(oldObj, newObj, path));\n      }\n      break;\n    case 'Object': {\n      const diffs = compareObject(oldObj, newObj, path, keyPath, false, options);\n      if (diffs.length) {\n        if (path.length) {\n          changes.push({\n            type: Operation.UPDATE,\n            key: getKey(path),\n            changes: diffs\n          });\n        } else {\n          changes = changes.concat(diffs);\n        }\n      }\n      break;\n    }\n    case 'Array':\n      changes = changes.concat(compareArray(oldObj, newObj, path, keyPath, options));\n      break;\n    case 'Function':\n      break;\n    // do nothing\n    default:\n      changes = changes.concat(comparePrimitives(oldObj, newObj, path));\n  }\n\n  return changes;\n};\n\nconst compareObject = (oldObj: any, newObj: any, path: any, keyPath: any, skipPath = false, options: Options = {}) => {\n  let k;\n  let newKeyPath;\n  let newPath;\n\n  if (skipPath == null) {\n    skipPath = false;\n  }\n  let changes: any[] = [];\n\n  // Filter keys directly rather than filtering by keysToSkip at this level\n  // The full path check is now done in the compare function\n  const oldObjKeys = Object.keys(oldObj);\n  const newObjKeys = Object.keys(newObj);\n\n  const intersectionKeys = intersection(oldObjKeys, newObjKeys);\n  for (k of intersectionKeys) {\n    newPath = path.concat([k]);\n    newKeyPath = skipPath ? keyPath : keyPath.concat([k]);\n    const diffs = compare(oldObj[k], newObj[k], newPath, newKeyPath, options);\n    if (diffs.length) {\n      changes = changes.concat(diffs);\n    }\n  }\n\n  const addedKeys = difference(newObjKeys, oldObjKeys);\n  for (k of addedKeys) {\n    newPath = path.concat([k]);\n    newKeyPath = skipPath ? keyPath : keyPath.concat([k]);\n    // Check if the path should be skipped\n    const currentPath = newKeyPath.join('.');\n    if (options.keysToSkip?.some(skipPath => currentPath === skipPath || currentPath.startsWith(skipPath + '.'))) {\n      continue; // Skip adding this key\n    }\n    changes.push({\n      type: Operation.ADD,\n      key: getKey(newPath),\n      value: newObj[k]\n    });\n  }\n\n  const deletedKeys = difference(oldObjKeys, newObjKeys);\n  for (k of deletedKeys) {\n    newPath = path.concat([k]);\n    newKeyPath = skipPath ? keyPath : keyPath.concat([k]);\n    // Check if the path should be skipped\n    const currentPath = newKeyPath.join('.');\n    if (options.keysToSkip?.some(skipPath => currentPath === skipPath || currentPath.startsWith(skipPath + '.'))) {\n      continue; // Skip removing this key\n    }\n    changes.push({\n      type: Operation.REMOVE,\n      key: getKey(newPath),\n      value: oldObj[k]\n    });\n  }\n  return changes;\n};\n\nconst compareArray = (oldObj: any, newObj: any, path: any, keyPath: any, options: Options) => {\n  if (getTypeOfObj(newObj) !== 'Array') {\n    return [{ type: Operation.UPDATE, key: getKey(path), value: newObj, oldValue: oldObj }];\n  }\n\n  const left = getObjectKey(options.embeddedObjKeys, keyPath);\n  const uniqKey = left != null ? left : '$index';\n  const indexedOldObj = convertArrayToObj(oldObj, uniqKey);\n  const indexedNewObj = convertArrayToObj(newObj, uniqKey);\n  const diffs = compareObject(indexedOldObj, indexedNewObj, path, keyPath, true, options);\n  if (diffs.length) {\n    return [\n      {\n        type: Operation.UPDATE,\n        key: getKey(path),\n        embeddedKey: typeof uniqKey === 'function' && uniqKey.length === 2 ? uniqKey(newObj[0], true) : uniqKey,\n        changes: diffs\n      }\n    ];\n  } else {\n    return [];\n  }\n};\n\nconst getObjectKey = (embeddedObjKeys: any, keyPath: any) => {\n  if (embeddedObjKeys != null) {\n    const path = keyPath.join('.');\n\n    if (embeddedObjKeys instanceof Map) {\n      for (const [key, value] of embeddedObjKeys.entries()) {\n        if (key instanceof RegExp) {\n          if (path.match(key)) {\n            return value;\n          }\n        } else if (path === key) {\n          return value;\n        }\n      }\n    }\n\n    const key = embeddedObjKeys[path];\n    if (key != null) {\n      return key;\n    }\n  }\n  return undefined;\n};\n\nconst convertArrayToObj = (arr: any[], uniqKey: any) => {\n  let obj: any = {};\n  if (uniqKey === '$value') {\n    arr.forEach((value) => {\n      obj[value] = value;\n    });\n  } else if (uniqKey !== '$index') {\n    // Convert string keys to functions for compatibility with es-toolkit keyBy\n    const keyFunction = typeof uniqKey === 'string' ? (item: any) => item[uniqKey] : uniqKey;\n    obj = keyBy(arr, keyFunction);\n  } else {\n    for (let i = 0; i < arr.length; i++) {\n      const value = arr[i];\n      obj[i] = value;\n    }\n  }\n  return obj;\n};\n\nconst comparePrimitives = (oldObj: any, newObj: any, path: any) => {\n  const changes = [];\n  if (oldObj !== newObj) {\n    changes.push({\n      type: Operation.UPDATE,\n      key: getKey(path),\n      value: newObj,\n      oldValue: oldObj\n    });\n  }\n  return changes;\n};\n\nconst removeKey = (obj: any, key: any, embeddedKey: any) => {\n  if (Array.isArray(obj)) {\n    if (embeddedKey === '$index') {\n      obj.splice(Number(key), 1);\n      return;\n    }\n    const index = indexOfItemInArray(obj, embeddedKey, key);\n    if (index === -1) {\n      // tslint:disable-next-line:no-console\n      console.warn(`Element with the key '${embeddedKey}' and value '${key}' could not be found in the array'`);\n      return;\n    }\n    return obj.splice(index != null ? index : key, 1);\n  } else {\n    delete obj[key];\n    return;\n  }\n};\n\nconst indexOfItemInArray = (arr: any[], key: any, value: any) => {\n  if (key === '$value') {\n    return arr.indexOf(value);\n  }\n  for (let i = 0; i < arr.length; i++) {\n    const item = arr[i];\n    if (item && item[key] ? item[key].toString() === value.toString() : undefined) {\n      return i;\n    }\n  }\n  return -1;\n};\n\nconst modifyKeyValue = (obj: any, key: any, value: any) => (obj[key] = value);\nconst addKeyValue = (obj: any, key: any, value: any, embeddedKey?: any) => {\n  if (Array.isArray(obj)) {\n    if (embeddedKey === '$index') {\n      obj.splice(Number(key), 0, value);\n      return obj.length;\n    }\n    return obj.push(value);\n  } else {\n    return obj ? (obj[key] = value) : null;\n  }\n};\n\nconst applyLeafChange = (obj: any, change: any, embeddedKey: any) => {\n  const { type, key, value } = change;\n  switch (type) {\n    case Operation.ADD:\n      return addKeyValue(obj, key, value, embeddedKey);\n    case Operation.UPDATE:\n      return modifyKeyValue(obj, key, value);\n    case Operation.REMOVE:\n      return removeKey(obj, key, embeddedKey);\n  }\n};\n\n/**\n * Applies changes to an array.\n * \n * @param {any[]} arr - The array to apply changes to.\n * @param {any} change - The change to apply, containing nested changes.\n * @returns {any[]} - The array after changes have been applied.\n *\n * Note: This function modifies the array in-place but also returns it for\n * consistency with other functions.\n */\nconst applyArrayChange = (arr: any[], change: any) => {\n  let changes = change.changes;\n  if (change.embeddedKey === '$index') {\n    changes = [...changes].sort((a, b) => {\n      if (a.type === Operation.REMOVE && b.type === Operation.REMOVE) {\n        return Number(b.key) - Number(a.key);\n      }\n      if (a.type === Operation.REMOVE) return -1;\n      if (b.type === Operation.REMOVE) return 1;\n      return Number(a.key) - Number(b.key);\n    });\n  }\n\n  for (const subchange of changes) {\n    if (\n      (subchange.value !== null && subchange.value !== undefined) ||\n      subchange.type === Operation.REMOVE ||\n      (subchange.value === null && subchange.type === Operation.ADD)\n    ) {\n      applyLeafChange(arr, subchange, change.embeddedKey);\n    } else {\n      let element;\n      if (change.embeddedKey === '$index') {\n        element = arr[subchange.key];\n      } else if (change.embeddedKey === '$value') {\n        const index = arr.indexOf(subchange.key);\n        if (index !== -1) {\n          element = arr[index];\n        }\n      } else {\n        element = arr.find((el) => el[change.embeddedKey]?.toString() === subchange.key.toString());\n      }\n      if (element) {\n        applyChangeset(element, subchange.changes);\n      }\n    }\n  }\n  return arr;\n};\n\nconst applyBranchChange = (obj: any, change: any) => {\n  if (Array.isArray(obj)) {\n    return applyArrayChange(obj, change);\n  } else {\n    return applyChangeset(obj, change.changes);\n  }\n};\n\nconst revertLeafChange = (obj: any, change: any, embeddedKey = '$index') => {\n  const { type, key, value, oldValue } = change;\n  \n  // Special handling for $root key\n  if (key === '$root') {\n    switch (type) {\n      case Operation.ADD:\n        // When reverting an ADD of the entire object, clear all properties\n        for (const prop in obj) {\n          if (Object.prototype.hasOwnProperty.call(obj, prop)) {\n            delete obj[prop];\n          }\n        }\n        return obj;\n      case Operation.UPDATE:\n        // Replace the entire object with the old value\n        for (const prop in obj) {\n          if (Object.prototype.hasOwnProperty.call(obj, prop)) {\n            delete obj[prop];\n          }\n        }\n        if (oldValue && typeof oldValue === 'object') {\n          Object.assign(obj, oldValue);\n        }\n        return obj;\n      case Operation.REMOVE:\n        // Restore the removed object\n        if (value && typeof value === 'object') {\n          Object.assign(obj, value);\n        }\n        return obj;\n    }\n  }\n  \n  // Regular property handling\n  switch (type) {\n    case Operation.ADD:\n      return removeKey(obj, key, embeddedKey);\n    case Operation.UPDATE:\n      return modifyKeyValue(obj, key, oldValue);\n    case Operation.REMOVE:\n      return addKeyValue(obj, key, value);\n  }\n};\n\n/**\n * Reverts changes in an array.\n * \n * @param {any[]} arr - The array to revert changes in.\n * @param {any} change - The change to revert, containing nested changes.\n * @returns {any[]} - The array after changes have been reverted.\n *\n * Note: This function modifies the array in-place but also returns it for\n * consistency with other functions.\n */\nconst revertArrayChange = (arr: any[], change: any) => {\n  for (const subchange of change.changes) {\n    if (subchange.value != null || subchange.type === Operation.REMOVE) {\n      revertLeafChange(arr, subchange, change.embeddedKey);\n    } else {\n      let element;\n      if (change.embeddedKey === '$index') {\n        element = arr[+subchange.key];\n      } else if (change.embeddedKey === '$value') {\n        const index = arr.indexOf(subchange.key);\n        if (index !== -1) {\n          element = arr[index];\n        }\n      } else {\n        element = arr.find((el) => el[change.embeddedKey]?.toString() === subchange.key.toString());\n      }\n      if (element) {\n        revertChangeset(element, subchange.changes);\n      }\n    }\n  }\n  return arr;\n};\n\nconst revertBranchChange = (obj: any, change: any) => {\n  if (Array.isArray(obj)) {\n    return revertArrayChange(obj, change);\n  } else {\n    return revertChangeset(obj, change.changes);\n  }\n};\n\n/** combine a base JSON Path with a subsequent segment */\nfunction append(basePath: string, nextSegment: string): string {\n  return nextSegment.includes('.') ? `${basePath}[${nextSegment}]` : `${basePath}.${nextSegment}`;\n}\n\n/** returns a JSON Path filter expression; e.g., `$.pet[(?name='spot')]` */\nfunction filterExpression(basePath: string, filterKey: string | FunctionKey, filterValue: string | number) {\n  const value = typeof filterValue === 'number' ? filterValue : `'${filterValue}'`;\n  return typeof filterKey === 'string' && filterKey.includes('.')\n    ? `${basePath}[?(@[${filterKey}]==${value})]`\n    : `${basePath}[?(@.${filterKey}==${value})]`;\n}\n\nexport {\n  Changeset,\n  EmbeddedObjKeysMapType,\n  EmbeddedObjKeysType,\n  IAtomicChange,\n  IChange,\n  Operation,\n  Options,\n  applyChangeset,\n  atomizeChangeset,\n  diff,\n  getTypeOfObj,\n  revertChangeset,\n  unatomizeChangeset\n};\n", "import { setByPath } from './helpers.js';\nimport { diff, atomizeChangeset, getTypeOfObj, IAtomicChange, Operation } from './jsonDiff.js';\n\nenum CompareOperation {\n  CONTAINER = 'CONTAINER',\n  UNCHANGED = 'UNCHANGED'\n}\n\ninterface IComparisonEnrichedNode {\n  type: Operation | CompareOperation;\n  value: IComparisonEnrichedNode | IComparisonEnrichedNode[] | any | any[];\n  oldValue?: any;\n}\n\nconst createValue = (value: any): IComparisonEnrichedNode => ({ type: CompareOperation.UNCHANGED, value });\nconst createContainer = (value: object | []): IComparisonEnrichedNode => ({\n  type: CompareOperation.CONTAINER,\n  value\n});\n\nconst enrich = (object: any): IComparisonEnrichedNode => {\n  const objectType = getTypeOfObj(object);\n\n  switch (objectType) {\n    case 'Object':\n      return Object.keys(object)\n        .map((key: string) => ({ key, value: enrich(object[key]) }))\n        .reduce((accumulator, entry) => {\n          accumulator.value[entry.key] = entry.value;\n          return accumulator;\n        }, createContainer({}));\n    case 'Array':\n      return (object as any[])\n        .map((value) => enrich(value))\n        .reduce((accumulator, value) => {\n          accumulator.value.push(value);\n          return accumulator;\n        }, createContainer([]));\n    case 'Function':\n      return undefined;\n    case 'Date':\n    default:\n      // Primitive value\n      return createValue(object);\n  }\n};\n\nconst applyChangelist = (object: IComparisonEnrichedNode, changelist: IAtomicChange[]): IComparisonEnrichedNode => {\n  changelist\n    .map((entry) => ({ ...entry, path: entry.path.replace('$.', '.') }))\n    .map((entry) => ({\n      ...entry,\n      path: entry.path.replace(/(\\[(?<array>\\d)\\]\\.)/g, 'ARRVAL_START$<array>ARRVAL_END')\n    }))\n    .map((entry) => ({ ...entry, path: entry.path.replace(/(?<dot>\\.)/g, '.value$<dot>') }))\n    .map((entry) => ({ ...entry, path: entry.path.replace(/\\./, '') }))\n    .map((entry) => ({ ...entry, path: entry.path.replace(/ARRVAL_START/g, '.value[') }))\n    .map((entry) => ({ ...entry, path: entry.path.replace(/ARRVAL_END/g, '].value.') }))\n    .forEach((entry) => {\n      switch (entry.type) {\n        case Operation.ADD:\n        case Operation.UPDATE:\n          setByPath(object, entry.path, { type: entry.type, value: entry.value, oldValue: entry.oldValue });\n          break;\n        case Operation.REMOVE:\n          setByPath(object, entry.path, { type: entry.type, value: undefined, oldValue: entry.value });\n          break;\n        default:\n          throw new Error();\n      }\n    });\n  return object;\n};\n\nconst compare = (oldObject: any, newObject: any): IComparisonEnrichedNode => {\n  return applyChangelist(enrich(oldObject), atomizeChangeset(diff(oldObject, newObject)));\n};\n\nexport { CompareOperation, IComparisonEnrichedNode, createValue, createContainer, enrich, applyChangelist, compare };\n", "import { SyncPlugin } from './SyncPlugin';\nimport { CoreEvents } from '../constants/CoreEvents';\nimport { diff } from 'json-diff-ts';\n/**\n * BaseEntityService<T extends ISync> - Abstract base class for all entity services\n *\n * PROVIDES:\n * - Generic CRUD operations (get, getAll, save, delete)\n * - Sync status management (delegates to SyncPlugin)\n * - Serialization hooks (override in subclass if needed)\n */\nexport class BaseEntityService {\n    constructor(context, eventBus) {\n        this.context = context;\n        this.eventBus = eventBus;\n        this.syncPlugin = new SyncPlugin(this);\n    }\n    get db() {\n        return this.context.getDatabase();\n    }\n    /**\n     * Serialize entity before storing in IndexedDB\n     */\n    serialize(entity) {\n        return entity;\n    }\n    /**\n     * Deserialize data from IndexedDB back to entity\n     */\n    deserialize(data) {\n        return data;\n    }\n    /**\n     * Get a single entity by ID\n     */\n    async get(id) {\n        return new Promise((resolve, reject) => {\n            const transaction = this.db.transaction([this.storeName], 'readonly');\n            const store = transaction.objectStore(this.storeName);\n            const request = store.get(id);\n            request.onsuccess = () => {\n                const data = request.result;\n                resolve(data ? this.deserialize(data) : null);\n            };\n            request.onerror = () => {\n                reject(new Error(`Failed to get ${this.entityType} ${id}: ${request.error}`));\n            };\n        });\n    }\n    /**\n     * Get all entities\n     */\n    async getAll() {\n        return new Promise((resolve, reject) => {\n            const transaction = this.db.transaction([this.storeName], 'readonly');\n            const store = transaction.objectStore(this.storeName);\n            const request = store.getAll();\n            request.onsuccess = () => {\n                const data = request.result;\n                const entities = data.map(item => this.deserialize(item));\n                resolve(entities);\n            };\n            request.onerror = () => {\n                reject(new Error(`Failed to get all ${this.entityType}s: ${request.error}`));\n            };\n        });\n    }\n    /**\n     * Save an entity (create or update)\n     * Emits ENTITY_SAVED event with operation type and changes (diff for updates)\n     * @param entity - Entity to save\n     * @param silent - If true, skip event emission (used for seeding)\n     */\n    async save(entity, silent = false) {\n        const entityId = entity.id;\n        const existingEntity = await this.get(entityId);\n        const isCreate = existingEntity === null;\n        // Calculate changes: full entity for create, diff for update\n        let changes;\n        if (isCreate) {\n            changes = entity;\n        }\n        else {\n            const existingSerialized = this.serialize(existingEntity);\n            const newSerialized = this.serialize(entity);\n            changes = diff(existingSerialized, newSerialized);\n        }\n        const serialized = this.serialize(entity);\n        return new Promise((resolve, reject) => {\n            const transaction = this.db.transaction([this.storeName], 'readwrite');\n            const store = transaction.objectStore(this.storeName);\n            const request = store.put(serialized);\n            request.onsuccess = () => {\n                // Only emit event if not silent (silent used for seeding)\n                if (!silent) {\n                    const payload = {\n                        entityType: this.entityType,\n                        entityId,\n                        operation: isCreate ? 'create' : 'update',\n                        changes,\n                        timestamp: Date.now()\n                    };\n                    this.eventBus.emit(CoreEvents.ENTITY_SAVED, payload);\n                }\n                resolve();\n            };\n            request.onerror = () => {\n                reject(new Error(`Failed to save ${this.entityType} ${entityId}: ${request.error}`));\n            };\n        });\n    }\n    /**\n     * Delete an entity\n     * Emits ENTITY_DELETED event\n     */\n    async delete(id) {\n        return new Promise((resolve, reject) => {\n            const transaction = this.db.transaction([this.storeName], 'readwrite');\n            const store = transaction.objectStore(this.storeName);\n            const request = store.delete(id);\n            request.onsuccess = () => {\n                const payload = {\n                    entityType: this.entityType,\n                    entityId: id,\n                    operation: 'delete',\n                    timestamp: Date.now()\n                };\n                this.eventBus.emit(CoreEvents.ENTITY_DELETED, payload);\n                resolve();\n            };\n            request.onerror = () => {\n                reject(new Error(`Failed to delete ${this.entityType} ${id}: ${request.error}`));\n            };\n        });\n    }\n    // Sync methods - delegate to SyncPlugin\n    async markAsSynced(id) {\n        return this.syncPlugin.markAsSynced(id);\n    }\n    async markAsError(id) {\n        return this.syncPlugin.markAsError(id);\n    }\n    async getSyncStatus(id) {\n        return this.syncPlugin.getSyncStatus(id);\n    }\n    async getBySyncStatus(syncStatus) {\n        return this.syncPlugin.getBySyncStatus(syncStatus);\n    }\n}\n", "import { EventStore } from './EventStore';\nimport { EventSerialization } from './EventSerialization';\nimport { BaseEntityService } from '../BaseEntityService';\n/**\n * EventService - CRUD operations for calendar events in IndexedDB\n *\n * Extends BaseEntityService for shared CRUD and sync logic.\n * Provides event-specific query methods.\n */\nexport class EventService extends BaseEntityService {\n    constructor(context, eventBus) {\n        super(context, eventBus);\n        this.storeName = EventStore.STORE_NAME;\n        this.entityType = 'Event';\n    }\n    serialize(event) {\n        return EventSerialization.serialize(event);\n    }\n    deserialize(data) {\n        return EventSerialization.deserialize(data);\n    }\n    /**\n     * Get events within a date range\n     */\n    async getByDateRange(start, end) {\n        return new Promise((resolve, reject) => {\n            const transaction = this.db.transaction([this.storeName], 'readonly');\n            const store = transaction.objectStore(this.storeName);\n            const index = store.index('start');\n            const range = IDBKeyRange.lowerBound(start.toISOString());\n            const request = index.getAll(range);\n            request.onsuccess = () => {\n                const data = request.result;\n                const events = data\n                    .map(item => this.deserialize(item))\n                    .filter(event => event.start <= end);\n                resolve(events);\n            };\n            request.onerror = () => {\n                reject(new Error(`Failed to get events by date range: ${request.error}`));\n            };\n        });\n    }\n    /**\n     * Get events for a specific resource\n     */\n    async getByResource(resourceId) {\n        return new Promise((resolve, reject) => {\n            const transaction = this.db.transaction([this.storeName], 'readonly');\n            const store = transaction.objectStore(this.storeName);\n            const index = store.index('resourceId');\n            const request = index.getAll(resourceId);\n            request.onsuccess = () => {\n                const data = request.result;\n                const events = data.map(item => this.deserialize(item));\n                resolve(events);\n            };\n            request.onerror = () => {\n                reject(new Error(`Failed to get events for resource ${resourceId}: ${request.error}`));\n            };\n        });\n    }\n    /**\n     * Get events for a resource within a date range\n     */\n    async getByResourceAndDateRange(resourceId, start, end) {\n        const resourceEvents = await this.getByResource(resourceId);\n        return resourceEvents.filter(event => event.start >= start && event.start <= end);\n    }\n}\n", "/**\n * ResourceStore - IndexedDB ObjectStore definition for resources\n */\nexport class ResourceStore {\n    constructor() {\n        this.storeName = ResourceStore.STORE_NAME;\n    }\n    create(db) {\n        const store = db.createObjectStore(ResourceStore.STORE_NAME, { keyPath: 'id' });\n        store.createIndex('type', 'type', { unique: false });\n        store.createIndex('syncStatus', 'syncStatus', { unique: false });\n        store.createIndex('isActive', 'isActive', { unique: false });\n    }\n}\nResourceStore.STORE_NAME = 'resources';\n", "import { ResourceStore } from './ResourceStore';\nimport { BaseEntityService } from '../BaseEntityService';\n/**\n * ResourceService - CRUD operations for resources in IndexedDB\n */\nexport class ResourceService extends BaseEntityService {\n    constructor(context, eventBus) {\n        super(context, eventBus);\n        this.storeName = ResourceStore.STORE_NAME;\n        this.entityType = 'Resource';\n    }\n    /**\n     * Get all active resources\n     */\n    async getActive() {\n        const all = await this.getAll();\n        return all.filter(r => r.isActive !== false);\n    }\n    /**\n     * Get resources by IDs\n     */\n    async getByIds(ids) {\n        if (ids.length === 0)\n            return [];\n        const results = await Promise.all(ids.map(id => this.get(id)));\n        return results.filter((r) => r !== null);\n    }\n    /**\n     * Get resources by type\n     */\n    async getByType(type) {\n        return new Promise((resolve, reject) => {\n            const transaction = this.db.transaction([this.storeName], 'readonly');\n            const store = transaction.objectStore(this.storeName);\n            const index = store.index('type');\n            const request = index.getAll(type);\n            request.onsuccess = () => {\n                const data = request.result;\n                resolve(data);\n            };\n            request.onerror = () => {\n                reject(new Error(`Failed to get resources by type ${type}: ${request.error}`));\n            };\n        });\n    }\n}\n", "/**\n * BookingStore - IndexedDB ObjectStore definition for bookings\n */\nexport class BookingStore {\n    constructor() {\n        this.storeName = BookingStore.STORE_NAME;\n    }\n    create(db) {\n        const store = db.createObjectStore(BookingStore.STORE_NAME, { keyPath: 'id' });\n        store.createIndex('customerId', 'customerId', { unique: false });\n        store.createIndex('status', 'status', { unique: false });\n        store.createIndex('syncStatus', 'syncStatus', { unique: false });\n        store.createIndex('createdAt', 'createdAt', { unique: false });\n    }\n}\nBookingStore.STORE_NAME = 'bookings';\n", "import { BookingStore } from './BookingStore';\nimport { BaseEntityService } from '../BaseEntityService';\n/**\n * BookingService - CRUD operations for bookings in IndexedDB\n */\nexport class BookingService extends BaseEntityService {\n    constructor(context, eventBus) {\n        super(context, eventBus);\n        this.storeName = BookingStore.STORE_NAME;\n        this.entityType = 'Booking';\n    }\n    serialize(booking) {\n        return {\n            ...booking,\n            createdAt: booking.createdAt.toISOString()\n        };\n    }\n    deserialize(data) {\n        const raw = data;\n        return {\n            ...raw,\n            createdAt: new Date(raw.createdAt)\n        };\n    }\n    /**\n     * Get bookings for a customer\n     */\n    async getByCustomer(customerId) {\n        return new Promise((resolve, reject) => {\n            const transaction = this.db.transaction([this.storeName], 'readonly');\n            const store = transaction.objectStore(this.storeName);\n            const index = store.index('customerId');\n            const request = index.getAll(customerId);\n            request.onsuccess = () => {\n                const data = request.result;\n                const bookings = data.map(item => this.deserialize(item));\n                resolve(bookings);\n            };\n            request.onerror = () => {\n                reject(new Error(`Failed to get bookings for customer ${customerId}: ${request.error}`));\n            };\n        });\n    }\n    /**\n     * Get bookings by status\n     */\n    async getByStatus(status) {\n        return new Promise((resolve, reject) => {\n            const transaction = this.db.transaction([this.storeName], 'readonly');\n            const store = transaction.objectStore(this.storeName);\n            const index = store.index('status');\n            const request = index.getAll(status);\n            request.onsuccess = () => {\n                const data = request.result;\n                const bookings = data.map(item => this.deserialize(item));\n                resolve(bookings);\n            };\n            request.onerror = () => {\n                reject(new Error(`Failed to get bookings with status ${status}: ${request.error}`));\n            };\n        });\n    }\n}\n", "/**\n * CustomerStore - IndexedDB ObjectStore definition for customers\n */\nexport class CustomerStore {\n    constructor() {\n        this.storeName = CustomerStore.STORE_NAME;\n    }\n    create(db) {\n        const store = db.createObjectStore(CustomerStore.STORE_NAME, { keyPath: 'id' });\n        store.createIndex('name', 'name', { unique: false });\n        store.createIndex('phone', 'phone', { unique: false });\n        store.createIndex('syncStatus', 'syncStatus', { unique: false });\n    }\n}\nCustomerStore.STORE_NAME = 'customers';\n", "import { CustomerStore } from './CustomerStore';\nimport { BaseEntityService } from '../BaseEntityService';\n/**\n * CustomerService - CRUD operations for customers in IndexedDB\n */\nexport class CustomerService extends BaseEntityService {\n    constructor(context, eventBus) {\n        super(context, eventBus);\n        this.storeName = CustomerStore.STORE_NAME;\n        this.entityType = 'Customer';\n    }\n    /**\n     * Search customers by name (case-insensitive contains)\n     */\n    async searchByName(query) {\n        const all = await this.getAll();\n        const lowerQuery = query.toLowerCase();\n        return all.filter(c => c.name.toLowerCase().includes(lowerQuery));\n    }\n    /**\n     * Find customer by phone\n     */\n    async getByPhone(phone) {\n        return new Promise((resolve, reject) => {\n            const transaction = this.db.transaction([this.storeName], 'readonly');\n            const store = transaction.objectStore(this.storeName);\n            const index = store.index('phone');\n            const request = index.get(phone);\n            request.onsuccess = () => {\n                const data = request.result;\n                resolve(data ? data : null);\n            };\n            request.onerror = () => {\n                reject(new Error(`Failed to find customer by phone ${phone}: ${request.error}`));\n            };\n        });\n    }\n}\n", "/**\n * TeamStore - IndexedDB ObjectStore definition for teams\n */\nexport class TeamStore {\n    constructor() {\n        this.storeName = TeamStore.STORE_NAME;\n    }\n    create(db) {\n        db.createObjectStore(TeamStore.STORE_NAME, { keyPath: 'id' });\n    }\n}\nTeamStore.STORE_NAME = 'teams';\n", "import { TeamStore } from './TeamStore';\nimport { BaseEntityService } from '../BaseEntityService';\n/**\n * TeamService - CRUD operations for teams in IndexedDB\n *\n * Teams define which resources belong together for hierarchical grouping.\n * Extends BaseEntityService for standard entity operations.\n */\nexport class TeamService extends BaseEntityService {\n    constructor(context, eventBus) {\n        super(context, eventBus);\n        this.storeName = TeamStore.STORE_NAME;\n        this.entityType = 'Team';\n    }\n    /**\n     * Get teams by IDs\n     */\n    async getByIds(ids) {\n        if (ids.length === 0)\n            return [];\n        const results = await Promise.all(ids.map(id => this.get(id)));\n        return results.filter((t) => t !== null);\n    }\n    /**\n     * Build reverse lookup: resourceId \u2192 teamId\n     */\n    async buildResourceToTeamMap() {\n        const teams = await this.getAll();\n        const map = {};\n        for (const team of teams) {\n            for (const resourceId of team.resourceIds) {\n                map[resourceId] = team.id;\n            }\n        }\n        return map;\n    }\n}\n", "/**\n * DepartmentStore - IndexedDB ObjectStore definition for departments\n */\nexport class DepartmentStore {\n    constructor() {\n        this.storeName = DepartmentStore.STORE_NAME;\n    }\n    create(db) {\n        db.createObjectStore(DepartmentStore.STORE_NAME, { keyPath: 'id' });\n    }\n}\nDepartmentStore.STORE_NAME = 'departments';\n", "import { DepartmentStore } from './DepartmentStore';\nimport { BaseEntityService } from '../BaseEntityService';\n/**\n * DepartmentService - CRUD operations for departments in IndexedDB\n */\nexport class DepartmentService extends BaseEntityService {\n    constructor(context, eventBus) {\n        super(context, eventBus);\n        this.storeName = DepartmentStore.STORE_NAME;\n        this.entityType = 'Department';\n    }\n    /**\n     * Get departments by IDs\n     */\n    async getByIds(ids) {\n        if (ids.length === 0)\n            return [];\n        const results = await Promise.all(ids.map(id => this.get(id)));\n        return results.filter((d) => d !== null);\n    }\n}\n", "/**\n * SettingsStore - IndexedDB ObjectStore definition for tenant settings\n *\n * Single store for all settings sections. Settings are stored as one document\n * per tenant with id='tenant-settings'.\n */\nexport class SettingsStore {\n    constructor() {\n        this.storeName = SettingsStore.STORE_NAME;\n    }\n    create(db) {\n        db.createObjectStore(SettingsStore.STORE_NAME, { keyPath: 'id' });\n    }\n}\nSettingsStore.STORE_NAME = 'settings';\n", "/**\n * Settings IDs as const for type safety\n */\nexport const SettingsIds = {\n    WORKWEEK: 'workweek',\n    GRID: 'grid',\n    TIME_FORMAT: 'timeFormat',\n    VIEWS: 'views'\n};\n", "import { SettingsIds } from '../../types/SettingsTypes';\nimport { SettingsStore } from './SettingsStore';\nimport { BaseEntityService } from '../BaseEntityService';\n/**\n * SettingsService - CRUD operations for tenant settings\n *\n * Settings are stored as separate records per section.\n * This service provides typed methods for accessing specific settings.\n */\nexport class SettingsService extends BaseEntityService {\n    constructor(context, eventBus) {\n        super(context, eventBus);\n        this.storeName = SettingsStore.STORE_NAME;\n        this.entityType = 'Settings';\n    }\n    /**\n     * Get workweek settings\n     */\n    async getWorkweekSettings() {\n        return this.get(SettingsIds.WORKWEEK);\n    }\n    /**\n     * Get grid settings\n     */\n    async getGridSettings() {\n        return this.get(SettingsIds.GRID);\n    }\n    /**\n     * Get time format settings\n     */\n    async getTimeFormatSettings() {\n        return this.get(SettingsIds.TIME_FORMAT);\n    }\n    /**\n     * Get view settings\n     */\n    async getViewSettings() {\n        return this.get(SettingsIds.VIEWS);\n    }\n    /**\n     * Get workweek preset by ID\n     */\n    async getWorkweekPreset(presetId) {\n        const settings = await this.getWorkweekSettings();\n        if (!settings)\n            return null;\n        return settings.presets[presetId] || null;\n    }\n    /**\n     * Get the default workweek preset\n     */\n    async getDefaultWorkweekPreset() {\n        const settings = await this.getWorkweekSettings();\n        if (!settings)\n            return null;\n        return settings.presets[settings.defaultPreset] || null;\n    }\n    /**\n     * Get all available workweek presets\n     */\n    async getWorkweekPresets() {\n        const settings = await this.getWorkweekSettings();\n        if (!settings)\n            return [];\n        return Object.values(settings.presets);\n    }\n}\n", "export class ViewConfigStore {\n    constructor() {\n        this.storeName = ViewConfigStore.STORE_NAME;\n    }\n    create(db) {\n        db.createObjectStore(ViewConfigStore.STORE_NAME, { keyPath: 'id' });\n    }\n}\nViewConfigStore.STORE_NAME = 'viewconfigs';\n", "import { ViewConfigStore } from './ViewConfigStore';\nimport { BaseEntityService } from '../BaseEntityService';\nexport class ViewConfigService extends BaseEntityService {\n    constructor(context, eventBus) {\n        super(context, eventBus);\n        this.storeName = ViewConfigStore.STORE_NAME;\n        this.entityType = 'ViewConfig';\n    }\n    async getById(id) {\n        return this.get(id);\n    }\n}\n", "/**\n * AuditStore - IndexedDB store configuration for audit entries\n *\n * Stores all entity changes for:\n * - Compliance and audit trail\n * - Sync tracking with backend\n * - Change history\n *\n * Indexes:\n * - syncStatus: For finding pending entries to sync\n * - synced: Boolean flag for quick sync queries\n * - entityId: For getting all audits for a specific entity\n * - timestamp: For chronological queries\n */\nexport class AuditStore {\n    constructor() {\n        this.storeName = 'audit';\n    }\n    create(db) {\n        const store = db.createObjectStore(this.storeName, { keyPath: 'id' });\n        store.createIndex('syncStatus', 'syncStatus', { unique: false });\n        store.createIndex('synced', 'synced', { unique: false });\n        store.createIndex('entityId', 'entityId', { unique: false });\n        store.createIndex('timestamp', 'timestamp', { unique: false });\n    }\n}\n", "import { BaseEntityService } from '../BaseEntityService';\nimport { CoreEvents } from '../../constants/CoreEvents';\n/**\n * AuditService - Entity service for audit entries\n *\n * RESPONSIBILITIES:\n * - Store audit entries in IndexedDB\n * - Listen for ENTITY_SAVED/ENTITY_DELETED events\n * - Create audit entries for all entity changes\n * - Emit AUDIT_LOGGED after saving (for SyncManager to listen)\n *\n * OVERRIDE PATTERN:\n * - Overrides save() to NOT emit events (prevents infinite loops)\n * - AuditService saves audit entries without triggering more audits\n *\n * EVENT CHAIN:\n * Entity change \u2192 ENTITY_SAVED/DELETED \u2192 AuditService \u2192 AUDIT_LOGGED \u2192 SyncManager\n */\nexport class AuditService extends BaseEntityService {\n    constructor(context, eventBus) {\n        super(context, eventBus);\n        this.storeName = 'audit';\n        this.entityType = 'Audit';\n        this.setupEventListeners();\n    }\n    /**\n     * Setup listeners for ENTITY_SAVED and ENTITY_DELETED events\n     */\n    setupEventListeners() {\n        // Listen for entity saves (create/update)\n        this.eventBus.on(CoreEvents.ENTITY_SAVED, (event) => {\n            const detail = event.detail;\n            this.handleEntitySaved(detail);\n        });\n        // Listen for entity deletes\n        this.eventBus.on(CoreEvents.ENTITY_DELETED, (event) => {\n            const detail = event.detail;\n            this.handleEntityDeleted(detail);\n        });\n    }\n    /**\n     * Handle ENTITY_SAVED event - create audit entry\n     */\n    async handleEntitySaved(payload) {\n        // Don't audit audit entries (prevent infinite loops)\n        if (payload.entityType === 'Audit')\n            return;\n        const auditEntry = {\n            id: crypto.randomUUID(),\n            entityType: payload.entityType,\n            entityId: payload.entityId,\n            operation: payload.operation,\n            userId: AuditService.DEFAULT_USER_ID,\n            timestamp: payload.timestamp,\n            changes: payload.changes,\n            synced: false,\n            syncStatus: 'pending'\n        };\n        await this.save(auditEntry);\n    }\n    /**\n     * Handle ENTITY_DELETED event - create audit entry\n     */\n    async handleEntityDeleted(payload) {\n        // Don't audit audit entries (prevent infinite loops)\n        if (payload.entityType === 'Audit')\n            return;\n        const auditEntry = {\n            id: crypto.randomUUID(),\n            entityType: payload.entityType,\n            entityId: payload.entityId,\n            operation: 'delete',\n            userId: AuditService.DEFAULT_USER_ID,\n            timestamp: payload.timestamp,\n            changes: { id: payload.entityId }, // For delete, just store the ID\n            synced: false,\n            syncStatus: 'pending'\n        };\n        await this.save(auditEntry);\n    }\n    /**\n     * Override save to NOT trigger ENTITY_SAVED event\n     * Instead, emits AUDIT_LOGGED for SyncManager to listen\n     *\n     * This prevents infinite loops:\n     * - BaseEntityService.save() emits ENTITY_SAVED\n     * - AuditService listens to ENTITY_SAVED and creates audit\n     * - If AuditService.save() also emitted ENTITY_SAVED, it would loop\n     */\n    async save(entity) {\n        const serialized = this.serialize(entity);\n        return new Promise((resolve, reject) => {\n            const transaction = this.db.transaction([this.storeName], 'readwrite');\n            const store = transaction.objectStore(this.storeName);\n            const request = store.put(serialized);\n            request.onsuccess = () => {\n                // Emit AUDIT_LOGGED instead of ENTITY_SAVED\n                const payload = {\n                    auditId: entity.id,\n                    entityType: entity.entityType,\n                    entityId: entity.entityId,\n                    operation: entity.operation,\n                    timestamp: entity.timestamp\n                };\n                this.eventBus.emit(CoreEvents.AUDIT_LOGGED, payload);\n                resolve();\n            };\n            request.onerror = () => {\n                reject(new Error(`Failed to save audit entry ${entity.id}: ${request.error}`));\n            };\n        });\n    }\n    /**\n     * Override delete to NOT trigger ENTITY_DELETED event\n     * Audit entries should never be deleted (compliance requirement)\n     */\n    async delete(_id) {\n        throw new Error('Audit entries cannot be deleted (compliance requirement)');\n    }\n    /**\n     * Get pending audit entries (for sync)\n     */\n    async getPendingAudits() {\n        return this.getBySyncStatus('pending');\n    }\n    /**\n     * Get audit entries for a specific entity\n     */\n    async getByEntityId(entityId) {\n        return new Promise((resolve, reject) => {\n            const transaction = this.db.transaction([this.storeName], 'readonly');\n            const store = transaction.objectStore(this.storeName);\n            const index = store.index('entityId');\n            const request = index.getAll(entityId);\n            request.onsuccess = () => {\n                const entries = request.result;\n                resolve(entries);\n            };\n            request.onerror = () => {\n                reject(new Error(`Failed to get audit entries for entity ${entityId}: ${request.error}`));\n            };\n        });\n    }\n}\n// Hardcoded userId for now - will come from session later\nAuditService.DEFAULT_USER_ID = '00000000-0000-0000-0000-000000000001';\n", "/**\n * MockEventRepository - Loads event data from local JSON file\n *\n * Used for development and testing. Only fetchAll() is implemented.\n */\nexport class MockEventRepository {\n    constructor() {\n        this.entityType = 'Event';\n        this.dataUrl = 'data/mock-events.json';\n    }\n    /**\n     * Fetch all events from mock JSON file\n     */\n    async fetchAll() {\n        try {\n            const response = await fetch(this.dataUrl);\n            if (!response.ok) {\n                throw new Error(`Failed to load mock events: ${response.status} ${response.statusText}`);\n            }\n            const rawData = await response.json();\n            return this.processCalendarData(rawData);\n        }\n        catch (error) {\n            console.error('Failed to load event data:', error);\n            throw error;\n        }\n    }\n    async sendCreate(_event) {\n        throw new Error('MockEventRepository does not support sendCreate. Mock data is read-only.');\n    }\n    async sendUpdate(_id, _updates) {\n        throw new Error('MockEventRepository does not support sendUpdate. Mock data is read-only.');\n    }\n    async sendDelete(_id) {\n        throw new Error('MockEventRepository does not support sendDelete. Mock data is read-only.');\n    }\n    processCalendarData(data) {\n        return data.map((event) => {\n            // Validate customer event constraints\n            if (event.type === 'customer') {\n                if (!event.bookingId)\n                    console.warn(`Customer event ${event.id} missing bookingId`);\n                if (!event.resourceId)\n                    console.warn(`Customer event ${event.id} missing resourceId`);\n                if (!event.customerId)\n                    console.warn(`Customer event ${event.id} missing customerId`);\n            }\n            return {\n                id: event.id,\n                title: event.title,\n                description: event.description,\n                start: new Date(event.start),\n                end: new Date(event.end),\n                type: event.type,\n                allDay: event.allDay || false,\n                bookingId: event.bookingId,\n                resourceId: event.resourceId,\n                customerId: event.customerId,\n                recurringId: event.recurringId,\n                metadata: event.metadata,\n                syncStatus: 'synced'\n            };\n        });\n    }\n}\n", "/**\n * MockResourceRepository - Loads resource data from local JSON file\n */\nexport class MockResourceRepository {\n    constructor() {\n        this.entityType = 'Resource';\n        this.dataUrl = 'data/mock-resources.json';\n    }\n    async fetchAll() {\n        try {\n            const response = await fetch(this.dataUrl);\n            if (!response.ok) {\n                throw new Error(`Failed to load mock resources: ${response.status} ${response.statusText}`);\n            }\n            const rawData = await response.json();\n            return this.processResourceData(rawData);\n        }\n        catch (error) {\n            console.error('Failed to load resource data:', error);\n            throw error;\n        }\n    }\n    async sendCreate(_resource) {\n        throw new Error('MockResourceRepository does not support sendCreate. Mock data is read-only.');\n    }\n    async sendUpdate(_id, _updates) {\n        throw new Error('MockResourceRepository does not support sendUpdate. Mock data is read-only.');\n    }\n    async sendDelete(_id) {\n        throw new Error('MockResourceRepository does not support sendDelete. Mock data is read-only.');\n    }\n    processResourceData(data) {\n        return data.map((resource) => ({\n            id: resource.id,\n            name: resource.name,\n            displayName: resource.displayName,\n            type: resource.type,\n            avatarUrl: resource.avatarUrl,\n            color: resource.color,\n            isActive: resource.isActive,\n            defaultSchedule: resource.defaultSchedule,\n            metadata: resource.metadata,\n            syncStatus: 'synced'\n        }));\n    }\n}\n", "/**\n * MockBookingRepository - Loads booking data from local JSON file\n */\nexport class MockBookingRepository {\n    constructor() {\n        this.entityType = 'Booking';\n        this.dataUrl = 'data/mock-bookings.json';\n    }\n    async fetchAll() {\n        try {\n            const response = await fetch(this.dataUrl);\n            if (!response.ok) {\n                throw new Error(`Failed to load mock bookings: ${response.status} ${response.statusText}`);\n            }\n            const rawData = await response.json();\n            return this.processBookingData(rawData);\n        }\n        catch (error) {\n            console.error('Failed to load booking data:', error);\n            throw error;\n        }\n    }\n    async sendCreate(_booking) {\n        throw new Error('MockBookingRepository does not support sendCreate. Mock data is read-only.');\n    }\n    async sendUpdate(_id, _updates) {\n        throw new Error('MockBookingRepository does not support sendUpdate. Mock data is read-only.');\n    }\n    async sendDelete(_id) {\n        throw new Error('MockBookingRepository does not support sendDelete. Mock data is read-only.');\n    }\n    processBookingData(data) {\n        return data.map((booking) => ({\n            id: booking.id,\n            customerId: booking.customerId,\n            status: booking.status,\n            createdAt: new Date(booking.createdAt),\n            services: booking.services,\n            totalPrice: booking.totalPrice,\n            tags: booking.tags,\n            notes: booking.notes,\n            syncStatus: 'synced'\n        }));\n    }\n}\n", "/**\n * MockCustomerRepository - Loads customer data from local JSON file\n */\nexport class MockCustomerRepository {\n    constructor() {\n        this.entityType = 'Customer';\n        this.dataUrl = 'data/mock-customers.json';\n    }\n    async fetchAll() {\n        try {\n            const response = await fetch(this.dataUrl);\n            if (!response.ok) {\n                throw new Error(`Failed to load mock customers: ${response.status} ${response.statusText}`);\n            }\n            const rawData = await response.json();\n            return this.processCustomerData(rawData);\n        }\n        catch (error) {\n            console.error('Failed to load customer data:', error);\n            throw error;\n        }\n    }\n    async sendCreate(_customer) {\n        throw new Error('MockCustomerRepository does not support sendCreate. Mock data is read-only.');\n    }\n    async sendUpdate(_id, _updates) {\n        throw new Error('MockCustomerRepository does not support sendUpdate. Mock data is read-only.');\n    }\n    async sendDelete(_id) {\n        throw new Error('MockCustomerRepository does not support sendDelete. Mock data is read-only.');\n    }\n    processCustomerData(data) {\n        return data.map((customer) => ({\n            id: customer.id,\n            name: customer.name,\n            phone: customer.phone,\n            email: customer.email,\n            metadata: customer.metadata,\n            syncStatus: 'synced'\n        }));\n    }\n}\n", "/**\n * MockAuditRepository - Mock API repository for audit entries\n *\n * In production, this would send audit entries to the backend.\n * For development/testing, it just logs the operations.\n */\nexport class MockAuditRepository {\n    constructor() {\n        this.entityType = 'Audit';\n    }\n    async sendCreate(entity) {\n        // Simulate API call delay\n        await new Promise(resolve => setTimeout(resolve, 100));\n        console.log('MockAuditRepository: Audit entry synced to backend:', {\n            id: entity.id,\n            entityType: entity.entityType,\n            entityId: entity.entityId,\n            operation: entity.operation,\n            timestamp: new Date(entity.timestamp).toISOString()\n        });\n        return entity;\n    }\n    async sendUpdate(_id, _entity) {\n        // Audit entries are immutable - updates should not happen\n        throw new Error('Audit entries cannot be updated');\n    }\n    async sendDelete(_id) {\n        // Audit entries should never be deleted\n        throw new Error('Audit entries cannot be deleted');\n    }\n    async fetchAll() {\n        // For now, return empty array - audit entries are local-first\n        // In production, this could fetch audit history from backend\n        return [];\n    }\n    async fetchById(_id) {\n        // For now, return null - audit entries are local-first\n        return null;\n    }\n}\n", "/**\n * MockTeamRepository - Loads team data from local JSON file\n */\nexport class MockTeamRepository {\n    constructor() {\n        this.entityType = 'Team';\n        this.dataUrl = 'data/mock-teams.json';\n    }\n    async fetchAll() {\n        try {\n            const response = await fetch(this.dataUrl);\n            if (!response.ok) {\n                throw new Error(`Failed to load mock teams: ${response.status} ${response.statusText}`);\n            }\n            const rawData = await response.json();\n            return this.processTeamData(rawData);\n        }\n        catch (error) {\n            console.error('Failed to load team data:', error);\n            throw error;\n        }\n    }\n    async sendCreate(_team) {\n        throw new Error('MockTeamRepository does not support sendCreate. Mock data is read-only.');\n    }\n    async sendUpdate(_id, _updates) {\n        throw new Error('MockTeamRepository does not support sendUpdate. Mock data is read-only.');\n    }\n    async sendDelete(_id) {\n        throw new Error('MockTeamRepository does not support sendDelete. Mock data is read-only.');\n    }\n    processTeamData(data) {\n        return data.map((team) => ({\n            id: team.id,\n            name: team.name,\n            resourceIds: team.resourceIds,\n            syncStatus: 'synced'\n        }));\n    }\n}\n", "/**\n * MockDepartmentRepository - Loads department data from local JSON file\n */\nexport class MockDepartmentRepository {\n    constructor() {\n        this.entityType = 'Department';\n        this.dataUrl = 'data/mock-departments.json';\n    }\n    async fetchAll() {\n        try {\n            const response = await fetch(this.dataUrl);\n            if (!response.ok) {\n                throw new Error(`Failed to load mock departments: ${response.status} ${response.statusText}`);\n            }\n            const rawData = await response.json();\n            return this.processDepartmentData(rawData);\n        }\n        catch (error) {\n            console.error('Failed to load department data:', error);\n            throw error;\n        }\n    }\n    async sendCreate(_department) {\n        throw new Error('MockDepartmentRepository does not support sendCreate. Mock data is read-only.');\n    }\n    async sendUpdate(_id, _updates) {\n        throw new Error('MockDepartmentRepository does not support sendUpdate. Mock data is read-only.');\n    }\n    async sendDelete(_id) {\n        throw new Error('MockDepartmentRepository does not support sendDelete. Mock data is read-only.');\n    }\n    processDepartmentData(data) {\n        return data.map((dept) => ({\n            id: dept.id,\n            name: dept.name,\n            resourceIds: dept.resourceIds,\n            syncStatus: 'synced'\n        }));\n    }\n}\n", "/**\n * MockSettingsRepository - Loads tenant settings from local JSON file\n *\n * Settings are stored as separate records per section (workweek, grid, etc.).\n * The JSON file is already an array of TenantSetting records.\n */\nexport class MockSettingsRepository {\n    constructor() {\n        this.entityType = 'Settings';\n        this.dataUrl = 'data/tenant-settings.json';\n    }\n    async fetchAll() {\n        try {\n            const response = await fetch(this.dataUrl);\n            if (!response.ok) {\n                throw new Error(`Failed to load tenant settings: ${response.status} ${response.statusText}`);\n            }\n            const settings = await response.json();\n            // Ensure syncStatus is set on each record\n            return settings.map(s => ({\n                ...s,\n                syncStatus: s.syncStatus || 'synced'\n            }));\n        }\n        catch (error) {\n            console.error('Failed to load tenant settings:', error);\n            throw error;\n        }\n    }\n    async sendCreate(_settings) {\n        throw new Error('MockSettingsRepository does not support sendCreate. Mock data is read-only.');\n    }\n    async sendUpdate(_id, _updates) {\n        throw new Error('MockSettingsRepository does not support sendUpdate. Mock data is read-only.');\n    }\n    async sendDelete(_id) {\n        throw new Error('MockSettingsRepository does not support sendDelete. Mock data is read-only.');\n    }\n}\n", "export class MockViewConfigRepository {\n    constructor() {\n        this.entityType = 'ViewConfig';\n        this.dataUrl = 'data/viewconfigs.json';\n    }\n    async fetchAll() {\n        try {\n            const response = await fetch(this.dataUrl);\n            if (!response.ok) {\n                throw new Error(`Failed to load viewconfigs: ${response.status} ${response.statusText}`);\n            }\n            const rawData = await response.json();\n            // Ensure syncStatus is set on each config\n            const configs = rawData.map((config) => ({\n                ...config,\n                syncStatus: config.syncStatus || 'synced'\n            }));\n            return configs;\n        }\n        catch (error) {\n            console.error('Failed to load viewconfigs:', error);\n            throw error;\n        }\n    }\n    async sendCreate(_config) {\n        throw new Error('MockViewConfigRepository does not support sendCreate. Mock data is read-only.');\n    }\n    async sendUpdate(_id, _updates) {\n        throw new Error('MockViewConfigRepository does not support sendUpdate. Mock data is read-only.');\n    }\n    async sendDelete(_id) {\n        throw new Error('MockViewConfigRepository does not support sendDelete. Mock data is read-only.');\n    }\n}\n", "/**\n * DataSeeder - Orchestrates initial data loading from repositories into IndexedDB\n *\n * ARCHITECTURE:\n * - Repository (Mock/Api): Fetches data from source (JSON file or backend API)\n * - DataSeeder (this class): Orchestrates fetch + save operations\n * - Service (EventService, etc.): Saves data to IndexedDB\n *\n * POLYMORPHIC DESIGN:\n * - Uses arrays of IEntityService[] and IApiRepository[]\n * - Matches services with repositories using entityType property\n * - Open/Closed Principle: Adding new entity requires no code changes here\n */\nexport class DataSeeder {\n    constructor(services, repositories) {\n        this.services = services;\n        this.repositories = repositories;\n    }\n    /**\n     * Seed all entity stores if they are empty\n     */\n    async seedIfEmpty() {\n        console.log('[DataSeeder] Checking if database needs seeding...');\n        try {\n            for (const service of this.services) {\n                const repository = this.repositories.find(repo => repo.entityType === service.entityType);\n                if (!repository) {\n                    console.warn(`[DataSeeder] No repository found for entity type: ${service.entityType}, skipping`);\n                    continue;\n                }\n                await this.seedEntity(service.entityType, service, repository);\n            }\n            console.log('[DataSeeder] Seeding complete');\n        }\n        catch (error) {\n            console.error('[DataSeeder] Seeding failed:', error);\n            throw error;\n        }\n    }\n    async seedEntity(entityType, service, repository) {\n        const existing = await service.getAll();\n        if (existing.length > 0) {\n            console.log(`[DataSeeder] ${entityType} store already has ${existing.length} items, skipping seed`);\n            return;\n        }\n        console.log(`[DataSeeder] ${entityType} store is empty, fetching from repository...`);\n        const data = await repository.fetchAll();\n        console.log(`[DataSeeder] Fetched ${data.length} ${entityType} items, saving to IndexedDB...`);\n        for (const entity of data) {\n            await service.save(entity, true); // silent = true to skip audit logging\n        }\n        console.log(`[DataSeeder] ${entityType} seeding complete (${data.length} items saved)`);\n    }\n}\n", "/**\n * Calculate pixel position for an event based on its times\n */\nexport function calculateEventPosition(start, end, config) {\n    const startMinutes = start.getHours() * 60 + start.getMinutes();\n    const endMinutes = end.getHours() * 60 + end.getMinutes();\n    const dayStartMinutes = config.dayStartHour * 60;\n    const minuteHeight = config.hourHeight / 60;\n    const top = (startMinutes - dayStartMinutes) * minuteHeight;\n    const height = (endMinutes - startMinutes) * minuteHeight;\n    return { top, height };\n}\n/**\n * Convert minutes to pixels\n */\nexport function minutesToPixels(minutes, config) {\n    return (minutes / 60) * config.hourHeight;\n}\n/**\n * Convert pixels to minutes\n */\nexport function pixelsToMinutes(pixels, config) {\n    return (pixels / config.hourHeight) * 60;\n}\n/**\n * Snap pixel position to grid interval\n */\nexport function snapToGrid(pixels, config) {\n    const snapPixels = minutesToPixels(config.snapInterval, config);\n    return Math.round(pixels / snapPixels) * snapPixels;\n}\n", "import { calculateEventPosition } from '../../utils/PositionUtils';\n/**\n * Check if two events overlap (strict - touching at boundary = NOT overlapping)\n * This matches Scenario 8: end===start is NOT overlap\n */\nexport function eventsOverlap(a, b) {\n    return a.start < b.end && a.end > b.start;\n}\n/**\n * Check if two events are within threshold for grid grouping.\n * This includes:\n * 1. Start-to-start: Events start within threshold of each other\n * 2. End-to-start: One event starts within threshold before another ends\n */\nfunction eventsWithinThreshold(a, b, thresholdMinutes) {\n    const thresholdMs = thresholdMinutes * 60 * 1000;\n    // Start-to-start: both events start within threshold\n    const startToStartDiff = Math.abs(a.start.getTime() - b.start.getTime());\n    if (startToStartDiff <= thresholdMs)\n        return true;\n    // End-to-start: one event starts within threshold before the other ends\n    // B starts within threshold before A ends\n    const bStartsBeforeAEnds = a.end.getTime() - b.start.getTime();\n    if (bStartsBeforeAEnds > 0 && bStartsBeforeAEnds <= thresholdMs)\n        return true;\n    // A starts within threshold before B ends\n    const aStartsBeforeBEnds = b.end.getTime() - a.start.getTime();\n    if (aStartsBeforeBEnds > 0 && aStartsBeforeBEnds <= thresholdMs)\n        return true;\n    return false;\n}\n/**\n * Check if all events in a group start within threshold of each other\n */\nfunction allStartWithinThreshold(events, thresholdMinutes) {\n    if (events.length <= 1)\n        return true;\n    // Find earliest and latest start times\n    let earliest = events[0].start.getTime();\n    let latest = events[0].start.getTime();\n    for (const event of events) {\n        const time = event.start.getTime();\n        if (time < earliest)\n            earliest = time;\n        if (time > latest)\n            latest = time;\n    }\n    const diffMinutes = (latest - earliest) / (1000 * 60);\n    return diffMinutes <= thresholdMinutes;\n}\n/**\n * Find groups of overlapping events (connected by overlap chain)\n * Events are grouped if they overlap with any event in the group\n */\nfunction findOverlapGroups(events) {\n    if (events.length === 0)\n        return [];\n    const sorted = [...events].sort((a, b) => a.start.getTime() - b.start.getTime());\n    const used = new Set();\n    const groups = [];\n    for (const event of sorted) {\n        if (used.has(event.id))\n            continue;\n        // Start a new group with this event\n        const group = [event];\n        used.add(event.id);\n        // Expand group by finding all connected events (via overlap)\n        let expanded = true;\n        while (expanded) {\n            expanded = false;\n            for (const candidate of sorted) {\n                if (used.has(candidate.id))\n                    continue;\n                // Check if candidate overlaps with any event in group\n                const connects = group.some(member => eventsOverlap(member, candidate));\n                if (connects) {\n                    group.push(candidate);\n                    used.add(candidate.id);\n                    expanded = true;\n                }\n            }\n        }\n        groups.push(group);\n    }\n    return groups;\n}\n/**\n * Find grid candidates within a group - events connected via threshold chain\n * Uses V1 logic: events are connected if within threshold (no overlap requirement)\n */\nfunction findGridCandidates(events, thresholdMinutes) {\n    if (events.length === 0)\n        return [];\n    const sorted = [...events].sort((a, b) => a.start.getTime() - b.start.getTime());\n    const used = new Set();\n    const groups = [];\n    for (const event of sorted) {\n        if (used.has(event.id))\n            continue;\n        const group = [event];\n        used.add(event.id);\n        // Expand by threshold chain (V1 logic: no overlap requirement, just threshold)\n        let expanded = true;\n        while (expanded) {\n            expanded = false;\n            for (const candidate of sorted) {\n                if (used.has(candidate.id))\n                    continue;\n                const connects = group.some(member => eventsWithinThreshold(member, candidate, thresholdMinutes));\n                if (connects) {\n                    group.push(candidate);\n                    used.add(candidate.id);\n                    expanded = true;\n                }\n            }\n        }\n        groups.push(group);\n    }\n    return groups;\n}\n/**\n * Calculate stack levels for overlapping events using greedy algorithm\n * For each event: level = max(overlapping already-processed events) + 1\n */\nfunction calculateStackLevels(events) {\n    const levels = new Map();\n    const sorted = [...events].sort((a, b) => a.start.getTime() - b.start.getTime());\n    for (const event of sorted) {\n        let maxOverlappingLevel = -1;\n        // Find max level among overlapping events already processed\n        for (const [id, level] of levels) {\n            const other = events.find(e => e.id === id);\n            if (other && eventsOverlap(event, other)) {\n                maxOverlappingLevel = Math.max(maxOverlappingLevel, level);\n            }\n        }\n        levels.set(event.id, maxOverlappingLevel + 1);\n    }\n    return levels;\n}\n/**\n * Allocate events to columns for GRID layout using greedy algorithm\n * Non-overlapping events can share a column to minimize total columns\n */\nfunction allocateColumns(events) {\n    const sorted = [...events].sort((a, b) => a.start.getTime() - b.start.getTime());\n    const columns = [];\n    for (const event of sorted) {\n        // Find first column where event doesn't overlap with existing events\n        let placed = false;\n        for (const column of columns) {\n            const canFit = !column.some(e => eventsOverlap(event, e));\n            if (canFit) {\n                column.push(event);\n                placed = true;\n                break;\n            }\n        }\n        // No suitable column found, create new one\n        if (!placed) {\n            columns.push([event]);\n        }\n    }\n    return columns;\n}\n/**\n * Main entry point: Calculate complete layout for a column's events\n *\n * Algorithm:\n * 1. Find overlap groups (events connected by overlap chain)\n * 2. For each overlap group, find grid candidates (events within threshold chain)\n * 3. If all events in overlap group form a single grid candidate \u2192 GRID mode\n * 4. Otherwise \u2192 STACKING mode with calculated levels\n */\nexport function calculateColumnLayout(events, config) {\n    const thresholdMinutes = config.gridStartThresholdMinutes ?? 10;\n    const result = {\n        grids: [],\n        stacked: []\n    };\n    if (events.length === 0)\n        return result;\n    // Find all overlapping event groups\n    const overlapGroups = findOverlapGroups(events);\n    for (const overlapGroup of overlapGroups) {\n        if (overlapGroup.length === 1) {\n            // Single event - no grouping needed\n            result.stacked.push({\n                event: overlapGroup[0],\n                stackLevel: 0\n            });\n            continue;\n        }\n        // Within this overlap group, find grid candidates (threshold-connected subgroups)\n        const gridSubgroups = findGridCandidates(overlapGroup, thresholdMinutes);\n        // Check if the ENTIRE overlap group forms a single grid candidate\n        // This happens when all events are connected via threshold chain\n        const largestGridCandidate = gridSubgroups.reduce((max, g) => g.length > max.length ? g : max, gridSubgroups[0]);\n        if (largestGridCandidate.length === overlapGroup.length) {\n            // All events in overlap group are connected via threshold chain \u2192 GRID mode\n            const columns = allocateColumns(overlapGroup);\n            const earliest = overlapGroup.reduce((min, e) => e.start < min.start ? e : min, overlapGroup[0]);\n            const position = calculateEventPosition(earliest.start, earliest.end, config);\n            result.grids.push({\n                events: overlapGroup,\n                columns,\n                stackLevel: 0,\n                position: { top: position.top }\n            });\n        }\n        else {\n            // Not all events connected via threshold \u2192 STACKING mode\n            const levels = calculateStackLevels(overlapGroup);\n            for (const event of overlapGroup) {\n                result.stacked.push({\n                    event,\n                    stackLevel: levels.get(event.id) ?? 0\n                });\n            }\n        }\n    }\n    return result;\n}\n", "import { calculateEventPosition, snapToGrid, pixelsToMinutes } from '../../utils/PositionUtils';\nimport { CoreEvents } from '../../constants/CoreEvents';\nimport { calculateColumnLayout } from './EventLayoutEngine';\n/**\n * EventRenderer - Renders calendar events to the DOM\n *\n * CLEAN approach:\n * - Only data-id attribute on event element\n * - innerHTML contains only visible content\n * - Event data retrieved via EventService when needed\n */\nexport class EventRenderer {\n    constructor(eventService, dateService, gridConfig, eventBus) {\n        this.eventService = eventService;\n        this.dateService = dateService;\n        this.gridConfig = gridConfig;\n        this.eventBus = eventBus;\n        this.container = null;\n        this.setupListeners();\n    }\n    /**\n     * Setup listeners for drag-drop and update events\n     */\n    setupListeners() {\n        this.eventBus.on(CoreEvents.EVENT_DRAG_COLUMN_CHANGE, (e) => {\n            const payload = e.detail;\n            this.handleColumnChange(payload);\n        });\n        this.eventBus.on(CoreEvents.EVENT_DRAG_MOVE, (e) => {\n            const payload = e.detail;\n            this.updateDragTimestamp(payload);\n        });\n        this.eventBus.on(CoreEvents.EVENT_UPDATED, (e) => {\n            const payload = e.detail;\n            this.handleEventUpdated(payload);\n        });\n        this.eventBus.on(CoreEvents.EVENT_DRAG_END, (e) => {\n            const payload = e.detail;\n            this.handleDragEnd(payload);\n        });\n        this.eventBus.on(CoreEvents.EVENT_DRAG_LEAVE_HEADER, (e) => {\n            const payload = e.detail;\n            this.handleDragLeaveHeader(payload);\n        });\n    }\n    /**\n     * Handle EVENT_DRAG_END - remove element if dropped in header\n     */\n    handleDragEnd(payload) {\n        if (payload.target === 'header') {\n            // Event was dropped in header drawer - remove from grid\n            const element = this.container?.querySelector(`swp-content-viewport swp-event[data-event-id=\"${payload.swpEvent.eventId}\"]`);\n            element?.remove();\n        }\n    }\n    /**\n     * Handle header item leaving header - create swp-event in grid\n     */\n    handleDragLeaveHeader(payload) {\n        // Only handle when source is header (header item dragged to grid)\n        if (payload.source !== 'header')\n            return;\n        if (!payload.targetColumn || !payload.start || !payload.end)\n            return;\n        // Turn header item into ghost (stays visible but faded)\n        if (payload.element) {\n            payload.element.classList.add('drag-ghost');\n            payload.element.style.opacity = '0.3';\n            payload.element.style.pointerEvents = 'none';\n        }\n        // Create event object from header item data\n        const event = {\n            id: payload.eventId,\n            title: payload.title || '',\n            description: '',\n            start: payload.start,\n            end: payload.end,\n            type: 'customer',\n            allDay: false,\n            syncStatus: 'pending'\n        };\n        // Create swp-event element using existing method\n        const element = this.createEventElement(event);\n        // Add to target column\n        let eventsLayer = payload.targetColumn.querySelector('swp-events-layer');\n        if (!eventsLayer) {\n            eventsLayer = document.createElement('swp-events-layer');\n            payload.targetColumn.appendChild(eventsLayer);\n        }\n        eventsLayer.appendChild(element);\n        // Mark as dragging so DragDropManager can continue with it\n        element.classList.add('dragging');\n    }\n    /**\n     * Handle EVENT_UPDATED - re-render affected columns\n     */\n    async handleEventUpdated(payload) {\n        // Re-render source column (if different from target)\n        if (payload.sourceColumnKey !== payload.targetColumnKey) {\n            await this.rerenderColumn(payload.sourceColumnKey);\n        }\n        // Re-render target column\n        await this.rerenderColumn(payload.targetColumnKey);\n    }\n    /**\n     * Re-render a single column with fresh data from IndexedDB\n     */\n    async rerenderColumn(columnKey) {\n        const column = this.findColumn(columnKey);\n        if (!column)\n            return;\n        // Read date and resourceId directly from column attributes (columnKey is opaque)\n        const date = column.dataset.date;\n        const resourceId = column.dataset.resourceId;\n        if (!date)\n            return;\n        // Get date range for this day\n        const startDate = new Date(date);\n        const endDate = new Date(date);\n        endDate.setHours(23, 59, 59, 999);\n        // Fetch events from IndexedDB\n        const events = resourceId\n            ? await this.eventService.getByResourceAndDateRange(resourceId, startDate, endDate)\n            : await this.eventService.getByDateRange(startDate, endDate);\n        // Filter to timed events and match date exactly\n        const timedEvents = events.filter(event => !event.allDay && this.dateService.getDateKey(event.start) === date);\n        // Get or create events layer\n        let eventsLayer = column.querySelector('swp-events-layer');\n        if (!eventsLayer) {\n            eventsLayer = document.createElement('swp-events-layer');\n            column.appendChild(eventsLayer);\n        }\n        // Clear existing events\n        eventsLayer.innerHTML = '';\n        // Calculate layout with stacking/grouping\n        const layout = calculateColumnLayout(timedEvents, this.gridConfig);\n        // Render GRID groups\n        layout.grids.forEach(grid => {\n            const groupEl = this.renderGridGroup(grid);\n            eventsLayer.appendChild(groupEl);\n        });\n        // Render STACKED events\n        layout.stacked.forEach(item => {\n            const eventEl = this.renderStackedEvent(item.event, item.stackLevel);\n            eventsLayer.appendChild(eventEl);\n        });\n    }\n    /**\n     * Find a column element by columnKey\n     */\n    findColumn(columnKey) {\n        if (!this.container)\n            return null;\n        return this.container.querySelector(`swp-day-column[data-column-key=\"${columnKey}\"]`);\n    }\n    /**\n     * Handle event moving to a new column during drag\n     */\n    handleColumnChange(payload) {\n        const eventsLayer = payload.newColumn.querySelector('swp-events-layer');\n        if (!eventsLayer)\n            return;\n        // Move element to new column\n        eventsLayer.appendChild(payload.element);\n        // Preserve Y position\n        payload.element.style.top = `${payload.currentY}px`;\n    }\n    /**\n     * Update timestamp display during drag (snapped to grid)\n     */\n    updateDragTimestamp(payload) {\n        const timeEl = payload.element.querySelector('swp-event-time');\n        if (!timeEl)\n            return;\n        // Snap position to grid interval\n        const snappedY = snapToGrid(payload.currentY, this.gridConfig);\n        // Calculate new start time\n        const minutesFromGridStart = pixelsToMinutes(snappedY, this.gridConfig);\n        const startMinutes = (this.gridConfig.dayStartHour * 60) + minutesFromGridStart;\n        // Keep original duration (from element height)\n        const height = parseFloat(payload.element.style.height) || this.gridConfig.hourHeight;\n        const durationMinutes = pixelsToMinutes(height, this.gridConfig);\n        // Create Date objects for consistent formatting via DateService\n        const start = this.minutesToDate(startMinutes);\n        const end = this.minutesToDate(startMinutes + durationMinutes);\n        timeEl.textContent = this.dateService.formatTimeRange(start, end);\n    }\n    /**\n     * Convert minutes since midnight to a Date object (today)\n     */\n    minutesToDate(minutes) {\n        const date = new Date();\n        date.setHours(Math.floor(minutes / 60) % 24, minutes % 60, 0, 0);\n        return date;\n    }\n    /**\n     * Render events for visible dates into day columns\n     * @param container - Calendar container element\n     * @param filter - Filter with 'date' and optionally 'resource' arrays\n     * @param filterTemplate - Template for matching events to columns\n     */\n    async render(container, filter, filterTemplate) {\n        // Store container reference for later re-renders\n        this.container = container;\n        const visibleDates = filter['date'] || [];\n        if (visibleDates.length === 0)\n            return;\n        // Get date range for query\n        const startDate = new Date(visibleDates[0]);\n        const endDate = new Date(visibleDates[visibleDates.length - 1]);\n        endDate.setHours(23, 59, 59, 999);\n        // Fetch events from IndexedDB\n        const events = await this.eventService.getByDateRange(startDate, endDate);\n        // Find day columns\n        const dayColumns = container.querySelector('swp-day-columns');\n        if (!dayColumns)\n            return;\n        const columns = dayColumns.querySelectorAll('swp-day-column');\n        // Render events into each column based on FilterTemplate matching\n        columns.forEach(column => {\n            const columnEl = column;\n            // Use FilterTemplate for matching - only fields in template are checked\n            const columnEvents = events.filter(event => filterTemplate.matches(event, columnEl));\n            // Get or create events layer\n            let eventsLayer = column.querySelector('swp-events-layer');\n            if (!eventsLayer) {\n                eventsLayer = document.createElement('swp-events-layer');\n                column.appendChild(eventsLayer);\n            }\n            // Clear existing events\n            eventsLayer.innerHTML = '';\n            // Filter to timed events only\n            const timedEvents = columnEvents.filter(event => !event.allDay);\n            // Calculate layout with stacking/grouping\n            const layout = calculateColumnLayout(timedEvents, this.gridConfig);\n            // Render GRID groups (simultaneous events side-by-side)\n            layout.grids.forEach(grid => {\n                const groupEl = this.renderGridGroup(grid);\n                eventsLayer.appendChild(groupEl);\n            });\n            // Render STACKED events (overlapping with margin offset)\n            layout.stacked.forEach(item => {\n                const eventEl = this.renderStackedEvent(item.event, item.stackLevel);\n                eventsLayer.appendChild(eventEl);\n            });\n        });\n    }\n    /**\n     * Create a single event element\n     *\n     * CLEAN approach:\n     * - Only data-id for lookup\n     * - Visible content in innerHTML only\n     */\n    createEventElement(event) {\n        const element = document.createElement('swp-event');\n        // Data attributes for SwpEvent compatibility\n        element.dataset.eventId = event.id;\n        if (event.resourceId) {\n            element.dataset.resourceId = event.resourceId;\n        }\n        // Calculate position\n        const position = calculateEventPosition(event.start, event.end, this.gridConfig);\n        element.style.top = `${position.top}px`;\n        element.style.height = `${position.height}px`;\n        // Color class based on event type\n        const colorClass = this.getColorClass(event);\n        if (colorClass) {\n            element.classList.add(colorClass);\n        }\n        // Visible content only\n        element.innerHTML = `\r\n      <swp-event-time>${this.dateService.formatTimeRange(event.start, event.end)}</swp-event-time>\r\n      <swp-event-title>${this.escapeHtml(event.title)}</swp-event-title>\r\n      ${event.description ? `<swp-event-description>${this.escapeHtml(event.description)}</swp-event-description>` : ''}\r\n    `;\n        return element;\n    }\n    /**\n     * Get color class based on metadata.color or event type\n     */\n    getColorClass(event) {\n        // Check metadata.color first\n        if (event.metadata?.color) {\n            return `is-${event.metadata.color}`;\n        }\n        // Fallback to type-based color\n        const typeColors = {\n            'customer': 'is-blue',\n            'vacation': 'is-green',\n            'break': 'is-amber',\n            'meeting': 'is-purple',\n            'blocked': 'is-red'\n        };\n        return typeColors[event.type] || 'is-blue';\n    }\n    /**\n     * Escape HTML to prevent XSS\n     */\n    escapeHtml(text) {\n        const div = document.createElement('div');\n        div.textContent = text;\n        return div.innerHTML;\n    }\n    /**\n     * Render a GRID group with side-by-side columns\n     * Used when multiple events start at the same time\n     */\n    renderGridGroup(layout) {\n        const group = document.createElement('swp-event-group');\n        group.classList.add(`cols-${layout.columns.length}`);\n        group.style.top = `${layout.position.top}px`;\n        // Stack level styling for entire group (if nested in another event)\n        if (layout.stackLevel > 0) {\n            group.style.marginLeft = `${layout.stackLevel * 15}px`;\n            group.style.zIndex = `${100 + layout.stackLevel}`;\n        }\n        // Calculate the height needed for the group (tallest event)\n        let maxBottom = 0;\n        for (const event of layout.events) {\n            const pos = calculateEventPosition(event.start, event.end, this.gridConfig);\n            const eventBottom = pos.top + pos.height;\n            if (eventBottom > maxBottom)\n                maxBottom = eventBottom;\n        }\n        const groupHeight = maxBottom - layout.position.top;\n        group.style.height = `${groupHeight}px`;\n        // Create wrapper div for each column\n        layout.columns.forEach(columnEvents => {\n            const wrapper = document.createElement('div');\n            wrapper.style.position = 'relative';\n            columnEvents.forEach(event => {\n                const eventEl = this.createEventElement(event);\n                // Position relative to group top\n                const pos = calculateEventPosition(event.start, event.end, this.gridConfig);\n                eventEl.style.top = `${pos.top - layout.position.top}px`;\n                eventEl.style.position = 'absolute';\n                eventEl.style.left = '0';\n                eventEl.style.right = '0';\n                wrapper.appendChild(eventEl);\n            });\n            group.appendChild(wrapper);\n        });\n        return group;\n    }\n    /**\n     * Render a STACKED event with margin-left offset\n     * Used for overlapping events that don't start at the same time\n     */\n    renderStackedEvent(event, stackLevel) {\n        const element = this.createEventElement(event);\n        // Add stack metadata for drag-drop and other features\n        element.dataset.stackLink = JSON.stringify({ stackLevel });\n        // Visual styling based on stack level\n        if (stackLevel > 0) {\n            element.style.marginLeft = `${stackLevel * 15}px`;\n            element.style.zIndex = `${100 + stackLevel}`;\n        }\n        return element;\n    }\n}\n", "/**\n * ScheduleRenderer - Renders unavailable time zones in day columns\n *\n * Creates visual indicators for times outside the resource's working hours:\n * - Before work start (e.g., 06:00 - 09:00)\n * - After work end (e.g., 17:00 - 18:00)\n * - Full day if resource is off (schedule = null)\n */\nexport class ScheduleRenderer {\n    constructor(scheduleService, dateService, gridConfig) {\n        this.scheduleService = scheduleService;\n        this.dateService = dateService;\n        this.gridConfig = gridConfig;\n    }\n    /**\n     * Render unavailable zones for visible columns\n     * @param container - Calendar container element\n     * @param filter - Filter with 'date' and 'resource' arrays\n     */\n    async render(container, filter) {\n        const dates = filter['date'] || [];\n        const resourceIds = filter['resource'] || [];\n        if (dates.length === 0)\n            return;\n        // Find day columns\n        const dayColumns = container.querySelector('swp-day-columns');\n        if (!dayColumns)\n            return;\n        const columns = dayColumns.querySelectorAll('swp-day-column');\n        for (const column of columns) {\n            const date = column.dataset.date;\n            const resourceId = column.dataset.resourceId;\n            if (!date || !resourceId)\n                continue;\n            // Get or create unavailable layer\n            let unavailableLayer = column.querySelector('swp-unavailable-layer');\n            if (!unavailableLayer) {\n                unavailableLayer = document.createElement('swp-unavailable-layer');\n                column.insertBefore(unavailableLayer, column.firstChild);\n            }\n            // Clear existing\n            unavailableLayer.innerHTML = '';\n            // Get schedule for this resource/date\n            const schedule = await this.scheduleService.getScheduleForDate(resourceId, date);\n            // Render unavailable zones\n            this.renderUnavailableZones(unavailableLayer, schedule);\n        }\n    }\n    /**\n     * Render unavailable time zones based on schedule\n     */\n    renderUnavailableZones(layer, schedule) {\n        const dayStartMinutes = this.gridConfig.dayStartHour * 60;\n        const dayEndMinutes = this.gridConfig.dayEndHour * 60;\n        const minuteHeight = this.gridConfig.hourHeight / 60;\n        if (schedule === null) {\n            // Full day unavailable\n            const zone = this.createUnavailableZone(0, (dayEndMinutes - dayStartMinutes) * minuteHeight);\n            layer.appendChild(zone);\n            return;\n        }\n        const workStartMinutes = this.dateService.timeToMinutes(schedule.start);\n        const workEndMinutes = this.dateService.timeToMinutes(schedule.end);\n        // Before work start\n        if (workStartMinutes > dayStartMinutes) {\n            const top = 0;\n            const height = (workStartMinutes - dayStartMinutes) * minuteHeight;\n            const zone = this.createUnavailableZone(top, height);\n            layer.appendChild(zone);\n        }\n        // After work end\n        if (workEndMinutes < dayEndMinutes) {\n            const top = (workEndMinutes - dayStartMinutes) * minuteHeight;\n            const height = (dayEndMinutes - workEndMinutes) * minuteHeight;\n            const zone = this.createUnavailableZone(top, height);\n            layer.appendChild(zone);\n        }\n    }\n    /**\n     * Create an unavailable zone element\n     */\n    createUnavailableZone(top, height) {\n        const zone = document.createElement('swp-unavailable-zone');\n        zone.style.top = `${top}px`;\n        zone.style.height = `${height}px`;\n        return zone;\n    }\n}\n", "import { CoreEvents } from '../../constants/CoreEvents';\n/**\n * HeaderDrawerRenderer - Handles rendering of items in the header drawer\n *\n * Listens to drag events from DragDropManager and creates/manages\n * swp-header-item elements in the header drawer.\n *\n * Uses subgrid for column alignment with parent swp-calendar-header.\n * Position items via gridArea for explicit row/column placement.\n */\nexport class HeaderDrawerRenderer {\n    constructor(eventBus, gridConfig, headerDrawerManager, eventService, dateService) {\n        this.eventBus = eventBus;\n        this.gridConfig = gridConfig;\n        this.headerDrawerManager = headerDrawerManager;\n        this.eventService = eventService;\n        this.dateService = dateService;\n        this.currentItem = null;\n        this.container = null;\n        this.sourceElement = null;\n        this.wasExpandedBeforeDrag = false;\n        this.filterTemplate = null;\n        this.setupListeners();\n    }\n    /**\n     * Render allDay events into the header drawer with row stacking\n     * @param filterTemplate - Template for matching events to columns\n     */\n    async render(container, filter, filterTemplate) {\n        // Store filterTemplate for buildColumnKeyFromEvent\n        this.filterTemplate = filterTemplate;\n        const drawer = container.querySelector('swp-header-drawer');\n        if (!drawer)\n            return;\n        const visibleDates = filter['date'] || [];\n        if (visibleDates.length === 0)\n            return;\n        // Get column keys from DOM for correct multi-resource positioning\n        const visibleColumnKeys = this.getVisibleColumnKeysFromDOM();\n        if (visibleColumnKeys.length === 0)\n            return;\n        // Fetch events for date range\n        const startDate = new Date(visibleDates[0]);\n        const endDate = new Date(visibleDates[visibleDates.length - 1]);\n        endDate.setHours(23, 59, 59, 999);\n        const events = await this.eventService.getByDateRange(startDate, endDate);\n        // Filter to allDay events only (allDay !== false)\n        const allDayEvents = events.filter(event => event.allDay !== false);\n        // Clear existing items\n        drawer.innerHTML = '';\n        if (allDayEvents.length === 0)\n            return;\n        // Calculate layout with row stacking using columnKeys\n        const layouts = this.calculateLayout(allDayEvents, visibleColumnKeys);\n        const rowCount = Math.max(1, ...layouts.map(l => l.row));\n        // Render each item with layout\n        layouts.forEach(layout => {\n            const item = this.createHeaderItem(layout);\n            drawer.appendChild(item);\n        });\n        // Expand drawer to fit all rows\n        this.headerDrawerManager.expandToRows(rowCount);\n    }\n    /**\n     * Create a header item element from layout\n     */\n    createHeaderItem(layout) {\n        const { event, columnKey, row, colStart, colEnd } = layout;\n        const item = document.createElement('swp-header-item');\n        item.dataset.eventId = event.id;\n        item.dataset.itemType = 'event';\n        item.dataset.start = event.start.toISOString();\n        item.dataset.end = event.end.toISOString();\n        item.dataset.columnKey = columnKey;\n        item.textContent = event.title;\n        // Color class\n        const colorClass = this.getColorClass(event);\n        if (colorClass)\n            item.classList.add(colorClass);\n        // Grid position from layout\n        item.style.gridArea = `${row} / ${colStart} / ${row + 1} / ${colEnd}`;\n        return item;\n    }\n    /**\n     * Calculate layout for all events with row stacking\n     * Uses track-based algorithm to find available rows for overlapping events\n     */\n    calculateLayout(events, visibleColumnKeys) {\n        // tracks[row][col] = occupied\n        const tracks = [new Array(visibleColumnKeys.length).fill(false)];\n        const layouts = [];\n        for (const event of events) {\n            // Build columnKey from event fields (only place we need to construct it)\n            const columnKey = this.buildColumnKeyFromEvent(event);\n            const startCol = visibleColumnKeys.indexOf(columnKey);\n            const endColumnKey = this.buildColumnKeyFromEvent(event, event.end);\n            const endCol = visibleColumnKeys.indexOf(endColumnKey);\n            if (startCol === -1 && endCol === -1)\n                continue;\n            // Clamp til synlige kolonner\n            const colStart = Math.max(0, startCol);\n            const colEnd = (endCol !== -1 ? endCol : visibleColumnKeys.length - 1) + 1;\n            // Find ledig r\u00E6kke\n            const row = this.findAvailableRow(tracks, colStart, colEnd);\n            // Marker som optaget\n            for (let c = colStart; c < colEnd; c++) {\n                tracks[row][c] = true;\n            }\n            layouts.push({ event, columnKey, row: row + 1, colStart: colStart + 1, colEnd: colEnd + 1 });\n        }\n        return layouts;\n    }\n    /**\n     * Build columnKey from event using FilterTemplate\n     * Uses the same template that columns use for matching\n     */\n    buildColumnKeyFromEvent(event, date) {\n        if (!this.filterTemplate) {\n            // Fallback if no template - shouldn't happen in normal flow\n            const dateStr = this.dateService.getDateKey(date || event.start);\n            return dateStr;\n        }\n        // For multi-day events, we need to override the date in the event\n        if (date && date.getTime() !== event.start.getTime()) {\n            // Create temporary event with overridden start for key generation\n            const tempEvent = { ...event, start: date };\n            return this.filterTemplate.buildKeyFromEvent(tempEvent);\n        }\n        return this.filterTemplate.buildKeyFromEvent(event);\n    }\n    /**\n     * Find available row for event spanning columns [colStart, colEnd)\n     */\n    findAvailableRow(tracks, colStart, colEnd) {\n        for (let row = 0; row < tracks.length; row++) {\n            let available = true;\n            for (let c = colStart; c < colEnd; c++) {\n                if (tracks[row][c]) {\n                    available = false;\n                    break;\n                }\n            }\n            if (available)\n                return row;\n        }\n        // Ny r\u00E6kke\n        tracks.push(new Array(tracks[0].length).fill(false));\n        return tracks.length - 1;\n    }\n    /**\n     * Get color class based on event metadata or type\n     */\n    getColorClass(event) {\n        if (event.metadata?.color) {\n            return `is-${event.metadata.color}`;\n        }\n        const typeColors = {\n            'customer': 'is-blue',\n            'vacation': 'is-green',\n            'break': 'is-amber',\n            'meeting': 'is-purple',\n            'blocked': 'is-red'\n        };\n        return typeColors[event.type] || 'is-blue';\n    }\n    /**\n     * Setup event listeners for drag events\n     */\n    setupListeners() {\n        this.eventBus.on(CoreEvents.EVENT_DRAG_ENTER_HEADER, (e) => {\n            const payload = e.detail;\n            this.handleDragEnter(payload);\n        });\n        this.eventBus.on(CoreEvents.EVENT_DRAG_MOVE_HEADER, (e) => {\n            const payload = e.detail;\n            this.handleDragMove(payload);\n        });\n        this.eventBus.on(CoreEvents.EVENT_DRAG_LEAVE_HEADER, (e) => {\n            const payload = e.detail;\n            this.handleDragLeave(payload);\n        });\n        this.eventBus.on(CoreEvents.EVENT_DRAG_END, (e) => {\n            const payload = e.detail;\n            this.handleDragEnd(payload);\n        });\n        this.eventBus.on(CoreEvents.EVENT_DRAG_CANCEL, () => {\n            this.cleanup();\n        });\n    }\n    /**\n     * Handle drag entering header zone - create preview item\n     */\n    handleDragEnter(payload) {\n        this.container = document.querySelector('swp-header-drawer');\n        if (!this.container)\n            return;\n        // Remember if drawer was already expanded\n        this.wasExpandedBeforeDrag = this.headerDrawerManager.isExpanded();\n        // Expand to at least 1 row if collapsed, otherwise keep current height\n        if (!this.wasExpandedBeforeDrag) {\n            this.headerDrawerManager.expandToRows(1);\n        }\n        // Store reference to source element\n        this.sourceElement = payload.element;\n        // Create header item\n        const item = document.createElement('swp-header-item');\n        item.dataset.eventId = payload.eventId;\n        item.dataset.itemType = payload.itemType;\n        item.dataset.duration = String(payload.duration);\n        item.dataset.columnKey = payload.sourceColumnKey;\n        item.textContent = payload.title;\n        // Apply color class if present\n        if (payload.colorClass) {\n            item.classList.add(payload.colorClass);\n        }\n        // Add dragging state\n        item.classList.add('dragging');\n        // Initial placement (duration determines column span)\n        // gridArea format: \"row / col-start / row+1 / col-end\"\n        const col = payload.sourceColumnIndex + 1;\n        const endCol = col + payload.duration;\n        item.style.gridArea = `1 / ${col} / 2 / ${endCol}`;\n        this.container.appendChild(item);\n        this.currentItem = item;\n        // Hide original element while in header\n        payload.element.style.visibility = 'hidden';\n    }\n    /**\n     * Handle drag moving within header - update column position\n     */\n    handleDragMove(payload) {\n        if (!this.currentItem)\n            return;\n        // Update column position\n        const col = payload.columnIndex + 1;\n        const duration = parseInt(this.currentItem.dataset.duration || '1', 10);\n        const endCol = col + duration;\n        this.currentItem.style.gridArea = `1 / ${col} / 2 / ${endCol}`;\n        // Update columnKey to new position\n        this.currentItem.dataset.columnKey = payload.columnKey;\n    }\n    /**\n     * Handle drag leaving header - cleanup for grid\u2192header drag only\n     */\n    handleDragLeave(payload) {\n        // Only cleanup for grid\u2192header drag (when grid event leaves header back to grid)\n        // For header\u2192grid drag, the header item stays as ghost until drop\n        if (payload.source === 'grid') {\n            this.cleanup();\n        }\n        // For header source, do nothing - ghost stays until EVENT_DRAG_END\n    }\n    /**\n     * Handle drag end - finalize based on drop target\n     */\n    handleDragEnd(payload) {\n        if (payload.target === 'header') {\n            // Grid\u2192Header: Finalize the header item (it stays in header)\n            if (this.currentItem) {\n                this.currentItem.classList.remove('dragging');\n                this.recalculateDrawerLayout();\n                this.currentItem = null;\n                this.sourceElement = null;\n            }\n        }\n        else {\n            // Header\u2192Grid: Remove ghost header item and recalculate\n            const ghost = document.querySelector(`swp-header-item.drag-ghost[data-event-id=\"${payload.swpEvent.eventId}\"]`);\n            ghost?.remove();\n            this.recalculateDrawerLayout();\n        }\n    }\n    /**\n     * Recalculate layout for all items currently in the drawer\n     * Called after drop to reposition items and adjust height\n     */\n    recalculateDrawerLayout() {\n        const drawer = document.querySelector('swp-header-drawer');\n        if (!drawer)\n            return;\n        const items = Array.from(drawer.querySelectorAll('swp-header-item'));\n        if (items.length === 0)\n            return;\n        // Get visible column keys for correct multi-resource positioning\n        const visibleColumnKeys = this.getVisibleColumnKeysFromDOM();\n        if (visibleColumnKeys.length === 0)\n            return;\n        // Build layout data from DOM items - use columnKey directly (opaque matching)\n        const itemData = items.map(item => ({\n            element: item,\n            columnKey: item.dataset.columnKey || '',\n            duration: parseInt(item.dataset.duration || '1', 10)\n        }));\n        // Calculate new layout using track algorithm\n        const tracks = [new Array(visibleColumnKeys.length).fill(false)];\n        for (const item of itemData) {\n            // Direct columnKey matching - no parsing or construction needed\n            const startCol = visibleColumnKeys.indexOf(item.columnKey);\n            if (startCol === -1)\n                continue;\n            const colStart = startCol;\n            const colEnd = Math.min(startCol + item.duration, visibleColumnKeys.length);\n            const row = this.findAvailableRow(tracks, colStart, colEnd);\n            for (let c = colStart; c < colEnd; c++) {\n                tracks[row][c] = true;\n            }\n            // Update element position\n            item.element.style.gridArea = `${row + 1} / ${colStart + 1} / ${row + 2} / ${colEnd + 1}`;\n        }\n        // Update drawer height\n        const rowCount = tracks.length;\n        this.headerDrawerManager.expandToRows(rowCount);\n    }\n    /**\n     * Get visible column keys from DOM (preserves order for multi-resource views)\n     * Uses filterTemplate.buildKeyFromColumn() for consistent key format with events\n     */\n    getVisibleColumnKeysFromDOM() {\n        if (!this.filterTemplate)\n            return [];\n        const columns = document.querySelectorAll('swp-day-column');\n        const columnKeys = [];\n        columns.forEach(col => {\n            const columnKey = this.filterTemplate.buildKeyFromColumn(col);\n            if (columnKey)\n                columnKeys.push(columnKey);\n        });\n        return columnKeys;\n    }\n    /**\n     * Cleanup preview item and restore source visibility\n     */\n    cleanup() {\n        // Remove preview item\n        this.currentItem?.remove();\n        this.currentItem = null;\n        // Restore source element visibility\n        if (this.sourceElement) {\n            this.sourceElement.style.visibility = '';\n            this.sourceElement = null;\n        }\n        // Collapse drawer if it wasn't expanded before drag\n        if (!this.wasExpandedBeforeDrag) {\n            this.headerDrawerManager.collapse();\n        }\n    }\n}\n", "/**\n * ScheduleOverrideStore - IndexedDB ObjectStore for schedule overrides\n *\n * Stores date-specific schedule overrides for resources.\n * Indexes: resourceId, date, compound (resourceId + date)\n */\nexport class ScheduleOverrideStore {\n    constructor() {\n        this.storeName = ScheduleOverrideStore.STORE_NAME;\n    }\n    create(db) {\n        const store = db.createObjectStore(ScheduleOverrideStore.STORE_NAME, { keyPath: 'id' });\n        store.createIndex('resourceId', 'resourceId', { unique: false });\n        store.createIndex('date', 'date', { unique: false });\n        store.createIndex('resourceId_date', ['resourceId', 'date'], { unique: true });\n        store.createIndex('syncStatus', 'syncStatus', { unique: false });\n    }\n}\nScheduleOverrideStore.STORE_NAME = 'scheduleOverrides';\n", "import { ScheduleOverrideStore } from './ScheduleOverrideStore';\n/**\n * ScheduleOverrideService - CRUD for schedule overrides\n *\n * Provides access to date-specific schedule overrides for resources.\n */\nexport class ScheduleOverrideService {\n    constructor(context) {\n        this.context = context;\n    }\n    get db() {\n        return this.context.getDatabase();\n    }\n    /**\n     * Get override for a specific resource and date\n     */\n    async getOverride(resourceId, date) {\n        return new Promise((resolve, reject) => {\n            const transaction = this.db.transaction([ScheduleOverrideStore.STORE_NAME], 'readonly');\n            const store = transaction.objectStore(ScheduleOverrideStore.STORE_NAME);\n            const index = store.index('resourceId_date');\n            const request = index.get([resourceId, date]);\n            request.onsuccess = () => {\n                resolve(request.result || null);\n            };\n            request.onerror = () => {\n                reject(new Error(`Failed to get override for ${resourceId} on ${date}: ${request.error}`));\n            };\n        });\n    }\n    /**\n     * Get all overrides for a resource\n     */\n    async getByResource(resourceId) {\n        return new Promise((resolve, reject) => {\n            const transaction = this.db.transaction([ScheduleOverrideStore.STORE_NAME], 'readonly');\n            const store = transaction.objectStore(ScheduleOverrideStore.STORE_NAME);\n            const index = store.index('resourceId');\n            const request = index.getAll(resourceId);\n            request.onsuccess = () => {\n                resolve(request.result || []);\n            };\n            request.onerror = () => {\n                reject(new Error(`Failed to get overrides for ${resourceId}: ${request.error}`));\n            };\n        });\n    }\n    /**\n     * Get overrides for a date range\n     */\n    async getByDateRange(resourceId, startDate, endDate) {\n        const all = await this.getByResource(resourceId);\n        return all.filter(o => o.date >= startDate && o.date <= endDate);\n    }\n    /**\n     * Save an override\n     */\n    async save(override) {\n        return new Promise((resolve, reject) => {\n            const transaction = this.db.transaction([ScheduleOverrideStore.STORE_NAME], 'readwrite');\n            const store = transaction.objectStore(ScheduleOverrideStore.STORE_NAME);\n            const request = store.put(override);\n            request.onsuccess = () => resolve();\n            request.onerror = () => {\n                reject(new Error(`Failed to save override ${override.id}: ${request.error}`));\n            };\n        });\n    }\n    /**\n     * Delete an override\n     */\n    async delete(id) {\n        return new Promise((resolve, reject) => {\n            const transaction = this.db.transaction([ScheduleOverrideStore.STORE_NAME], 'readwrite');\n            const store = transaction.objectStore(ScheduleOverrideStore.STORE_NAME);\n            const request = store.delete(id);\n            request.onsuccess = () => resolve();\n            request.onerror = () => {\n                reject(new Error(`Failed to delete override ${id}: ${request.error}`));\n            };\n        });\n    }\n}\n", "/**\n * ResourceScheduleService - Get effective schedule for a resource on a date\n *\n * Logic:\n * 1. Check for override on this date\n * 2. Fall back to default schedule for the weekday\n */\nexport class ResourceScheduleService {\n    constructor(resourceService, overrideService, dateService) {\n        this.resourceService = resourceService;\n        this.overrideService = overrideService;\n        this.dateService = dateService;\n    }\n    /**\n     * Get effective schedule for a resource on a specific date\n     *\n     * @param resourceId - Resource ID\n     * @param date - Date string \"YYYY-MM-DD\"\n     * @returns ITimeSlot or null (fri/closed)\n     */\n    async getScheduleForDate(resourceId, date) {\n        // 1. Check for override\n        const override = await this.overrideService.getOverride(resourceId, date);\n        if (override) {\n            return override.schedule;\n        }\n        // 2. Use default schedule for weekday\n        const resource = await this.resourceService.get(resourceId);\n        if (!resource || !resource.defaultSchedule) {\n            return null;\n        }\n        const weekDay = this.dateService.getISOWeekDay(date);\n        return resource.defaultSchedule[weekDay] || null;\n    }\n    /**\n     * Get schedules for multiple dates\n     *\n     * @param resourceId - Resource ID\n     * @param dates - Array of date strings \"YYYY-MM-DD\"\n     * @returns Map of date -> ITimeSlot | null\n     */\n    async getSchedulesForDates(resourceId, dates) {\n        const result = new Map();\n        // Get resource once\n        const resource = await this.resourceService.get(resourceId);\n        // Get all overrides in date range\n        const overrides = dates.length > 0\n            ? await this.overrideService.getByDateRange(resourceId, dates[0], dates[dates.length - 1])\n            : [];\n        // Build override map\n        const overrideMap = new Map(overrides.map(o => [o.date, o.schedule]));\n        // Resolve each date\n        for (const date of dates) {\n            // Check override first\n            if (overrideMap.has(date)) {\n                result.set(date, overrideMap.get(date));\n                continue;\n            }\n            // Fall back to default\n            if (resource?.defaultSchedule) {\n                const weekDay = this.dateService.getISOWeekDay(date);\n                result.set(date, resource.defaultSchedule[weekDay] || null);\n            }\n            else {\n                result.set(date, null);\n            }\n        }\n        return result;\n    }\n}\n", "/**\n * SwpEvent - Wrapper class for calendar event elements\n *\n * Encapsulates an HTMLElement and provides computed properties\n * for start/end times based on element position and grid config.\n *\n * Usage:\n * - eventId is read from element.dataset\n * - columnKey identifies the column uniformly\n * - Position (top, height) is read from element.style\n * - Factory method `fromElement()` calculates Date objects\n */\nexport class SwpEvent {\n    constructor(element, columnKey, start, end) {\n        this.element = element;\n        this.columnKey = columnKey;\n        this._start = start;\n        this._end = end;\n    }\n    /** Event ID from element.dataset.eventId */\n    get eventId() {\n        return this.element.dataset.eventId || '';\n    }\n    get start() {\n        return this._start;\n    }\n    get end() {\n        return this._end;\n    }\n    /** Duration in minutes */\n    get durationMinutes() {\n        return (this._end.getTime() - this._start.getTime()) / (1000 * 60);\n    }\n    /** Duration in milliseconds */\n    get durationMs() {\n        return this._end.getTime() - this._start.getTime();\n    }\n    /**\n     * Factory: Create SwpEvent from element + columnKey\n     * Reads top/height from element.style to calculate start/end\n     * @param columnKey - Opaque column identifier (do NOT parse - use only for matching)\n     * @param date - Date string (YYYY-MM-DD) for time calculations\n     */\n    static fromElement(element, columnKey, date, gridConfig) {\n        const topPixels = parseFloat(element.style.top) || 0;\n        const heightPixels = parseFloat(element.style.height) || 0;\n        // Calculate start from top position\n        const startMinutesFromGrid = (topPixels / gridConfig.hourHeight) * 60;\n        const totalMinutes = (gridConfig.dayStartHour * 60) + startMinutesFromGrid;\n        const start = new Date(date);\n        start.setHours(Math.floor(totalMinutes / 60), totalMinutes % 60, 0, 0);\n        // Calculate end from height\n        const durationMinutes = (heightPixels / gridConfig.hourHeight) * 60;\n        const end = new Date(start.getTime() + durationMinutes * 60 * 1000);\n        return new SwpEvent(element, columnKey, start, end);\n    }\n}\n", "import { CoreEvents } from '../constants/CoreEvents';\nimport { snapToGrid } from '../utils/PositionUtils';\nimport { SwpEvent } from '../types/SwpEvent';\n/**\n * DragDropManager - Handles drag-drop for calendar events\n *\n * Strategy: Drag original element, leave ghost-clone in place\n * - mousedown: Store initial state, wait for movement\n * - mousemove (>5px): Create ghost, start dragging original\n * - mouseup: Snap to grid, remove ghost, emit drag:end\n * - cancel: Animate back to startY, remove ghost\n */\nexport class DragDropManager {\n    constructor(eventBus, gridConfig) {\n        this.eventBus = eventBus;\n        this.gridConfig = gridConfig;\n        this.dragState = null;\n        this.mouseDownPosition = null;\n        this.pendingElement = null;\n        this.pendingMouseOffset = null;\n        this.container = null;\n        this.inHeader = false;\n        this.DRAG_THRESHOLD = 5;\n        this.INTERPOLATION_FACTOR = 0.3;\n        this.handlePointerDown = (e) => {\n            const target = e.target;\n            // Ignore if clicking on resize handle\n            if (target.closest('swp-resize-handle'))\n                return;\n            // Match both swp-event and swp-header-item\n            const eventElement = target.closest('swp-event');\n            const headerItem = target.closest('swp-header-item');\n            const draggable = eventElement || headerItem;\n            if (!draggable)\n                return;\n            // Store for potential drag\n            this.mouseDownPosition = { x: e.clientX, y: e.clientY };\n            this.pendingElement = draggable;\n            // Calculate mouse offset within element\n            const rect = draggable.getBoundingClientRect();\n            this.pendingMouseOffset = {\n                x: e.clientX - rect.left,\n                y: e.clientY - rect.top\n            };\n            // Capture pointer for reliable tracking\n            draggable.setPointerCapture(e.pointerId);\n        };\n        this.handlePointerMove = (e) => {\n            // Not in potential drag state\n            if (!this.mouseDownPosition || !this.pendingElement) {\n                // Already dragging - update target\n                if (this.dragState) {\n                    this.updateDragTarget(e);\n                }\n                return;\n            }\n            // Check threshold\n            const deltaX = Math.abs(e.clientX - this.mouseDownPosition.x);\n            const deltaY = Math.abs(e.clientY - this.mouseDownPosition.y);\n            const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);\n            if (distance < this.DRAG_THRESHOLD)\n                return;\n            // Start drag\n            this.initializeDrag(this.pendingElement, this.pendingMouseOffset, e);\n            this.mouseDownPosition = null;\n            this.pendingElement = null;\n            this.pendingMouseOffset = null;\n        };\n        this.handlePointerUp = (_e) => {\n            // Clear pending state\n            this.mouseDownPosition = null;\n            this.pendingElement = null;\n            this.pendingMouseOffset = null;\n            if (!this.dragState)\n                return;\n            // Stop animation\n            cancelAnimationFrame(this.dragState.animationId);\n            // Handle based on drag source and target\n            if (this.dragState.dragSource === 'header') {\n                // Header item drag end\n                this.handleHeaderItemDragEnd();\n            }\n            else {\n                // Grid event drag end\n                this.handleGridEventDragEnd();\n            }\n            // Cleanup\n            this.dragState.element.classList.remove('dragging');\n            this.dragState = null;\n            this.inHeader = false;\n        };\n        this.animateDrag = () => {\n            if (!this.dragState)\n                return;\n            const diff = this.dragState.targetY - this.dragState.currentY;\n            // Stop animation when close enough to target\n            if (Math.abs(diff) <= 0.5) {\n                this.dragState.animationId = 0;\n                return;\n            }\n            // Interpolate towards target\n            this.dragState.currentY += diff * this.INTERPOLATION_FACTOR;\n            // Update element position\n            this.dragState.element.style.top = `${this.dragState.currentY}px`;\n            // Emit drag:move (only if we have a column)\n            if (this.dragState.columnElement) {\n                const payload = {\n                    eventId: this.dragState.eventId,\n                    element: this.dragState.element,\n                    currentY: this.dragState.currentY,\n                    columnElement: this.dragState.columnElement\n                };\n                this.eventBus.emit(CoreEvents.EVENT_DRAG_MOVE, payload);\n            }\n            // Continue animation\n            this.dragState.animationId = requestAnimationFrame(this.animateDrag);\n        };\n        this.setupScrollListener();\n    }\n    setupScrollListener() {\n        this.eventBus.on(CoreEvents.EDGE_SCROLL_TICK, (e) => {\n            if (!this.dragState)\n                return;\n            const { scrollDelta } = e.detail;\n            // Element skal flytte med scroll for at forblive under musen\n            // (elementets top er relativ til kolonnen, som scroller med viewport)\n            this.dragState.targetY += scrollDelta;\n            this.dragState.currentY += scrollDelta;\n            this.dragState.element.style.top = `${this.dragState.currentY}px`;\n        });\n    }\n    /**\n     * Initialize drag-drop on a container element\n     */\n    init(container) {\n        this.container = container;\n        container.addEventListener('pointerdown', this.handlePointerDown);\n        document.addEventListener('pointermove', this.handlePointerMove);\n        document.addEventListener('pointerup', this.handlePointerUp);\n    }\n    /**\n     * Handle drag end for header items\n     */\n    handleHeaderItemDragEnd() {\n        if (!this.dragState)\n            return;\n        // If dropped in grid (not in header), the swp-event was already created\n        // by EventRenderer listening to EVENT_DRAG_LEAVE_HEADER\n        // Just emit drag:end for persistence\n        if (!this.inHeader && this.dragState.currentColumn) {\n            // Dropped in grid - emit drag:end with the new swp-event element\n            const gridEvent = this.dragState.currentColumn.querySelector(`swp-event[data-event-id=\"${this.dragState.eventId}\"]`);\n            if (gridEvent) {\n                const columnKey = this.dragState.currentColumn.dataset.columnKey || '';\n                const date = this.dragState.currentColumn.dataset.date || '';\n                const swpEvent = SwpEvent.fromElement(gridEvent, columnKey, date, this.gridConfig);\n                const payload = {\n                    swpEvent,\n                    sourceColumnKey: this.dragState.sourceColumnKey,\n                    target: 'grid'\n                };\n                this.eventBus.emit(CoreEvents.EVENT_DRAG_END, payload);\n            }\n        }\n        // If still in header, no persistence needed (stayed in header)\n    }\n    /**\n     * Handle drag end for grid events\n     */\n    handleGridEventDragEnd() {\n        if (!this.dragState || !this.dragState.columnElement)\n            return;\n        // Snap to grid\n        const snappedY = snapToGrid(this.dragState.currentY, this.gridConfig);\n        this.dragState.element.style.top = `${snappedY}px`;\n        // Remove ghost\n        this.dragState.ghostElement?.remove();\n        // Get columnKey and date from target column\n        const columnKey = this.dragState.columnElement.dataset.columnKey || '';\n        const date = this.dragState.columnElement.dataset.date || '';\n        // Create SwpEvent from element (reads top/height/eventId from element)\n        const swpEvent = SwpEvent.fromElement(this.dragState.element, columnKey, date, this.gridConfig);\n        // Emit drag:end\n        const payload = {\n            swpEvent,\n            sourceColumnKey: this.dragState.sourceColumnKey,\n            target: this.inHeader ? 'header' : 'grid'\n        };\n        this.eventBus.emit(CoreEvents.EVENT_DRAG_END, payload);\n    }\n    initializeDrag(element, mouseOffset, e) {\n        const eventId = element.dataset.eventId || '';\n        const isHeaderItem = element.tagName.toLowerCase() === 'swp-header-item';\n        const columnElement = element.closest('swp-day-column');\n        // For grid events, we need a column\n        if (!isHeaderItem && !columnElement)\n            return;\n        if (isHeaderItem) {\n            // Header item drag initialization\n            this.initializeHeaderItemDrag(element, mouseOffset, eventId);\n        }\n        else {\n            // Grid event drag initialization\n            this.initializeGridEventDrag(element, mouseOffset, e, columnElement, eventId);\n        }\n    }\n    /**\n     * Initialize drag for a header item (allDay event)\n     */\n    initializeHeaderItemDrag(element, mouseOffset, eventId) {\n        // Mark as dragging\n        element.classList.add('dragging');\n        // Initialize drag state for header item\n        this.dragState = {\n            eventId,\n            element,\n            ghostElement: null, // No ghost for header items\n            startY: 0,\n            mouseOffset,\n            columnElement: null,\n            currentColumn: null,\n            targetY: 0,\n            currentY: 0,\n            animationId: 0,\n            sourceColumnKey: '', // Will be set from header item data\n            dragSource: 'header'\n        };\n        // Start in header mode\n        this.inHeader = true;\n    }\n    /**\n     * Initialize drag for a grid event\n     */\n    initializeGridEventDrag(element, mouseOffset, e, columnElement, eventId) {\n        // Calculate absolute Y position using getBoundingClientRect\n        const elementRect = element.getBoundingClientRect();\n        const columnRect = columnElement.getBoundingClientRect();\n        const startY = elementRect.top - columnRect.top;\n        // If event is inside a group, move it to events-layer for correct positioning during drag\n        const group = element.closest('swp-event-group');\n        if (group) {\n            const eventsLayer = columnElement.querySelector('swp-events-layer');\n            if (eventsLayer) {\n                eventsLayer.appendChild(element);\n            }\n        }\n        // Set consistent positioning for drag (works for both grouped and stacked events)\n        element.style.position = 'absolute';\n        element.style.top = `${startY}px`;\n        element.style.left = '2px';\n        element.style.right = '2px';\n        element.style.marginLeft = '0'; // Reset stacking margin\n        // Create ghost clone\n        const ghostElement = element.cloneNode(true);\n        ghostElement.classList.add('drag-ghost');\n        ghostElement.style.opacity = '0.3';\n        ghostElement.style.pointerEvents = 'none';\n        // Insert ghost before original\n        element.parentNode?.insertBefore(ghostElement, element);\n        // Setup element for dragging\n        element.classList.add('dragging');\n        // Calculate initial target from mouse position\n        const targetY = e.clientY - columnRect.top - mouseOffset.y;\n        // Initialize drag state\n        this.dragState = {\n            eventId,\n            element,\n            ghostElement,\n            startY,\n            mouseOffset,\n            columnElement,\n            currentColumn: columnElement,\n            targetY: Math.max(0, targetY),\n            currentY: startY,\n            animationId: 0,\n            sourceColumnKey: columnElement.dataset.columnKey || '',\n            dragSource: 'grid'\n        };\n        // Emit drag:start\n        const payload = {\n            eventId,\n            element,\n            ghostElement,\n            startY,\n            mouseOffset,\n            columnElement\n        };\n        this.eventBus.emit(CoreEvents.EVENT_DRAG_START, payload);\n        // Start animation loop\n        this.animateDrag();\n    }\n    updateDragTarget(e) {\n        if (!this.dragState)\n            return;\n        // Check header zone first\n        this.checkHeaderZone(e);\n        // Skip normal grid handling if in header\n        if (this.inHeader)\n            return;\n        // Check for column change\n        const columnAtPoint = this.getColumnAtPoint(e.clientX);\n        // For header items entering grid, set initial column\n        if (this.dragState.dragSource === 'header' && columnAtPoint && !this.dragState.currentColumn) {\n            this.dragState.currentColumn = columnAtPoint;\n            this.dragState.columnElement = columnAtPoint;\n        }\n        if (columnAtPoint && columnAtPoint !== this.dragState.currentColumn && this.dragState.currentColumn) {\n            const payload = {\n                eventId: this.dragState.eventId,\n                element: this.dragState.element,\n                previousColumn: this.dragState.currentColumn,\n                newColumn: columnAtPoint,\n                currentY: this.dragState.currentY\n            };\n            this.eventBus.emit(CoreEvents.EVENT_DRAG_COLUMN_CHANGE, payload);\n            this.dragState.currentColumn = columnAtPoint;\n            this.dragState.columnElement = columnAtPoint;\n        }\n        // Skip grid position updates if no column yet\n        if (!this.dragState.columnElement)\n            return;\n        const columnRect = this.dragState.columnElement.getBoundingClientRect();\n        const targetY = e.clientY - columnRect.top - this.dragState.mouseOffset.y;\n        this.dragState.targetY = Math.max(0, targetY);\n        // Start animation if not running\n        if (!this.dragState.animationId) {\n            this.animateDrag();\n        }\n    }\n    /**\n     * Check if pointer is in header zone and emit appropriate events\n     */\n    checkHeaderZone(e) {\n        if (!this.dragState)\n            return;\n        const headerViewport = document.querySelector('swp-header-viewport');\n        if (!headerViewport)\n            return;\n        const rect = headerViewport.getBoundingClientRect();\n        const isInHeader = e.clientY < rect.bottom;\n        if (isInHeader && !this.inHeader) {\n            // Entered header (from grid)\n            this.inHeader = true;\n            if (this.dragState.dragSource === 'grid' && this.dragState.columnElement) {\n                const payload = {\n                    eventId: this.dragState.eventId,\n                    element: this.dragState.element,\n                    sourceColumnIndex: this.getColumnIndex(this.dragState.columnElement),\n                    sourceColumnKey: this.dragState.columnElement.dataset.columnKey || '',\n                    title: this.dragState.element.querySelector('swp-event-title')?.textContent || '',\n                    colorClass: [...this.dragState.element.classList].find(c => c.startsWith('is-')),\n                    itemType: 'event',\n                    duration: 1\n                };\n                this.eventBus.emit(CoreEvents.EVENT_DRAG_ENTER_HEADER, payload);\n            }\n            // For header source re-entering header, just update inHeader flag\n        }\n        else if (!isInHeader && this.inHeader) {\n            // Left header (entering grid)\n            this.inHeader = false;\n            const targetColumn = this.getColumnAtPoint(e.clientX);\n            if (this.dragState.dragSource === 'header') {\n                // Header item leaving header \u2192 create swp-event in grid\n                const payload = {\n                    eventId: this.dragState.eventId,\n                    source: 'header',\n                    element: this.dragState.element,\n                    targetColumn: targetColumn || undefined,\n                    start: this.dragState.element.dataset.start ? new Date(this.dragState.element.dataset.start) : undefined,\n                    end: this.dragState.element.dataset.end ? new Date(this.dragState.element.dataset.end) : undefined,\n                    title: this.dragState.element.textContent || '',\n                    colorClass: [...this.dragState.element.classList].find(c => c.startsWith('is-'))\n                };\n                this.eventBus.emit(CoreEvents.EVENT_DRAG_LEAVE_HEADER, payload);\n                // Re-attach to the new swp-event created by EventRenderer\n                if (targetColumn) {\n                    const newElement = targetColumn.querySelector(`swp-event[data-event-id=\"${this.dragState.eventId}\"]`);\n                    if (newElement) {\n                        this.dragState.element = newElement;\n                        this.dragState.columnElement = targetColumn;\n                        this.dragState.currentColumn = targetColumn;\n                        // Start animation for the new element\n                        this.animateDrag();\n                    }\n                }\n            }\n            else {\n                // Grid event leaving header \u2192 restore to grid\n                const payload = {\n                    eventId: this.dragState.eventId,\n                    source: 'grid'\n                };\n                this.eventBus.emit(CoreEvents.EVENT_DRAG_LEAVE_HEADER, payload);\n            }\n        }\n        else if (isInHeader) {\n            // Moving within header\n            const column = this.getColumnAtX(e.clientX);\n            if (column) {\n                const payload = {\n                    eventId: this.dragState.eventId,\n                    columnIndex: this.getColumnIndex(column),\n                    columnKey: column.dataset.columnKey || ''\n                };\n                this.eventBus.emit(CoreEvents.EVENT_DRAG_MOVE_HEADER, payload);\n            }\n        }\n    }\n    /**\n     * Get column index (0-based) for a column element\n     */\n    getColumnIndex(column) {\n        if (!this.container || !column)\n            return 0;\n        const columns = Array.from(this.container.querySelectorAll('swp-day-column'));\n        return columns.indexOf(column);\n    }\n    /**\n     * Get column at X coordinate (alias for getColumnAtPoint)\n     */\n    getColumnAtX(clientX) {\n        return this.getColumnAtPoint(clientX);\n    }\n    /**\n     * Find column element at given X coordinate\n     */\n    getColumnAtPoint(clientX) {\n        if (!this.container)\n            return null;\n        const columns = this.container.querySelectorAll('swp-day-column');\n        for (const col of columns) {\n            const rect = col.getBoundingClientRect();\n            if (clientX >= rect.left && clientX <= rect.right) {\n                return col;\n            }\n        }\n        return null;\n    }\n    /**\n     * Cancel drag and animate back to start position\n     */\n    cancelDrag() {\n        if (!this.dragState)\n            return;\n        // Stop animation\n        cancelAnimationFrame(this.dragState.animationId);\n        const { element, ghostElement, startY, eventId } = this.dragState;\n        // Animate back to start\n        element.style.transition = 'top 200ms ease-out';\n        element.style.top = `${startY}px`;\n        // Remove ghost after animation (if exists)\n        setTimeout(() => {\n            ghostElement?.remove();\n            element.style.transition = '';\n            element.classList.remove('dragging');\n        }, 200);\n        // Emit drag:cancel\n        const payload = {\n            eventId,\n            element,\n            startY\n        };\n        this.eventBus.emit(CoreEvents.EVENT_DRAG_CANCEL, payload);\n        this.dragState = null;\n        this.inHeader = false;\n    }\n}\n", "import { CoreEvents } from '../constants/CoreEvents';\nexport class EdgeScrollManager {\n    constructor(eventBus) {\n        this.eventBus = eventBus;\n        this.scrollableContent = null;\n        this.timeGrid = null;\n        this.draggedElement = null;\n        this.scrollRAF = null;\n        this.mouseY = 0;\n        this.isDragging = false;\n        this.isScrolling = false;\n        this.lastTs = 0;\n        this.rect = null;\n        this.initialScrollTop = 0;\n        this.OUTER_ZONE = 100;\n        this.INNER_ZONE = 50;\n        this.SLOW_SPEED = 140;\n        this.FAST_SPEED = 640;\n        this.trackMouse = (e) => {\n            if (this.isDragging) {\n                this.mouseY = e.clientY;\n            }\n        };\n        this.scrollTick = (ts) => {\n            if (!this.isDragging || !this.scrollableContent)\n                return;\n            const dt = this.lastTs ? (ts - this.lastTs) / 1000 : 0;\n            this.lastTs = ts;\n            this.rect ?? (this.rect = this.scrollableContent.getBoundingClientRect());\n            const velocity = this.calculateVelocity();\n            if (velocity !== 0 && !this.isAtBoundary(velocity)) {\n                const scrollDelta = velocity * dt;\n                this.scrollableContent.scrollTop += scrollDelta;\n                this.rect = null;\n                this.eventBus.emit(CoreEvents.EDGE_SCROLL_TICK, { scrollDelta });\n                this.setScrollingState(true);\n            }\n            else {\n                this.setScrollingState(false);\n            }\n            this.scrollRAF = requestAnimationFrame(this.scrollTick);\n        };\n        this.subscribeToEvents();\n        document.addEventListener('pointermove', this.trackMouse);\n    }\n    init(scrollableContent) {\n        this.scrollableContent = scrollableContent;\n        this.timeGrid = scrollableContent.querySelector('swp-time-grid');\n        this.scrollableContent.style.scrollBehavior = 'auto';\n    }\n    subscribeToEvents() {\n        this.eventBus.on(CoreEvents.EVENT_DRAG_START, (event) => {\n            const payload = event.detail;\n            this.draggedElement = payload.element;\n            this.startDrag();\n        });\n        this.eventBus.on(CoreEvents.EVENT_DRAG_END, () => this.stopDrag());\n        this.eventBus.on(CoreEvents.EVENT_DRAG_CANCEL, () => this.stopDrag());\n    }\n    startDrag() {\n        this.isDragging = true;\n        this.isScrolling = false;\n        this.lastTs = 0;\n        this.initialScrollTop = this.scrollableContent?.scrollTop ?? 0;\n        if (this.scrollRAF === null) {\n            this.scrollRAF = requestAnimationFrame(this.scrollTick);\n        }\n    }\n    stopDrag() {\n        this.isDragging = false;\n        this.setScrollingState(false);\n        if (this.scrollRAF !== null) {\n            cancelAnimationFrame(this.scrollRAF);\n            this.scrollRAF = null;\n        }\n        this.rect = null;\n        this.lastTs = 0;\n        this.initialScrollTop = 0;\n    }\n    calculateVelocity() {\n        if (!this.rect)\n            return 0;\n        const distTop = this.mouseY - this.rect.top;\n        const distBot = this.rect.bottom - this.mouseY;\n        if (distTop < this.INNER_ZONE)\n            return -this.FAST_SPEED;\n        if (distTop < this.OUTER_ZONE)\n            return -this.SLOW_SPEED;\n        if (distBot < this.INNER_ZONE)\n            return this.FAST_SPEED;\n        if (distBot < this.OUTER_ZONE)\n            return this.SLOW_SPEED;\n        return 0;\n    }\n    isAtBoundary(velocity) {\n        if (!this.scrollableContent || !this.timeGrid || !this.draggedElement)\n            return false;\n        const atTop = this.scrollableContent.scrollTop <= 0 && velocity < 0;\n        const atBottom = velocity > 0 &&\n            this.draggedElement.getBoundingClientRect().bottom >=\n                this.timeGrid.getBoundingClientRect().bottom;\n        return atTop || atBottom;\n    }\n    setScrollingState(scrolling) {\n        if (this.isScrolling === scrolling)\n            return;\n        this.isScrolling = scrolling;\n        if (scrolling) {\n            this.eventBus.emit(CoreEvents.EDGE_SCROLL_STARTED, {});\n        }\n        else {\n            this.initialScrollTop = this.scrollableContent?.scrollTop ?? 0;\n            this.eventBus.emit(CoreEvents.EDGE_SCROLL_STOPPED, {});\n        }\n    }\n}\n", "import { pixelsToMinutes, minutesToPixels, snapToGrid } from '../utils/PositionUtils';\nimport { CoreEvents } from '../constants/CoreEvents';\nimport { SwpEvent } from '../types/SwpEvent';\nexport class ResizeManager {\n    constructor(eventBus, gridConfig, dateService) {\n        this.eventBus = eventBus;\n        this.gridConfig = gridConfig;\n        this.dateService = dateService;\n        this.container = null;\n        this.resizeState = null;\n        this.Z_INDEX_RESIZING = '1000';\n        this.ANIMATION_SPEED = 0.35;\n        this.MIN_HEIGHT_MINUTES = 15;\n        /**\n         * Handle mouseover - create resize handle if not exists\n         */\n        this.handleMouseOver = (e) => {\n            const target = e.target;\n            const eventElement = target.closest('swp-event');\n            if (!eventElement || this.resizeState)\n                return;\n            // Check if handle already exists\n            if (!eventElement.querySelector(':scope > swp-resize-handle')) {\n                const handle = this.createResizeHandle();\n                eventElement.appendChild(handle);\n            }\n        };\n        /**\n         * Handle pointerdown - start resize if on handle\n         */\n        this.handlePointerDown = (e) => {\n            const handle = e.target.closest('swp-resize-handle');\n            if (!handle)\n                return;\n            const element = handle.parentElement;\n            if (!element)\n                return;\n            const eventId = element.dataset.eventId || '';\n            const startHeight = element.offsetHeight;\n            const startDurationMinutes = pixelsToMinutes(startHeight, this.gridConfig);\n            // Store previous z-index\n            const container = element.closest('swp-event-group') ?? element;\n            const prevZIndex = container.style.zIndex;\n            // Set resize state\n            this.resizeState = {\n                eventId,\n                element,\n                handleElement: handle,\n                startY: e.clientY,\n                startHeight,\n                startDurationMinutes,\n                pointerId: e.pointerId,\n                prevZIndex,\n                // Animation state\n                currentHeight: startHeight,\n                targetHeight: startHeight,\n                animationId: null\n            };\n            // Elevate z-index\n            container.style.zIndex = this.Z_INDEX_RESIZING;\n            // Capture pointer for smooth tracking\n            try {\n                handle.setPointerCapture(e.pointerId);\n            }\n            catch (err) {\n                console.warn('Pointer capture failed:', err);\n            }\n            // Add global resizing class\n            document.documentElement.classList.add('swp--resizing');\n            // Emit resize start event\n            this.eventBus.emit(CoreEvents.EVENT_RESIZE_START, {\n                eventId,\n                element,\n                startHeight\n            });\n            e.preventDefault();\n        };\n        /**\n         * Handle pointermove - update target height during resize\n         */\n        this.handlePointerMove = (e) => {\n            if (!this.resizeState)\n                return;\n            const deltaY = e.clientY - this.resizeState.startY;\n            const minHeight = (this.MIN_HEIGHT_MINUTES / 60) * this.gridConfig.hourHeight;\n            const newHeight = Math.max(minHeight, this.resizeState.startHeight + deltaY);\n            // Set target height for animation\n            this.resizeState.targetHeight = newHeight;\n            // Start animation if not running\n            if (this.resizeState.animationId === null) {\n                this.animateHeight();\n            }\n        };\n        /**\n         * RAF animation loop for smooth height interpolation\n         */\n        this.animateHeight = () => {\n            if (!this.resizeState)\n                return;\n            const diff = this.resizeState.targetHeight - this.resizeState.currentHeight;\n            // Stop animation when close enough\n            if (Math.abs(diff) < 0.5) {\n                this.resizeState.animationId = null;\n                return;\n            }\n            // Interpolate towards target (35% per frame like V1)\n            this.resizeState.currentHeight += diff * this.ANIMATION_SPEED;\n            this.resizeState.element.style.height = `${this.resizeState.currentHeight}px`;\n            // Update timestamp display (snapped)\n            this.updateTimestampDisplay();\n            // Continue animation\n            this.resizeState.animationId = requestAnimationFrame(this.animateHeight);\n        };\n        /**\n         * Handle pointerup - finish resize\n         */\n        this.handlePointerUp = (e) => {\n            if (!this.resizeState)\n                return;\n            // Cancel any pending animation\n            if (this.resizeState.animationId !== null) {\n                cancelAnimationFrame(this.resizeState.animationId);\n            }\n            // Release pointer capture\n            try {\n                this.resizeState.handleElement.releasePointerCapture(e.pointerId);\n            }\n            catch (err) {\n                console.warn('Pointer release failed:', err);\n            }\n            // Snap final height to grid\n            this.snapToGridFinal();\n            // Update timestamp one final time\n            this.updateTimestampDisplay();\n            // Restore z-index\n            const container = this.resizeState.element.closest('swp-event-group') ?? this.resizeState.element;\n            container.style.zIndex = this.resizeState.prevZIndex;\n            // Remove global resizing class\n            document.documentElement.classList.remove('swp--resizing');\n            // Get columnKey and date from parent column\n            const column = this.resizeState.element.closest('swp-day-column');\n            const columnKey = column?.dataset.columnKey || '';\n            const date = column?.dataset.date || '';\n            // Create SwpEvent from element (reads top/height/eventId from element)\n            const swpEvent = SwpEvent.fromElement(this.resizeState.element, columnKey, date, this.gridConfig);\n            // Emit resize end event\n            this.eventBus.emit(CoreEvents.EVENT_RESIZE_END, {\n                swpEvent\n            });\n            // Reset state\n            this.resizeState = null;\n        };\n    }\n    /**\n     * Initialize resize functionality on container\n     */\n    init(container) {\n        this.container = container;\n        // Mouseover listener for handle creation (capture phase like V1)\n        container.addEventListener('mouseover', this.handleMouseOver, true);\n        // Pointer listeners for resize (capture phase like V1)\n        document.addEventListener('pointerdown', this.handlePointerDown, true);\n        document.addEventListener('pointermove', this.handlePointerMove, true);\n        document.addEventListener('pointerup', this.handlePointerUp, true);\n    }\n    /**\n     * Create resize handle element\n     */\n    createResizeHandle() {\n        const handle = document.createElement('swp-resize-handle');\n        handle.setAttribute('aria-label', 'Resize event');\n        handle.setAttribute('role', 'separator');\n        return handle;\n    }\n    /**\n     * Update timestamp display with snapped end time\n     */\n    updateTimestampDisplay() {\n        if (!this.resizeState)\n            return;\n        const timeEl = this.resizeState.element.querySelector('swp-event-time');\n        if (!timeEl)\n            return;\n        // Get start time from element position\n        const top = parseFloat(this.resizeState.element.style.top) || 0;\n        const startMinutesFromGrid = pixelsToMinutes(top, this.gridConfig);\n        const startMinutes = (this.gridConfig.dayStartHour * 60) + startMinutesFromGrid;\n        // Calculate snapped end time from current height\n        const snappedHeight = snapToGrid(this.resizeState.currentHeight, this.gridConfig);\n        const durationMinutes = pixelsToMinutes(snappedHeight, this.gridConfig);\n        const endMinutes = startMinutes + durationMinutes;\n        // Format and update\n        const start = this.minutesToDate(startMinutes);\n        const end = this.minutesToDate(endMinutes);\n        timeEl.textContent = this.dateService.formatTimeRange(start, end);\n    }\n    /**\n     * Convert minutes since midnight to Date\n     */\n    minutesToDate(minutes) {\n        const date = new Date();\n        date.setHours(Math.floor(minutes / 60) % 24, minutes % 60, 0, 0);\n        return date;\n    }\n    ;\n    /**\n     * Snap final height to grid interval\n     */\n    snapToGridFinal() {\n        if (!this.resizeState)\n            return;\n        const currentHeight = this.resizeState.element.offsetHeight;\n        const snappedHeight = snapToGrid(currentHeight, this.gridConfig);\n        const minHeight = minutesToPixels(this.MIN_HEIGHT_MINUTES, this.gridConfig);\n        const finalHeight = Math.max(minHeight, snappedHeight);\n        this.resizeState.element.style.height = `${finalHeight}px`;\n        this.resizeState.currentHeight = finalHeight;\n    }\n}\n", "import { CoreEvents } from '../constants/CoreEvents';\nexport class EventPersistenceManager {\n    constructor(eventService, eventBus, dateService) {\n        this.eventService = eventService;\n        this.eventBus = eventBus;\n        this.dateService = dateService;\n        /**\n         * Handle drag end - update event position in IndexedDB\n         */\n        this.handleDragEnd = async (e) => {\n            const payload = e.detail;\n            const { swpEvent } = payload;\n            // Get existing event to merge with\n            const event = await this.eventService.get(swpEvent.eventId);\n            if (!event) {\n                console.warn(`EventPersistenceManager: Event ${swpEvent.eventId} not found`);\n                return;\n            }\n            // Parse resourceId from columnKey if present\n            const { resource } = this.dateService.parseColumnKey(swpEvent.columnKey);\n            // Update and save - start/end already calculated in SwpEvent\n            // Set allDay based on drop target:\n            // - header: allDay = true\n            // - grid: allDay = false (converts allDay event to timed)\n            const updatedEvent = {\n                ...event,\n                start: swpEvent.start,\n                end: swpEvent.end,\n                resourceId: resource ?? event.resourceId,\n                allDay: payload.target === 'header',\n                syncStatus: 'pending'\n            };\n            await this.eventService.save(updatedEvent);\n            // Emit EVENT_UPDATED for EventRenderer to re-render affected columns\n            const updatePayload = {\n                eventId: updatedEvent.id,\n                sourceColumnKey: payload.sourceColumnKey,\n                targetColumnKey: swpEvent.columnKey\n            };\n            this.eventBus.emit(CoreEvents.EVENT_UPDATED, updatePayload);\n        };\n        /**\n         * Handle resize end - update event duration in IndexedDB\n         */\n        this.handleResizeEnd = async (e) => {\n            const payload = e.detail;\n            const { swpEvent } = payload;\n            // Get existing event to merge with\n            const event = await this.eventService.get(swpEvent.eventId);\n            if (!event) {\n                console.warn(`EventPersistenceManager: Event ${swpEvent.eventId} not found`);\n                return;\n            }\n            // Update and save - end already calculated in SwpEvent\n            const updatedEvent = {\n                ...event,\n                end: swpEvent.end,\n                syncStatus: 'pending'\n            };\n            await this.eventService.save(updatedEvent);\n            // Emit EVENT_UPDATED for EventRenderer to re-render the column\n            // Resize stays in same column, so source and target are the same\n            const updatePayload = {\n                eventId: updatedEvent.id,\n                sourceColumnKey: swpEvent.columnKey,\n                targetColumnKey: swpEvent.columnKey\n            };\n            this.eventBus.emit(CoreEvents.EVENT_UPDATED, updatePayload);\n        };\n        this.setupListeners();\n    }\n    setupListeners() {\n        this.eventBus.on(CoreEvents.EVENT_DRAG_END, this.handleDragEnd);\n        this.eventBus.on(CoreEvents.EVENT_RESIZE_END, this.handleResizeEnd);\n    }\n}\n", "import { Container } from '@novadi/core';\nimport { DateRenderer } from './features/date/DateRenderer';\nimport { DateService } from './core/DateService';\nimport { ResourceRenderer } from './features/resource/ResourceRenderer';\nimport { TeamRenderer } from './features/team/TeamRenderer';\nimport { DepartmentRenderer } from './features/department/DepartmentRenderer';\nimport { CalendarOrchestrator } from './core/CalendarOrchestrator';\nimport { CalendarApp } from './core/CalendarApp';\nimport { TimeAxisRenderer } from './features/timeaxis/TimeAxisRenderer';\nimport { ScrollManager } from './core/ScrollManager';\nimport { HeaderDrawerManager } from './core/HeaderDrawerManager';\nimport { MockTeamStore, MockResourceStore } from './demo/MockStores';\nimport { DemoApp } from './demo/DemoApp';\n// Event system\nimport { EventBus } from './core/EventBus';\n// Storage\nimport { IndexedDBContext } from './storage/IndexedDBContext';\nimport { EventStore } from './storage/events/EventStore';\nimport { EventService } from './storage/events/EventService';\nimport { ResourceStore } from './storage/resources/ResourceStore';\nimport { ResourceService } from './storage/resources/ResourceService';\nimport { BookingStore } from './storage/bookings/BookingStore';\nimport { BookingService } from './storage/bookings/BookingService';\nimport { CustomerStore } from './storage/customers/CustomerStore';\nimport { CustomerService } from './storage/customers/CustomerService';\nimport { TeamStore } from './storage/teams/TeamStore';\nimport { TeamService } from './storage/teams/TeamService';\nimport { DepartmentStore } from './storage/departments/DepartmentStore';\nimport { DepartmentService } from './storage/departments/DepartmentService';\nimport { SettingsStore } from './storage/settings/SettingsStore';\nimport { SettingsService } from './storage/settings/SettingsService';\nimport { ViewConfigStore } from './storage/viewconfigs/ViewConfigStore';\nimport { ViewConfigService } from './storage/viewconfigs/ViewConfigService';\n// Audit\nimport { AuditStore } from './storage/audit/AuditStore';\nimport { AuditService } from './storage/audit/AuditService';\nimport { MockEventRepository } from './repositories/MockEventRepository';\nimport { MockResourceRepository } from './repositories/MockResourceRepository';\nimport { MockBookingRepository } from './repositories/MockBookingRepository';\nimport { MockCustomerRepository } from './repositories/MockCustomerRepository';\nimport { MockAuditRepository } from './repositories/MockAuditRepository';\nimport { MockTeamRepository } from './repositories/MockTeamRepository';\nimport { MockDepartmentRepository } from './repositories/MockDepartmentRepository';\nimport { MockSettingsRepository } from './repositories/MockSettingsRepository';\nimport { MockViewConfigRepository } from './repositories/MockViewConfigRepository';\n// Workers\nimport { DataSeeder } from './workers/DataSeeder';\n// Features\nimport { EventRenderer } from './features/event/EventRenderer';\nimport { ScheduleRenderer } from './features/schedule/ScheduleRenderer';\nimport { HeaderDrawerRenderer } from './features/headerdrawer/HeaderDrawerRenderer';\n// Schedule\nimport { ScheduleOverrideStore } from './storage/schedules/ScheduleOverrideStore';\nimport { ScheduleOverrideService } from './storage/schedules/ScheduleOverrideService';\nimport { ResourceScheduleService } from './storage/schedules/ResourceScheduleService';\n// Managers\nimport { DragDropManager } from './managers/DragDropManager';\nimport { EdgeScrollManager } from './managers/EdgeScrollManager';\nimport { ResizeManager } from './managers/ResizeManager';\nimport { EventPersistenceManager } from './managers/EventPersistenceManager';\nconst defaultTimeFormatConfig = {\n    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,\n    use24HourFormat: true,\n    locale: 'da-DK',\n    dateFormat: 'locale',\n    showSeconds: false\n};\nconst defaultGridConfig = {\n    hourHeight: 64,\n    dayStartHour: 6,\n    dayEndHour: 18,\n    snapInterval: 15,\n    gridStartThresholdMinutes: 30\n};\nexport function createContainer() {\n    const container = new Container();\n    const builder = container.builder();\n    // Config\n    builder.registerInstance(defaultTimeFormatConfig).as(\"ITimeFormatConfig\");\n    builder.registerInstance(defaultGridConfig).as(\"IGridConfig\");\n    // Core - EventBus\n    builder.registerType(EventBus).as(\"EventBus\");\n    builder.registerType(EventBus).as(\"IEventBus\");\n    // Services\n    builder.registerType(DateService).as(\"DateService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"ITimeFormatConfig\"),\n            undefined\n        ]\n    });\n    // Storage infrastructure\n    builder.registerType(IndexedDBContext).as(\"IndexedDBContext\").autoWire({\n        mapResolvers: [\n            c => c.resolveTypeAll(\"IStore\")\n        ]\n    });\n    // Stores (for IndexedDB schema creation)\n    builder.registerType(EventStore).as(\"IStore\");\n    builder.registerType(ResourceStore).as(\"IStore\");\n    builder.registerType(BookingStore).as(\"IStore\");\n    builder.registerType(CustomerStore).as(\"IStore\");\n    builder.registerType(TeamStore).as(\"IStore\");\n    builder.registerType(DepartmentStore).as(\"IStore\");\n    builder.registerType(ScheduleOverrideStore).as(\"IStore\");\n    builder.registerType(AuditStore).as(\"IStore\");\n    builder.registerType(SettingsStore).as(\"IStore\");\n    builder.registerType(ViewConfigStore).as(\"IStore\");\n    // Entity services (for DataSeeder polymorphic array)\n    builder.registerType(EventService).as(\"IEntityService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(EventService).as(\"IEntityService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(EventService).as(\"EventService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(ResourceService).as(\"IEntityService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(ResourceService).as(\"IEntityService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(ResourceService).as(\"ResourceService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(BookingService).as(\"IEntityService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(BookingService).as(\"IEntityService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(BookingService).as(\"BookingService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(CustomerService).as(\"IEntityService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(CustomerService).as(\"IEntityService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(CustomerService).as(\"CustomerService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(TeamService).as(\"IEntityService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(TeamService).as(\"IEntityService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(TeamService).as(\"TeamService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(DepartmentService).as(\"IEntityService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(DepartmentService).as(\"IEntityService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(DepartmentService).as(\"DepartmentService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(SettingsService).as(\"IEntityService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(SettingsService).as(\"IEntityService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(SettingsService).as(\"SettingsService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(ViewConfigService).as(\"IEntityService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(ViewConfigService).as(\"IEntityService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(ViewConfigService).as(\"ViewConfigService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    // Repositories (for DataSeeder polymorphic array)\n    builder.registerType(MockEventRepository).as(\"IApiRepository\");\n    builder.registerType(MockEventRepository).as(\"IApiRepository\");\n    builder.registerType(MockResourceRepository).as(\"IApiRepository\");\n    builder.registerType(MockResourceRepository).as(\"IApiRepository\");\n    builder.registerType(MockBookingRepository).as(\"IApiRepository\");\n    builder.registerType(MockBookingRepository).as(\"IApiRepository\");\n    builder.registerType(MockCustomerRepository).as(\"IApiRepository\");\n    builder.registerType(MockCustomerRepository).as(\"IApiRepository\");\n    builder.registerType(MockAuditRepository).as(\"IApiRepository\");\n    builder.registerType(MockAuditRepository).as(\"IApiRepository\");\n    builder.registerType(MockTeamRepository).as(\"IApiRepository\");\n    builder.registerType(MockTeamRepository).as(\"IApiRepository\");\n    builder.registerType(MockDepartmentRepository).as(\"IApiRepository\");\n    builder.registerType(MockDepartmentRepository).as(\"IApiRepository\");\n    builder.registerType(MockSettingsRepository).as(\"IApiRepository\");\n    builder.registerType(MockSettingsRepository).as(\"IApiRepository\");\n    builder.registerType(MockViewConfigRepository).as(\"IApiRepository\");\n    builder.registerType(MockViewConfigRepository).as(\"IApiRepository\");\n    // Audit service (listens to ENTITY_SAVED/DELETED events automatically)\n    builder.registerType(AuditService).as(\"AuditService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    // Workers\n    builder.registerType(DataSeeder).as(\"DataSeeder\").autoWire({\n        mapResolvers: [\n            c => c.resolveTypeAll(\"IEntityService\"),\n            c => c.resolveTypeAll(\"IApiRepository\")\n        ]\n    });\n    // Schedule services\n    builder.registerType(ScheduleOverrideService).as(\"ScheduleOverrideService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\")\n        ]\n    });\n    builder.registerType(ResourceScheduleService).as(\"ResourceScheduleService\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"ResourceService\"),\n            c => c.resolveType(\"ScheduleOverrideService\"),\n            c => c.resolveType(\"DateService\")\n        ]\n    });\n    // Features\n    builder.registerType(EventRenderer).as(\"EventRenderer\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"EventService\"),\n            c => c.resolveType(\"DateService\"),\n            c => c.resolveType(\"IGridConfig\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(ScheduleRenderer).as(\"ScheduleRenderer\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"ResourceScheduleService\"),\n            c => c.resolveType(\"DateService\"),\n            c => c.resolveType(\"IGridConfig\")\n        ]\n    });\n    builder.registerType(HeaderDrawerRenderer).as(\"HeaderDrawerRenderer\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IEventBus\"),\n            c => c.resolveType(\"IGridConfig\"),\n            c => c.resolveType(\"HeaderDrawerManager\"),\n            c => c.resolveType(\"EventService\"),\n            c => c.resolveType(\"DateService\")\n        ]\n    });\n    // Renderers - registreres som Renderer (array injection til CalendarOrchestrator)\n    builder.registerType(DateRenderer).as(\"IRenderer\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"DateService\")\n        ]\n    });\n    builder.registerType(ResourceRenderer).as(\"IRenderer\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"ResourceService\")\n        ]\n    });\n    builder.registerType(TeamRenderer).as(\"IRenderer\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"TeamService\")\n        ]\n    });\n    builder.registerType(DepartmentRenderer).as(\"IRenderer\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"DepartmentService\")\n        ]\n    });\n    // Stores - registreres som IGroupingStore\n    builder.registerType(MockTeamStore).as(\"IGroupingStore\");\n    builder.registerType(MockResourceStore).as(\"IGroupingStore\");\n    // CalendarOrchestrator modtager IGroupingStore[] automatisk (array injection)\n    builder.registerType(CalendarOrchestrator).as(\"CalendarOrchestrator\").autoWire({\n        mapResolvers: [\n            c => c.resolveTypeAll(\"IRenderer\"),\n            c => c.resolveType(\"EventRenderer\"),\n            c => c.resolveType(\"ScheduleRenderer\"),\n            c => c.resolveType(\"HeaderDrawerRenderer\"),\n            c => c.resolveType(\"DateService\"),\n            c => c.resolveTypeAll(\"IEntityService\")\n        ]\n    });\n    builder.registerType(TimeAxisRenderer).as(\"TimeAxisRenderer\");\n    builder.registerType(ScrollManager).as(\"ScrollManager\");\n    builder.registerType(HeaderDrawerManager).as(\"HeaderDrawerManager\");\n    builder.registerType(DragDropManager).as(\"DragDropManager\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IEventBus\"),\n            c => c.resolveType(\"IGridConfig\")\n        ]\n    });\n    builder.registerType(EdgeScrollManager).as(\"EdgeScrollManager\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    builder.registerType(ResizeManager).as(\"ResizeManager\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IEventBus\"),\n            c => c.resolveType(\"IGridConfig\"),\n            c => c.resolveType(\"DateService\")\n        ]\n    });\n    builder.registerType(EventPersistenceManager).as(\"EventPersistenceManager\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"EventService\"),\n            c => c.resolveType(\"IEventBus\"),\n            c => c.resolveType(\"DateService\")\n        ]\n    });\n    // CalendarApp - genbrugelig kalenderkomponent\n    builder.registerType(CalendarApp).as(\"CalendarApp\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"CalendarOrchestrator\"),\n            c => c.resolveType(\"TimeAxisRenderer\"),\n            c => c.resolveType(\"DateService\"),\n            c => c.resolveType(\"ScrollManager\"),\n            c => c.resolveType(\"HeaderDrawerManager\"),\n            c => c.resolveType(\"DragDropManager\"),\n            c => c.resolveType(\"EdgeScrollManager\"),\n            c => c.resolveType(\"ResizeManager\"),\n            c => c.resolveType(\"HeaderDrawerRenderer\"),\n            c => c.resolveType(\"EventPersistenceManager\"),\n            c => c.resolveType(\"SettingsService\"),\n            c => c.resolveType(\"ViewConfigService\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    // Demo app\n    builder.registerType(DemoApp).as(\"DemoApp\").autoWire({\n        mapResolvers: [\n            c => c.resolveType(\"IndexedDBContext\"),\n            c => c.resolveType(\"DataSeeder\"),\n            c => c.resolveType(\"AuditService\"),\n            c => c.resolveType(\"CalendarApp\"),\n            c => c.resolveType(\"DateService\"),\n            c => c.resolveType(\"ResourceService\"),\n            c => c.resolveType(\"IEventBus\")\n        ]\n    });\n    return builder.build();\n}\n", "import { createContainer } from '../CompositionRoot';\nconst container = createContainer();\ncontainer.resolveType(\"DemoApp\").init().catch(console.error);\n"],
  "mappings": "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",
  "names": ["t", "e", "n", "r", "i", "s", "u", "a", "M", "m", "f", "l", "$", "y", "v", "g", "D", "o", "d", "c", "h", "t", "i", "e", "s", "f", "n", "u", "r", "o", "t", "n", "i", "o", "r", "e", "u", "f", "s", "a", "t", "i", "d", "n", "e", "s", "token", "container", "container", "token", "container", "dayjs", "utc", "timezone", "isoWeek", "container", "container", "container", "container", "container", "container", "getKey", "skipPath", "key", "container", "container", "container", "diff", "container", "container", "diff", "container"]
}
