playlight-sdk 0.0.1

package/dist/playlight-sdk.es.js

@@ -0,0 +1,3737 @@
+const e = false;
+var t = Array.isArray, n = Array.prototype.indexOf, i = Array.from, o = Object.defineProperty, s = Object.getOwnPropertyDescriptor, a = Object.getOwnPropertyDescriptors, l = Object.prototype, c = Array.prototype, u = Object.getPrototypeOf;
+function is_function(e2) {
+  return "function" == typeof e2;
+}
+const noop = () => {
+};
+function run(e2) {
+  return e2();
+}
+function run_all(e2) {
+  for (var t2 = 0; t2 < e2.length; t2++) e2[t2]();
+}
+const d = 32, f = 128, p = 256, _ = 512, v = 1024, g = 2048, h = 4096, m = 8192, b = 16384, y = 65536, $ = 1 << 20, w = Symbol("$state"), x = Symbol("legacy props"), k = Symbol("");
+function equals(e2) {
+  return e2 === this.v;
+}
+function safe_not_equal(e2, t2) {
+  return e2 != e2 ? t2 == t2 : e2 !== t2 || null !== e2 && "object" == typeof e2 || "function" == typeof e2;
+}
+function safe_equals(e2) {
+  return !safe_not_equal(e2, this.v);
+}
+let C = false;
+const M = Symbol(), S = "http://www.w3.org/2000/svg";
+function lifecycle_outside_component(e2) {
+  throw new Error("https://svelte.dev/e/lifecycle_outside_component");
+}
+let T = null;
+function set_component_context(e2) {
+  T = e2;
+}
+function push(e2, t2 = false, n2) {
+  T = {
+    p: T,
+    c: null,
+    e: null,
+    m: false,
+    s: e2,
+    x: null,
+    l: null
+  }, C && !t2 && (T.l = {
+    s: null,
+    u: null,
+    r1: [],
+    r2: source(false)
+  });
+}
+function pop(e2) {
+  const t2 = T;
+  if (null !== t2) {
+    const e3 = t2.e;
+    if (null !== e3) {
+      var n2 = H, i2 = F;
+      t2.e = null;
+      try {
+        for (var o2 = 0; o2 < e3.length; o2++) {
+          var s2 = e3[o2];
+          set_active_effect(s2.effect), set_active_reaction(s2.reaction), effect(s2.fn);
+        }
+      } finally {
+        set_active_effect(n2), set_active_reaction(i2);
+      }
+    }
+    T = t2.p, t2.m = true;
+  }
+  return {};
+}
+function is_runes() {
+  return !C || null !== T && null === T.l;
+}
+function source(e2, t2) {
+  return {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: e2,
+    reactions: null,
+    equals,
+    rv: 0,
+    wv: 0
+  };
+}
+function state(e2) {
+  return /* @__PURE__ */ push_derived_source(source(e2));
+}
+// @__NO_SIDE_EFFECTS__
+function mutable_source(e2, t2 = false) {
+  var _a;
+  const n2 = source(e2);
+  return t2 || (n2.equals = safe_equals), // bind the signal to the component context, in case we need to
+  // track updates to trigger beforeUpdate/afterUpdate callbacks
+  C && null !== T && null !== T.l && ((_a = T.l).s ?? (_a.s = [])).push(n2), n2;
+}
+function mutable_state(e2, t2 = false) {
+  return /* @__PURE__ */ push_derived_source(/* @__PURE__ */ mutable_source(e2, t2));
+}
+// @__NO_SIDE_EFFECTS__
+function push_derived_source(e2) {
+  return null !== F && !G && 2 & F.f && (null === R ? (
+    /**
+    * @param {Source[] | null} sources
+    */
+    function set_derived_sources(e3) {
+      R = e3;
+    }([e2])
+  ) : R.push(e2)), e2;
+}
+function set(e2, t2) {
+  return null !== F && !G && is_runes() && 18 & F.f && // If the source was created locally within the current derived, then
+  // we allow the mutation.
+  (null === R || !R.includes(e2)) && /**
+  * Updating state inside a derived or a template expression is forbidden. If the value should not be reactive, declare it without `$state`
+  * @returns {never}
+  */
+  function state_unsafe_mutation() {
+    throw new Error("https://svelte.dev/e/state_unsafe_mutation");
+  }(), internal_set(e2, t2);
+}
+function internal_set(e2, t2) {
+  return e2.equals(t2) || (e2.v, e2.v = t2, e2.wv = increment_write_version(), mark_reactions(e2, g), // It's possible that the current reaction might not have up-to-date dependencies
+  // whilst it's actively running. So in the case of ensuring it registers the reaction
+  // properly for itself, we need to ensure the current effect actually gets
+  // scheduled. i.e: `$effect(() => x++)`
+  is_runes() && null !== H && H.f & v && !(96 & H.f) && (null === U ? (
+    /** @param {null | Source[]} value */
+    function set_untracked_writes(e3) {
+      U = e3;
+    }([e2])
+  ) : U.push(e2))), t2;
+}
+function update(e2, t2 = 1) {
+  var n2 = get$1(e2), i2 = 1 === t2 ? n2++ : n2--;
+  return set(e2, n2), i2;
+}
+function mark_reactions(e2, t2) {
+  var n2 = e2.reactions;
+  if (null !== n2) for (var i2 = is_runes(), o2 = n2.length, s2 = 0; s2 < o2; s2++) {
+    var a2 = n2[s2], l2 = a2.f;
+    l2 & g || // In legacy mode, skip the current effect to prevent infinite loops
+    (i2 || a2 !== H) && (set_signal_status(a2, t2), // If the signal a) was previously clean or b) is an unowned derived, then mark it
+    1280 & l2 && (2 & l2 ? mark_reactions(
+      /** @type {Derived} */
+      a2,
+      h
+    ) : schedule_effect(
+      /** @type {Effect} */
+      a2
+    )));
+  }
+}
+function proxy(e2, n2 = null, i2) {
+  if ("object" != typeof e2 || null === e2 || w in e2) return e2;
+  const o2 = u(e2);
+  if (o2 !== l && o2 !== c) return e2;
+  var a2, d2 = /* @__PURE__ */ new Map(), f2 = t(e2), p2 = source(0);
+  return f2 && // We need to create the length source eagerly to ensure that
+  // mutations to the array are properly synced with our proxy
+  d2.set("length", source(
+    /** @type {any[]} */
+    e2.length
+  )), new Proxy(
+    /** @type {any} */
+    e2,
+    {
+      defineProperty(e3, t2, n3) {
+        "value" in n3 && false !== n3.configurable && false !== n3.enumerable && false !== n3.writable || // we disallow non-basic descriptors, because unless they are applied to the
+        // target object — which we avoid, so that state can be forked — we will run
+        // afoul of the various invariants
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/getOwnPropertyDescriptor#invariants
+        /**
+        * Property descriptors defined on `$state` objects must contain `value` and always be `enumerable`, `configurable` and `writable`.
+        * @returns {never}
+        */
+        function state_descriptors_fixed() {
+          throw new Error("https://svelte.dev/e/state_descriptors_fixed");
+        }();
+        var i3 = d2.get(t2);
+        return void 0 === i3 ? (i3 = source(n3.value), d2.set(t2, i3)) : set(i3, proxy(n3.value, a2)), true;
+      },
+      deleteProperty(e3, t2) {
+        var n3 = d2.get(t2);
+        if (void 0 === n3) t2 in e3 && d2.set(t2, source(M));
+        else {
+          if (f2 && "string" == typeof t2) {
+            var i3 = (
+              /** @type {Source<number>} */
+              d2.get("length")
+            ), o3 = Number(t2);
+            Number.isInteger(o3) && o3 < i3.v && set(i3, o3);
+          }
+          set(n3, M), update_version(p2);
+        }
+        return true;
+      },
+      get(t2, n3, i3) {
+        var _a;
+        if (n3 === w) return e2;
+        var o3 = d2.get(n3), l2 = n3 in t2;
+        if (
+          // create a source, but only if it's an own property and not a prototype property
+          void 0 !== o3 || l2 && !((_a = s(t2, n3)) == null ? void 0 : _a.writable) || (o3 = source(proxy(l2 ? t2[n3] : M, a2)), d2.set(n3, o3)), void 0 !== o3
+        ) {
+          var c2 = get$1(o3);
+          return c2 === M ? void 0 : c2;
+        }
+        return Reflect.get(t2, n3, i3);
+      },
+      getOwnPropertyDescriptor(e3, t2) {
+        var n3 = Reflect.getOwnPropertyDescriptor(e3, t2);
+        if (n3 && "value" in n3) {
+          var i3 = d2.get(t2);
+          i3 && (n3.value = get$1(i3));
+        } else if (void 0 === n3) {
+          var o3 = d2.get(t2), s2 = o3 == null ? void 0 : o3.v;
+          if (void 0 !== o3 && s2 !== M) return {
+            enumerable: true,
+            configurable: true,
+            value: s2,
+            writable: true
+          };
+        }
+        return n3;
+      },
+      has(e3, t2) {
+        var _a;
+        if (t2 === w) return true;
+        var n3 = d2.get(t2), i3 = void 0 !== n3 && n3.v !== M || Reflect.has(e3, t2);
+        if ((void 0 !== n3 || null !== H && (!i3 || ((_a = s(e3, t2)) == null ? void 0 : _a.writable))) && (void 0 === n3 && (n3 = source(i3 ? proxy(e3[t2], a2) : M), d2.set(t2, n3)), get$1(n3) === M)) return false;
+        return i3;
+      },
+      set(e3, t2, n3, i3) {
+        var _a;
+        var o3 = d2.get(t2), l2 = t2 in e3;
+        if (f2 && "length" === t2) for (var c2 = n3; c2 < /** @type {Source<number>} */
+        o3.v; c2 += 1) {
+          var u2 = d2.get(c2 + "");
+          void 0 !== u2 ? set(u2, M) : c2 in e3 && // If the item exists in the original, we need to create a uninitialized source,
+          // else a later read of the property would result in a source being created with
+          // the value of the original item at that index.
+          (u2 = source(M), d2.set(c2 + "", u2));
+        }
+        void 0 === o3 ? l2 && !((_a = s(e3, t2)) == null ? void 0 : _a.writable) || (set(o3 = source(void 0), proxy(n3, a2)), d2.set(t2, o3)) : (l2 = o3.v !== M, set(o3, proxy(n3, a2)));
+        var _2 = Reflect.getOwnPropertyDescriptor(e3, t2);
+        if ((_2 == null ? void 0 : _2.set) && _2.set.call(i3, n3), !l2) {
+          if (f2 && "string" == typeof t2) {
+            var v2 = (
+              /** @type {Source<number>} */
+              d2.get("length")
+            ), g2 = Number(t2);
+            Number.isInteger(g2) && g2 >= v2.v && set(v2, g2 + 1);
+          }
+          update_version(p2);
+        }
+        return true;
+      },
+      ownKeys(e3) {
+        get$1(p2);
+        var t2 = Reflect.ownKeys(e3).filter((e4) => {
+          var t3 = d2.get(e4);
+          return void 0 === t3 || t3.v !== M;
+        });
+        for (var [n3, i3] of d2) i3.v === M || n3 in e3 || t2.push(n3);
+        return t2;
+      },
+      setPrototypeOf() {
+        !function state_prototype_fixed() {
+          throw new Error("https://svelte.dev/e/state_prototype_fixed");
+        }();
+      }
+    }
+  );
+}
+function update_version(e2, t2 = 1) {
+  set(e2, e2.v + t2);
+}
+var q, I, P, O, E;
+function create_text(e2 = "") {
+  return document.createTextNode(e2);
+}
+// @__NO_SIDE_EFFECTS__
+function get_first_child(e2) {
+  return O.call(e2);
+}
+// @__NO_SIDE_EFFECTS__
+function get_next_sibling(e2) {
+  return E.call(e2);
+}
+function child(e2, t2) {
+  return /* @__PURE__ */ get_first_child(e2);
+}
+function first_child(e2, t2) {
+  var n2 = (
+    /** @type {DocumentFragment} */
+    /* @__PURE__ */ get_first_child(
+      /** @type {Node} */
+      e2
+    )
+  );
+  return n2 instanceof Comment && "" === n2.data ? /* @__PURE__ */ get_next_sibling(n2) : n2;
+}
+function sibling(e2, t2 = 1, n2 = false) {
+  let i2 = e2;
+  for (; t2--; ) i2 = /** @type {TemplateNode} */
+  /* @__PURE__ */ get_next_sibling(i2);
+  return i2;
+}
+// @__NO_SIDE_EFFECTS__
+function derived(e2) {
+  var t2 = 2050, n2 = null !== F && 2 & F.f ? (
+    /** @type {Derived} */
+    F
+  ) : null;
+  null === H || null !== n2 && n2.f & p ? t2 |= p : (
+    // Since deriveds are evaluated lazily, any effects created inside them are
+    // created too late to ensure that the parent effect is added to the tree
+    H.f |= $
+  );
+  return {
+    ctx: T,
+    deps: null,
+    effects: null,
+    equals,
+    f: t2,
+    fn: e2,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      null
+    ),
+    wv: 0,
+    parent: n2 ?? H
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function derived_safe_equal(e2) {
+  const t2 = /* @__PURE__ */ derived(e2);
+  return t2.equals = safe_equals, t2;
+}
+function destroy_derived_effects(e2) {
+  var t2 = e2.effects;
+  if (null !== t2) {
+    e2.effects = null;
+    for (var n2 = 0; n2 < t2.length; n2 += 1) destroy_effect(
+      /** @type {Effect} */
+      t2[n2]
+    );
+  }
+}
+function update_derived(e2) {
+  var t2 = (
+    /**
+    * @template T
+    * @param {Derived} derived
+    * @returns {T}
+    */
+    function execute_derived(e3) {
+      var t3, n2 = H;
+      set_active_effect(function get_derived_parent_effect(e4) {
+        for (var t4 = e4.parent; null !== t4; ) {
+          if (!(2 & t4.f))
+            return t4;
+          t4 = t4.parent;
+        }
+        return null;
+      }(e3));
+      try {
+        destroy_derived_effects(e3), t3 = update_reaction(e3);
+      } finally {
+        set_active_effect(n2);
+      }
+      return t3;
+    }(e2)
+  );
+  set_signal_status(e2, (J || e2.f & p) && null !== e2.deps ? h : v), e2.equals(t2) || (e2.v = t2, e2.wv = increment_write_version());
+}
+function validate_effect(e2) {
+  null === H && null === F && /**
+  * `%rune%` can only be used inside an effect (e.g. during component initialisation)
+  * @param {string} rune
+  * @returns {never}
+  */
+  function effect_orphan(e3) {
+    throw new Error("https://svelte.dev/e/effect_orphan");
+  }(), null !== F && F.f & p && null === H && /**
+  * Effect cannot be created inside a `$derived` value that was not itself created inside an effect
+  * @returns {never}
+  */
+  function effect_in_unowned_derived() {
+    throw new Error("https://svelte.dev/e/effect_in_unowned_derived");
+  }(), L && function effect_in_teardown(e3) {
+    throw new Error("https://svelte.dev/e/effect_in_teardown");
+  }();
+}
+function create_effect(e2, t2, n2, i2 = true) {
+  var o2 = !!(64 & e2), s2 = H, a2 = {
+    ctx: T,
+    deps: null,
+    nodes_start: null,
+    nodes_end: null,
+    f: e2 | g,
+    first: null,
+    fn: t2,
+    last: null,
+    next: null,
+    parent: o2 ? null : s2,
+    prev: null,
+    teardown: null,
+    transitions: null,
+    wv: 0
+  };
+  if (n2) try {
+    update_effect(a2), a2.f |= 32768;
+  } catch (e3) {
+    throw destroy_effect(a2), e3;
+  }
+  else null !== t2 && schedule_effect(a2);
+  if (!(n2 && null === a2.deps && null === a2.first && null === a2.nodes_start && null === a2.teardown && !(1048704 & a2.f)) && !o2 && i2 && (null !== s2 && function push_effect(e3, t3) {
+    var n3 = t3.last;
+    null === n3 ? t3.last = t3.first = e3 : (n3.next = e3, e3.prev = n3, t3.last = e3);
+  }(a2, s2), null !== F && 2 & F.f)) {
+    var l2 = (
+      /** @type {Derived} */
+      F
+    );
+    (l2.effects ?? (l2.effects = [])).push(a2);
+  }
+  return a2;
+}
+function teardown(e2) {
+  const t2 = create_effect(8, null, false);
+  return set_signal_status(t2, v), t2.teardown = e2, t2;
+}
+function user_effect(e2) {
+  if (validate_effect(), !(null !== H && !!(H.f & d) && null !== T && !T.m)) return effect(e2);
+  var t2 = (
+    /** @type {ComponentContext} */
+    T
+  );
+  (t2.e ?? (t2.e = [])).push({
+    fn: e2,
+    effect: H,
+    reaction: F
+  });
+}
+function effect(e2) {
+  return create_effect(4, e2, false);
+}
+function legacy_pre_effect(e2, t2) {
+  var n2 = (
+    /** @type {ComponentContextLegacy} */
+    T
+  ), i2 = {
+    effect: null,
+    ran: false
+  };
+  n2.l.r1.push(i2), i2.effect = render_effect(() => {
+    e2(), // If this legacy pre effect has already run before the end of the reset, then
+    // bail out to emulate the same behavior.
+    i2.ran || (i2.ran = true, set(n2.l.r2, true), untrack(t2));
+  });
+}
+function legacy_pre_effect_reset() {
+  var e2 = (
+    /** @type {ComponentContextLegacy} */
+    T
+  );
+  render_effect(() => {
+    if (get$1(e2.l.r2)) {
+      for (var t2 of e2.l.r1) {
+        var n2 = t2.effect;
+        n2.f & v && set_signal_status(n2, h), check_dirtiness(n2) && update_effect(n2), t2.ran = false;
+      }
+      e2.l.r2.v = false;
+    }
+  });
+}
+function render_effect(e2) {
+  return create_effect(8, e2, true);
+}
+function template_effect(e2, t2 = [], n2 = derived) {
+  const i2 = t2.map(n2);
+  return block(() => e2(...i2.map(get$1)));
+}
+function block(e2, t2 = 0) {
+  return create_effect(24 | t2, e2, true);
+}
+function branch(e2, t2 = true) {
+  return create_effect(40, e2, true, t2);
+}
+function execute_effect_teardown(e2) {
+  var t2 = e2.teardown;
+  if (null !== t2) {
+    const e3 = L, n2 = F;
+    set_is_destroying_effect(true), set_active_reaction(null);
+    try {
+      t2.call(null);
+    } finally {
+      set_is_destroying_effect(e3), set_active_reaction(n2);
+    }
+  }
+}
+function destroy_effect_children(e2, t2 = false) {
+  var n2 = e2.first;
+  for (e2.first = e2.last = null; null !== n2; ) {
+    var i2 = n2.next;
+    destroy_effect(n2, t2), n2 = i2;
+  }
+}
+function destroy_effect(e2, t2 = true) {
+  var n2 = false;
+  if ((t2 || 524288 & e2.f) && null !== e2.nodes_start) {
+    for (var i2 = e2.nodes_start, o2 = e2.nodes_end; null !== i2; ) {
+      var s2 = i2 === o2 ? null : (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ get_next_sibling(i2)
+      );
+      i2.remove(), i2 = s2;
+    }
+    n2 = true;
+  }
+  destroy_effect_children(e2, t2 && !n2), remove_reactions(e2, 0), set_signal_status(e2, b);
+  var a2 = e2.transitions;
+  if (null !== a2) for (const e3 of a2) e3.stop();
+  execute_effect_teardown(e2);
+  var l2 = e2.parent;
+  null !== l2 && null !== l2.first && unlink_effect(e2), // `first` and `child` are nulled out in destroy_effect_children
+  // we don't null out `parent` so that error propagation can work correctly
+  e2.next = e2.prev = e2.teardown = e2.ctx = e2.deps = e2.fn = e2.nodes_start = e2.nodes_end = null;
+}
+function unlink_effect(e2) {
+  var t2 = e2.parent, n2 = e2.prev, i2 = e2.next;
+  null !== n2 && (n2.next = i2), null !== i2 && (i2.prev = n2), null !== t2 && (t2.first === e2 && (t2.first = i2), t2.last === e2 && (t2.last = n2));
+}
+function pause_effect(e2, t2) {
+  var n2 = [];
+  pause_children(e2, n2, true), run_out_transitions(n2, () => {
+    destroy_effect(e2), t2 && t2();
+  });
+}
+function run_out_transitions(e2, t2) {
+  var n2 = e2.length;
+  if (n2 > 0) {
+    var check = () => --n2 || t2();
+    for (var i2 of e2) i2.out(check);
+  } else t2();
+}
+function pause_children(e2, t2, n2) {
+  if (!(e2.f & m)) {
+    if (e2.f ^= m, null !== e2.transitions) for (const i3 of e2.transitions) (i3.is_global || n2) && t2.push(i3);
+    for (var i2 = e2.first; null !== i2; ) {
+      var o2 = i2.next;
+      pause_children(i2, t2, !!(!!(i2.f & y) || !!(i2.f & d)) && n2), i2 = o2;
+    }
+  }
+}
+function resume_effect(e2) {
+  resume_children(e2, true);
+}
+function resume_children(e2, t2) {
+  if (e2.f & m) {
+    e2.f ^= m, // Ensure the effect is marked as clean again so that any dirty child
+    // effects can schedule themselves for execution
+    e2.f & v || (e2.f ^= v), // If a dependency of this effect changed while it was paused,
+    // schedule the effect to update
+    check_dirtiness(e2) && (set_signal_status(e2, g), schedule_effect(e2));
+    for (var n2 = e2.first; null !== n2; ) {
+      var i2 = n2.next;
+      resume_children(n2, !!(!!(n2.f & y) || !!(n2.f & d)) && t2), n2 = i2;
+    }
+    if (null !== e2.transitions) for (const n3 of e2.transitions) (n3.is_global || t2) && n3.in();
+  }
+}
+let j = [], N = [];
+function run_micro_tasks() {
+  var e2 = j;
+  j = [], run_all(e2);
+}
+function queue_micro_task(e2) {
+  0 === j.length && queueMicrotask(run_micro_tasks), j.push(e2);
+}
+function flush_tasks() {
+  j.length > 0 && run_micro_tasks(), N.length > 0 && function run_idle_tasks() {
+    var e2 = N;
+    N = [], run_all(e2);
+  }();
+}
+let B = false, z = false, D = null, A = false, L = false;
+function set_is_destroying_effect(e2) {
+  L = e2;
+}
+let W = [], F = null, G = false;
+function set_active_reaction(e2) {
+  F = e2;
+}
+let H = null;
+function set_active_effect(e2) {
+  H = e2;
+}
+let R = null;
+let V = null, K = 0, U = null;
+let Z = 1, Y = 0, J = false;
+function increment_write_version() {
+  return ++Z;
+}
+function check_dirtiness(e2) {
+  var _a;
+  var t2 = e2.f;
+  if (t2 & g) return true;
+  if (t2 & h) {
+    var n2 = e2.deps, i2 = !!(t2 & p);
+    if (null !== n2) {
+      var o2, s2, a2 = !!(t2 & _), l2 = i2 && null !== H && !J, c2 = n2.length;
+      if (a2 || l2) {
+        var u2 = (
+          /** @type {Derived} */
+          e2
+        ), d2 = u2.parent;
+        for (o2 = 0; o2 < c2; o2++) s2 = n2[o2], // We always re-add all reactions (even duplicates) if the derived was
+        // previously disconnected, however we don't if it was unowned as we
+        // de-duplicate dependencies in that case
+        !a2 && ((_a = s2 == null ? void 0 : s2.reactions) == null ? void 0 : _a.includes(u2)) || (s2.reactions ?? (s2.reactions = [])).push(u2);
+        a2 && (u2.f ^= _), // If the unowned derived is now fully connected to the graph again (it's unowned and reconnected, has a parent
+        // and the parent is not unowned), then we can mark it as connected again, removing the need for the unowned
+        // flag
+        !l2 || null === d2 || d2.f & p || (u2.f ^= p);
+      }
+      for (o2 = 0; o2 < c2; o2++) if (check_dirtiness(s2 = n2[o2]) && update_derived(
+        /** @type {Derived} */
+        s2
+      ), s2.wv > e2.wv) return true;
+    }
+    i2 && (null === H || J) || set_signal_status(e2, v);
+  }
+  return false;
+}
+function handle_error(e2, t2, n2, i2) {
+  if (B) {
+    if (null === n2 && (B = false), /**
+    * @param {Effect} effect
+    */
+    function should_rethrow_error(e3) {
+      return !(e3.f & b || null !== e3.parent && e3.parent.f & f);
+    }(t2)) throw e2;
+  } else null !== n2 && (B = true), function propagate_error(e3, t3) {
+    for (var n3 = t3; null !== n3; ) {
+      if (n3.f & f) try {
+        return void n3.fn(e3);
+      } catch {
+        n3.f ^= f;
+      }
+      n3 = n3.parent;
+    }
+    throw B = false, e3;
+  }(e2, t2);
+}
+function schedule_possible_effect_self_invalidation(e2, t2, n2 = true) {
+  var i2 = e2.reactions;
+  if (null !== i2) for (var o2 = 0; o2 < i2.length; o2++) {
+    var s2 = i2[o2];
+    2 & s2.f ? schedule_possible_effect_self_invalidation(
+      /** @type {Derived} */
+      s2,
+      t2,
+      false
+    ) : t2 === s2 && (n2 ? set_signal_status(s2, g) : s2.f & v && set_signal_status(s2, h), schedule_effect(
+      /** @type {Effect} */
+      s2
+    ));
+  }
+}
+function update_reaction(e2) {
+  var _a;
+  var t2 = V, n2 = K, i2 = U, o2 = F, s2 = J, a2 = R, l2 = T, c2 = G, u2 = e2.f;
+  V = /** @type {null | Value[]} */
+  null, K = 0, U = null, J = !!(u2 & p) && (G || !A || null === F), F = 96 & u2 ? null : e2, R = null, set_component_context(e2.ctx), G = false, Y++;
+  try {
+    var d2 = (
+      /** @type {Function} */
+      /** @type {Function} */
+      (0, e2.fn)()
+    ), f2 = e2.deps;
+    if (null !== V) {
+      var _2;
+      if (remove_reactions(e2, K), null !== f2 && K > 0) for (f2.length = K + V.length, _2 = 0; _2 < V.length; _2++) f2[K + _2] = V[_2];
+      else e2.deps = f2 = V;
+      if (!J) for (_2 = K; _2 < f2.length; _2++) ((_a = f2[_2]).reactions ?? (_a.reactions = [])).push(e2);
+    } else null !== f2 && K < f2.length && (remove_reactions(e2, K), f2.length = K);
+    if (is_runes() && null !== U && !G && null !== f2 && !(6146 & e2.f)) for (_2 = 0; _2 < /** @type {Source[]} */
+    U.length; _2++) schedule_possible_effect_self_invalidation(
+      U[_2],
+      /** @type {Effect} */
+      e2
+    );
+    return null !== o2 && Y++, d2;
+  } finally {
+    V = t2, K = n2, U = i2, F = o2, J = s2, R = a2, set_component_context(l2), G = c2;
+  }
+}
+function remove_reaction(e2, t2) {
+  let i2 = t2.reactions;
+  if (null !== i2) {
+    var o2 = n.call(i2, e2);
+    if (-1 !== o2) {
+      var s2 = i2.length - 1;
+      0 === s2 ? i2 = t2.reactions = null : (
+        // Swap with last element and then remove.
+        (i2[o2] = i2[s2], i2.pop())
+      );
+    }
+  }
+  null === i2 && 2 & t2.f && // Destroying a child effect while updating a parent effect can cause a dependency to appear
+  // to be unused, when in fact it is used by the currently-updating parent. Checking `new_deps`
+  // allows us to skip the expensive work of disconnecting and immediately reconnecting it
+  (null === V || !V.includes(t2)) && (set_signal_status(t2, h), // If we are working with a derived that is owned by an effect, then mark it as being
+  // disconnected.
+  768 & t2.f || (t2.f ^= _), // Disconnect any reactions owned by this reaction
+  destroy_derived_effects(
+    /** @type {Derived} **/
+    t2
+  ), remove_reactions(
+    /** @type {Derived} **/
+    t2,
+    0
+  ));
+}
+function remove_reactions(e2, t2) {
+  var n2 = e2.deps;
+  if (null !== n2) for (var i2 = t2; i2 < n2.length; i2++) remove_reaction(e2, n2[i2]);
+}
+function update_effect(t2) {
+  var n2 = t2.f;
+  if (!(n2 & b)) {
+    set_signal_status(t2, v);
+    var i2 = H, o2 = T, s2 = A;
+    H = t2, A = true;
+    try {
+      16 & n2 ? function destroy_block_effect_children(e2) {
+        for (var t3 = e2.first; null !== t3; ) {
+          var n3 = t3.next;
+          t3.f & d || destroy_effect(t3), t3 = n3;
+        }
+      }(t2) : destroy_effect_children(t2), execute_effect_teardown(t2);
+      var a2 = update_reaction(t2);
+      t2.teardown = "function" == typeof a2 ? a2 : null, t2.wv = Z;
+      t2.deps;
+      e;
+    } catch (e2) {
+      handle_error(e2, t2, i2, o2 || t2.ctx);
+    } finally {
+      A = s2, H = i2;
+    }
+  }
+}
+function infinite_loop_guard() {
+  try {
+    !function effect_update_depth_exceeded() {
+      throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+    }();
+  } catch (e2) {
+    if (null === D) throw e2;
+    handle_error(e2, D, null);
+  }
+}
+function flush_queued_root_effects() {
+  try {
+    for (var e2 = 0; W.length > 0; ) {
+      e2++ > 1e3 && infinite_loop_guard();
+      var t2 = W, n2 = t2.length;
+      W = [];
+      for (var i2 = 0; i2 < n2; i2++) {
+        var o2 = t2[i2];
+        o2.f & v || (o2.f ^= v), flush_queued_effects(process_effects(o2));
+      }
+    }
+  } finally {
+    z = false, D = null;
+  }
+}
+function flush_queued_effects(e2) {
+  var t2 = e2.length;
+  if (0 !== t2) for (var n2 = 0; n2 < t2; n2++) {
+    var i2 = e2[n2];
+    if (!(24576 & i2.f)) try {
+      check_dirtiness(i2) && (update_effect(i2), // Effects with no dependencies or teardown do not get added to the effect tree.
+      // Deferred effects (e.g. `$effect(...)`) _are_ added to the tree because we
+      // don't know if we need to keep them until they are executed. Doing the check
+      // here (rather than in `update_effect`) allows us to skip the work for
+      // immediate effects.
+      null === i2.deps && null === i2.first && null === i2.nodes_start && (null === i2.teardown ? (
+        // remove this effect from the graph
+        unlink_effect(i2)
+      ) : (
+        // keep the effect in the graph, but free up some memory
+        i2.fn = null
+      )));
+    } catch (e3) {
+      handle_error(e3, i2, null, i2.ctx);
+    }
+  }
+}
+function schedule_effect(e2) {
+  z || (z = true, queueMicrotask(flush_queued_root_effects));
+  for (var t2 = D = e2; null !== t2.parent; ) {
+    var n2 = (t2 = t2.parent).f;
+    if (96 & n2) {
+      if (!(n2 & v)) return;
+      t2.f ^= v;
+    }
+  }
+  W.push(t2);
+}
+function process_effects(e2) {
+  for (var t2 = [], n2 = e2.first; null !== n2; ) {
+    var i2 = n2.f, o2 = !!(i2 & d);
+    if (!(o2 && !!(i2 & v) || i2 & m)) {
+      if (4 & i2) t2.push(n2);
+      else if (o2) n2.f ^= v;
+      else {
+        var s2 = F;
+        try {
+          F = n2, check_dirtiness(n2) && update_effect(n2);
+        } catch (e3) {
+          handle_error(e3, n2, null, n2.ctx);
+        } finally {
+          F = s2;
+        }
+      }
+      var a2 = n2.first;
+      if (null !== a2) {
+        n2 = a2;
+        continue;
+      }
+    }
+    var l2 = n2.parent;
+    for (n2 = n2.next; null === n2 && null !== l2; ) n2 = l2.next, l2 = l2.parent;
+  }
+  return t2;
+}
+async function tick() {
+  await Promise.resolve(), // By calling flushSync we guarantee that any pending state changes are applied after one tick.
+  // TODO look into whether we can make flushing subsequent updates synchronously in the future.
+  function flushSync(e2) {
+    for (flush_tasks(); W.length > 0; ) z = true, flush_queued_root_effects(), flush_tasks();
+  }();
+}
+function get$1(e2) {
+  var t2 = !!(2 & e2.f);
+  if (null === F || G) {
+    if (t2 && /** @type {Derived} */
+    null === e2.deps && /** @type {Derived} */
+    null === e2.effects) {
+      var n2 = (
+        /** @type {Derived} */
+        e2
+      ), i2 = n2.parent;
+      null === i2 || i2.f & p || // If the derived is owned by another derived then mark it as unowned
+      // as the derived value might have been referenced in a different context
+      // since and thus its parent might not be its true owner anymore
+      (n2.f ^= p);
+    }
+  } else {
+    null !== R && R.includes(e2) && function state_unsafe_local_read() {
+      throw new Error("https://svelte.dev/e/state_unsafe_local_read");
+    }();
+    var o2 = F.deps;
+    e2.rv < Y && (e2.rv = Y, // If the signal is accessing the same dependencies in the same
+    // order as it did last time, increment `skipped_deps`
+    // rather than updating `new_deps`, which creates GC cost
+    null === V && null !== o2 && o2[K] === e2 ? K++ : null === V ? V = [e2] : J && V.includes(e2) || // Normally we can push duplicated dependencies to `new_deps`, but if we're inside
+    // an unowned derived because skip_reaction is true, then we need to ensure that
+    // we don't have duplicates
+    V.push(e2));
+  }
+  return t2 && check_dirtiness(n2 = /** @type {Derived} */
+  e2) && update_derived(n2), e2.v;
+}
+function untrack(e2) {
+  var t2 = G;
+  try {
+    return G = true, e2();
+  } finally {
+    G = t2;
+  }
+}
+const Q = -7169;
+function set_signal_status(e2, t2) {
+  e2.f = e2.f & Q | t2;
+}
+function deep_read_state(e2) {
+  if ("object" == typeof e2 && e2 && !(e2 instanceof EventTarget)) {
+    if (w in e2) deep_read(e2);
+    else if (!Array.isArray(e2)) for (let t2 in e2) {
+      const n2 = e2[t2];
+      "object" == typeof n2 && n2 && w in n2 && deep_read(n2);
+    }
+  }
+}
+function deep_read(e2, t2 = /* @__PURE__ */ new Set()) {
+  if (!("object" != typeof e2 || null === e2 || e2 instanceof EventTarget || t2.has(e2))) {
+    t2.add(e2), // When working with a possible SvelteDate, this
+    // will ensure we capture changes to it.
+    e2 instanceof Date && e2.getTime();
+    for (let n3 in e2) try {
+      deep_read(e2[n3], t2);
+    } catch (e3) {
+    }
+    const n2 = u(e2);
+    if (n2 !== Object.prototype && n2 !== Array.prototype && n2 !== Map.prototype && n2 !== Set.prototype && n2 !== Date.prototype) {
+      const t3 = a(n2);
+      for (let n3 in t3) {
+        const i2 = t3[n3].get;
+        if (i2) try {
+          i2.call(e2);
+        } catch (e3) {
+        }
+      }
+    }
+  }
+}
+function is_capture_event(e2) {
+  return e2.endsWith("capture") && "gotpointercapture" !== e2 && "lostpointercapture" !== e2;
+}
+const ee = ["beforeinput", "click", "change", "dblclick", "contextmenu", "focusin", "focusout", "input", "keydown", "keyup", "mousedown", "mousemove", "mouseout", "mouseover", "mouseup", "pointerdown", "pointermove", "pointerout", "pointerover", "pointerup", "touchend", "touchmove", "touchstart"];
+function is_delegated(e2) {
+  return ee.includes(e2);
+}
+const te = {
+  // no `class: 'className'` because we handle that separately
+  formnovalidate: "formNoValidate",
+  ismap: "isMap",
+  nomodule: "noModule",
+  playsinline: "playsInline",
+  readonly: "readOnly",
+  defaultvalue: "defaultValue",
+  defaultchecked: "defaultChecked",
+  srcobject: "srcObject",
+  novalidate: "noValidate",
+  allowfullscreen: "allowFullscreen",
+  disablepictureinpicture: "disablePictureInPicture",
+  disableremoteplayback: "disableRemotePlayback"
+};
+function normalize_attribute(e2) {
+  return e2 = e2.toLowerCase(), te[e2] ?? e2;
+}
+const ne = ["touchstart", "touchmove"];
+function is_passive_event(e2) {
+  return ne.includes(e2);
+}
+function autofocus(e2, t2) {
+  if (t2) {
+    const t3 = document.body;
+    e2.autofocus = true, queue_micro_task(() => {
+      document.activeElement === t3 && e2.focus();
+    });
+  }
+}
+let re = false;
+function without_reactive_context(e2) {
+  var t2 = F, n2 = H;
+  set_active_reaction(null), set_active_effect(null);
+  try {
+    return e2();
+  } finally {
+    set_active_reaction(t2), set_active_effect(n2);
+  }
+}
+function listen_to_event_and_reset_event(e2, t2, n2, i2 = n2) {
+  e2.addEventListener(t2, () => without_reactive_context(n2));
+  const o2 = e2.__on_r;
+  e2.__on_r = o2 ? () => {
+    o2(), i2(true);
+  } : () => i2(true), function add_form_reset_listener() {
+    re || (re = true, document.addEventListener(
+      "reset",
+      (e3) => {
+        Promise.resolve().then(() => {
+          var _a;
+          if (!e3.defaultPrevented) for (
+            const t3 of
+            /**@type {HTMLFormElement} */
+            e3.target.elements
+          )
+            (_a = t3.__on_r) == null ? void 0 : _a.call(t3);
+        });
+      },
+      // In the capture phase to guarantee we get noticed of it (no possiblity of stopPropagation)
+      {
+        capture: true
+      }
+    ));
+  }();
+}
+const ie = /* @__PURE__ */ new Set(), oe = /* @__PURE__ */ new Set();
+function create_event(e2, t2, n2, i2 = {}) {
+  function target_handler(e3) {
+    if (i2.capture || // Only call in the bubble phase, else delegated events would be called before the capturing events
+    handle_event_propagation.call(t2, e3), !e3.cancelBubble) return without_reactive_context(() => n2 == null ? void 0 : n2.call(this, e3));
+  }
+  return e2.startsWith("pointer") || e2.startsWith("touch") || "wheel" === e2 ? queue_micro_task(() => {
+    t2.addEventListener(e2, target_handler, i2);
+  }) : t2.addEventListener(e2, target_handler, i2), target_handler;
+}
+function event(e2, t2, n2, i2, o2) {
+  var s2 = {
+    capture: i2,
+    passive: o2
+  }, a2 = create_event(e2, t2, n2, s2);
+  t2 !== document.body && t2 !== window && t2 !== document || teardown(() => {
+    t2.removeEventListener(e2, a2, s2);
+  });
+}
+function delegate(e2) {
+  for (var t2 = 0; t2 < e2.length; t2++) ie.add(e2[t2]);
+  for (var n2 of oe) n2(e2);
+}
+function handle_event_propagation(e2) {
+  var _a;
+  var n2 = this, i2 = (
+    /** @type {Node} */
+    n2.ownerDocument
+  ), s2 = e2.type, a2 = ((_a = e2.composedPath) == null ? void 0 : _a.call(e2)) || [], l2 = (
+    /** @type {null | Element} */
+    a2[0] || e2.target
+  ), c2 = 0, u2 = e2.__root;
+  if (u2) {
+    var d2 = a2.indexOf(u2);
+    if (-1 !== d2 && (n2 === document || n2 === /** @type {any} */
+    window))
+      return void (e2.__root = n2);
+    var f2 = a2.indexOf(n2);
+    if (-1 === f2)
+      return;
+    d2 <= f2 && (c2 = d2);
+  }
+  if ((l2 = /** @type {Element} */
+  a2[c2] || e2.target) !== n2) {
+    o(e2, "currentTarget", {
+      configurable: true,
+      get: () => l2 || i2
+    });
+    var p2 = F, _2 = H;
+    set_active_reaction(null), set_active_effect(null);
+    try {
+      for (var v2, g2 = []; null !== l2; ) {
+        var h2 = l2.assignedSlot || l2.parentNode || /** @type {any} */
+        l2.host || null;
+        try {
+          var m2 = l2["__" + s2];
+          if (void 0 !== m2 && (!/** @type {any} */
+          l2.disabled || // DOM could've been updated already by the time this is reached, so we check this as well
+          // -> the target could not have been disabled because it emits the event in the first place
+          e2.target === l2)) if (t(m2)) {
+            var [b2, ...y2] = m2;
+            b2.apply(l2, [e2, ...y2]);
+          } else m2.call(l2, e2);
+        } catch (e3) {
+          v2 ? g2.push(e3) : v2 = e3;
+        }
+        if (e2.cancelBubble || h2 === n2 || null === h2) break;
+        l2 = h2;
+      }
+      if (v2) {
+        for (let e3 of g2)
+          queueMicrotask(() => {
+            throw e3;
+          });
+        throw v2;
+      }
+    } finally {
+      e2.__root = n2, // @ts-ignore remove proxy on currentTarget
+      delete e2.currentTarget, set_active_reaction(p2), set_active_effect(_2);
+    }
+  }
+}
+function create_fragment_from_html(e2) {
+  var t2 = document.createElement("template");
+  return t2.innerHTML = e2, t2.content;
+}
+function assign_nodes(e2, t2) {
+  var n2 = (
+    /** @type {Effect} */
+    H
+  );
+  null === n2.nodes_start && (n2.nodes_start = e2, n2.nodes_end = t2);
+}
+// @__NO_SIDE_EFFECTS__
+function template(e2, t2) {
+  var n2, i2 = !!(1 & t2), o2 = !!(2 & t2), s2 = !e2.startsWith("<!>");
+  return () => {
+    void 0 === n2 && (n2 = create_fragment_from_html(s2 ? e2 : "<!>" + e2), i2 || (n2 = /** @type {Node} */
+    /* @__PURE__ */ get_first_child(n2)));
+    var t3 = (
+      /** @type {TemplateNode} */
+      o2 || P ? document.importNode(n2, true) : n2.cloneNode(true)
+    );
+    i2 ? assign_nodes(
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ get_first_child(t3),
+      /** @type {TemplateNode} */
+      t3.lastChild
+    ) : assign_nodes(t3, t3);
+    return t3;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function ns_template(e2, t2, n2 = "svg") {
+  var i2, o2 = `<${n2}>${!e2.startsWith("<!>") ? e2 : "<!>" + e2}</${n2}>`;
+  return () => {
+    if (!i2) {
+      var e3 = (
+        /** @type {Element} */
+        /* @__PURE__ */ get_first_child(
+          /** @type {DocumentFragment} */
+          create_fragment_from_html(o2)
+        )
+      );
+      i2 = /** @type {Element} */
+      /* @__PURE__ */ get_first_child(e3);
+    }
+    var t3 = (
+      /** @type {TemplateNode} */
+      i2.cloneNode(true)
+    );
+    return assign_nodes(t3, t3), t3;
+  };
+}
+function text(e2 = "") {
+  var t2 = create_text(e2 + "");
+  return assign_nodes(t2, t2), t2;
+}
+function comment() {
+  var e2 = document.createDocumentFragment(), t2 = document.createComment(""), n2 = create_text();
+  return e2.append(t2, n2), assign_nodes(t2, n2), e2;
+}
+function append(e2, t2) {
+  null !== e2 && e2.before(
+    /** @type {Node} */
+    t2
+  );
+}
+let se = true;
+function set_should_intro(e2) {
+  se = e2;
+}
+function set_text(e2, t2) {
+  var n2 = null == t2 ? "" : "object" == typeof t2 ? t2 + "" : t2;
+  n2 !== (e2.__t ?? (e2.__t = e2.nodeValue)) && // @ts-expect-error
+  (e2.__t = n2, e2.nodeValue = n2 + "");
+}
+function mount(e2, t2) {
+  return function _mount(e3, { target: t3, anchor: n2, props: o2 = {}, events: a2, context: l2, intro: c2 = true }) {
+    !/**
+    * Initialize these lazily to avoid issues when using the runtime in a server context
+    * where these globals are not available while avoiding a separate server entry point
+    */
+    function init_operations() {
+      if (void 0 === q) {
+        q = window, I = document, P = /Firefox/.test(navigator.userAgent);
+        var e4 = Element.prototype, t4 = Node.prototype;
+        O = s(t4, "firstChild").get, // @ts-ignore
+        E = s(t4, "nextSibling").get, // the following assignments improve perf of lookups on DOM nodes
+        // @ts-expect-error
+        e4.__click = void 0, // @ts-expect-error
+        e4.__className = void 0, // @ts-expect-error
+        e4.__attributes = null, // @ts-expect-error
+        e4.__styles = null, // @ts-expect-error
+        e4.__e = void 0, // @ts-expect-error
+        Text.prototype.__t = void 0;
+      }
+    }();
+    var u2 = /* @__PURE__ */ new Set(), event_handle = (e4) => {
+      for (var n3 = 0; n3 < e4.length; n3++) {
+        var i2 = e4[n3];
+        if (!u2.has(i2)) {
+          u2.add(i2);
+          var o3 = is_passive_event(i2);
+          t3.addEventListener(i2, handle_event_propagation, {
+            passive: o3
+          });
+          var s2 = ae.get(i2);
+          void 0 === s2 ? (
+            // The document listener ensures we catch events that originate from elements that were
+            // manually moved outside of the container (e.g. via manual portals).
+            (document.addEventListener(i2, handle_event_propagation, {
+              passive: o3
+            }), ae.set(i2, 1))
+          ) : ae.set(i2, s2 + 1);
+        }
+      }
+    };
+    event_handle(i(ie)), oe.add(event_handle);
+    var d2 = void 0, f2 = (
+      /**
+      * An effect root whose children can transition out
+      * @param {() => void} fn
+      * @returns {(options?: { outro?: boolean }) => Promise<void>}
+      */
+      function component_root(e4) {
+        const t4 = create_effect(64, e4, true);
+        return (e5 = {}) => new Promise((n3) => {
+          e5.outro ? pause_effect(t4, () => {
+            destroy_effect(t4), n3(void 0);
+          }) : (destroy_effect(t4), n3(void 0));
+        });
+      }(() => {
+        var i2 = n2 ?? t3.appendChild(create_text());
+        return branch(() => {
+          l2 && (push({}), /** @type {ComponentContext} */
+          T.c = l2);
+          a2 && // We can't spread the object or else we'd lose the state proxy stuff, if it is one
+          /** @type {any} */
+          (o2.$$events = a2), se = c2, // @ts-expect-error the public typings are not what the actual function looks like
+          d2 = e3(i2, o2) || {}, se = true, l2 && pop();
+        }), () => {
+          var _a;
+          for (var e4 of u2) {
+            t3.removeEventListener(e4, handle_event_propagation);
+            var o3 = (
+              /** @type {number} */
+              ae.get(e4)
+            );
+            0 == --o3 ? (document.removeEventListener(e4, handle_event_propagation), ae.delete(e4)) : ae.set(e4, o3);
+          }
+          oe.delete(event_handle), i2 !== n2 && ((_a = i2.parentNode) == null ? void 0 : _a.removeChild(i2));
+        };
+      })
+    );
+    return le.set(d2, f2), d2;
+  }(e2, t2);
+}
+const ae = /* @__PURE__ */ new Map();
+let le = /* @__PURE__ */ new WeakMap();
+function if_block(e2, t2, n2 = false) {
+  var i2 = e2, o2 = null, s2 = null, a2 = M, l2 = false;
+  const set_branch = (e3, t3 = true) => {
+    l2 = true, update_branch(t3, e3);
+  }, update_branch = (e3, t3) => {
+    a2 !== (a2 = e3) && (a2 ? (o2 ? resume_effect(o2) : t3 && (o2 = branch(() => t3(i2))), s2 && pause_effect(s2, () => {
+      s2 = null;
+    })) : (s2 ? resume_effect(s2) : t3 && (s2 = branch(() => t3(i2))), o2 && pause_effect(o2, () => {
+      o2 = null;
+    })));
+  };
+  block(() => {
+    l2 = false, t2(set_branch), l2 || update_branch(null, null);
+  }, n2 ? y : 0);
+}
+let ce = null;
+function set_current_each_item(e2) {
+  ce = e2;
+}
+function index(e2, t2) {
+  return t2;
+}
+function each(e2, n2, o2, s2, a2, l2 = null) {
+  var c2 = e2, u2 = {
+    flags: n2,
+    items: /* @__PURE__ */ new Map(),
+    first: null
+  };
+  !(4 & n2) || (c2 = /** @type {Element} */
+  e2.appendChild(create_text()));
+  var d2 = null, f2 = false, p2 = /* @__PURE__ */ derived_safe_equal(() => {
+    var e3 = o2();
+    return t(e3) ? e3 : null == e3 ? [] : i(e3);
+  });
+  block(() => {
+    var e3 = get$1(p2), t2 = e3.length;
+    f2 && 0 === t2 || (f2 = 0 === t2, /**
+    * Add, remove, or reorder items output by an each block as its input changes
+    * @template V
+    * @param {Array<V>} array
+    * @param {EachState} state
+    * @param {Element | Comment | Text} anchor
+    * @param {(anchor: Node, item: MaybeSource<V>, index: number | Source<number>, collection: () => V[]) => void} render_fn
+    * @param {number} flags
+    * @param {(value: V, index: number) => any} get_key
+    * @param {() => V[]} get_collection
+    * @returns {void}
+    */
+    function reconcile(e4, t3, n3, o3, s3, a3, l3) {
+      var _a, _b, _c, _d;
+      var c3, u3, d3, f3, p3, _2, v2 = !!(8 & s3), g2 = !!(3 & s3), h2 = e4.length, b2 = t3.items, y2 = t3.first, $2 = y2, w2 = null, x2 = [], k2 = [];
+      if (v2) for (_2 = 0; _2 < h2; _2 += 1) f3 = a3(d3 = e4[_2], _2), void 0 !== (p3 = b2.get(f3)) && ((_a = p3.a) == null ? void 0 : _a.measure(), (u3 ?? (u3 = /* @__PURE__ */ new Set())).add(p3));
+      for (_2 = 0; _2 < h2; _2 += 1) if (f3 = a3(d3 = e4[_2], _2), void 0 !== (p3 = b2.get(f3))) {
+        if (g2 && update_item(p3, d3, _2, s3), p3.e.f & m && (resume_effect(p3.e), v2 && ((_b = p3.a) == null ? void 0 : _b.unfix(), (u3 ?? (u3 = /* @__PURE__ */ new Set())).delete(p3))), p3 !== $2) {
+          if (void 0 !== c3 && c3.has(p3)) {
+            if (x2.length < k2.length) {
+              var C2, M2 = k2[0];
+              w2 = M2.prev;
+              var S2 = x2[0], T2 = x2[x2.length - 1];
+              for (C2 = 0; C2 < x2.length; C2 += 1) move(x2[C2], M2, n3);
+              for (C2 = 0; C2 < k2.length; C2 += 1) c3.delete(k2[C2]);
+              link(t3, S2.prev, T2.next), link(t3, w2, S2), link(t3, T2, M2), $2 = M2, w2 = T2, _2 -= 1, x2 = [], k2 = [];
+            } else
+              c3.delete(p3), move(p3, $2, n3), link(t3, p3.prev, p3.next), link(t3, p3, null === w2 ? t3.first : w2.next), link(t3, w2, p3), w2 = p3;
+            continue;
+          }
+          for (x2 = [], k2 = []; null !== $2 && $2.k !== f3; )
+            $2.e.f & m || (c3 ?? (c3 = /* @__PURE__ */ new Set())).add($2), k2.push($2), $2 = $2.next;
+          if (null === $2) continue;
+          p3 = $2;
+        }
+        x2.push(p3), w2 = p3, $2 = p3.next;
+      } else {
+        w2 = create_item($2 ? (
+          /** @type {TemplateNode} */
+          $2.e.nodes_start
+        ) : n3, t3, w2, null === w2 ? t3.first : w2.next, d3, f3, _2, o3, s3, l3), b2.set(f3, w2), x2 = [], k2 = [], $2 = w2.next;
+      }
+      if (null !== $2 || void 0 !== c3) {
+        for (var q2 = void 0 === c3 ? [] : i(c3); null !== $2; )
+          $2.e.f & m || q2.push($2), $2 = $2.next;
+        var I2 = q2.length;
+        if (I2 > 0) {
+          var P2 = 4 & s3 && 0 === h2 ? n3 : null;
+          if (v2) {
+            for (_2 = 0; _2 < I2; _2 += 1) (_c = q2[_2].a) == null ? void 0 : _c.measure();
+            for (_2 = 0; _2 < I2; _2 += 1) (_d = q2[_2].a) == null ? void 0 : _d.fix();
+          }
+          !function pause_effects(e5, t4, n4, i2) {
+            for (var o4 = [], s4 = t4.length, a4 = 0; a4 < s4; a4++) pause_children(t4[a4].e, o4, true);
+            var l4 = s4 > 0 && 0 === o4.length && null !== n4;
+            if (l4) {
+              var c4 = (
+                /** @type {Element} */
+                /** @type {Element} */
+                n4.parentNode
+              );
+              !function clear_text_content(e6) {
+                e6.textContent = "";
+              }(c4), c4.append(
+                /** @type {Element} */
+                n4
+              ), i2.clear(), link(e5, t4[0].prev, t4[s4 - 1].next);
+            }
+            run_out_transitions(o4, () => {
+              for (var n5 = 0; n5 < s4; n5++) {
+                var o5 = t4[n5];
+                l4 || (i2.delete(o5.k), link(e5, o5.prev, o5.next)), destroy_effect(o5.e, !l4);
+              }
+            });
+          }(t3, q2, P2, b2);
+        }
+      }
+      v2 && queue_micro_task(() => {
+        var _a2;
+        if (void 0 !== u3) for (p3 of u3) (_a2 = p3.a) == null ? void 0 : _a2.apply();
+      });
+      H.first = t3.first && t3.first.e, /** @type {Effect} */
+      H.last = w2 && w2.e;
+    }(e3, u2, c2, a2, n2, s2, o2), null !== l2 && (0 === t2 ? d2 ? resume_effect(d2) : d2 = branch(() => l2(c2)) : null !== d2 && pause_effect(d2, () => {
+      d2 = null;
+    })), // When we mount the each block for the first time, the collection won't be
+    // connected to this effect as the effect hasn't finished running yet and its deps
+    // won't be assigned. However, it's possible that when reconciling the each block
+    // that a mutation occurred and it's made the collection MAYBE_DIRTY, so reading the
+    // collection again can provide consistency to the reactive graph again as the deriveds
+    // will now be `CLEAN`.
+    get$1(p2));
+  });
+}
+function update_item(e2, t2, n2, i2) {
+  1 & i2 && internal_set(e2.v, t2), 2 & i2 ? internal_set(
+    /** @type {Value<number>} */
+    e2.i,
+    n2
+  ) : e2.i = n2;
+}
+function create_item(e2, t2, n2, i2, o2, s2, a2, l2, c2, u2) {
+  var d2 = ce, f2 = !!(1 & c2) ? !(16 & c2) ? /* @__PURE__ */ mutable_source(o2) : source(o2) : o2, p2 = 2 & c2 ? source(a2) : a2, _2 = {
+    i: p2,
+    v: f2,
+    k: s2,
+    a: null,
+    // @ts-expect-error
+    e: null,
+    prev: n2,
+    next: i2
+  };
+  ce = _2;
+  try {
+    return _2.e = branch(() => l2(e2, f2, p2, u2), false), _2.e.prev = n2 && n2.e, _2.e.next = i2 && i2.e, null === n2 ? t2.first = _2 : (n2.next = _2, n2.e.next = _2.e), null !== i2 && (i2.prev = _2, i2.e.prev = _2.e), _2;
+  } finally {
+    ce = d2;
+  }
+}
+function move(e2, t2, n2) {
+  for (var i2 = e2.next ? (
+    /** @type {TemplateNode} */
+    e2.next.e.nodes_start
+  ) : n2, o2 = t2 ? (
+    /** @type {TemplateNode} */
+    t2.e.nodes_start
+  ) : n2, s2 = (
+    /** @type {TemplateNode} */
+    e2.e.nodes_start
+  ); s2 !== i2; ) {
+    var a2 = (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ get_next_sibling(s2)
+    );
+    o2.before(s2), s2 = a2;
+  }
+}
+function link(e2, t2, n2) {
+  null === t2 ? e2.first = n2 : (t2.next = n2, t2.e.next = n2 && n2.e), null !== n2 && (n2.prev = t2, n2.e.prev = t2 && t2.e);
+}
+function slot(e2, t2, n2, i2, o2) {
+  var _a;
+  var s2 = (_a = t2.$$slots) == null ? void 0 : _a[n2], a2 = false;
+  true === s2 && (s2 = t2["default" === n2 ? "children" : n2], a2 = true), void 0 === s2 ? null !== o2 && o2(e2) : s2(e2, a2 ? () => i2 : i2);
+}
+function component(e2, t2, n2) {
+  var i2, o2, s2 = e2;
+  block(() => {
+    i2 !== (i2 = t2()) && (o2 && (pause_effect(o2), o2 = null), i2 && (o2 = branch(() => n2(s2, i2))));
+  }, y);
+}
+function r(e2) {
+  var t2, n2, i2 = "";
+  if ("string" == typeof e2 || "number" == typeof e2) i2 += e2;
+  else if ("object" == typeof e2) if (Array.isArray(e2)) {
+    var o2 = e2.length;
+    for (t2 = 0; t2 < o2; t2++) e2[t2] && (n2 = r(e2[t2])) && (i2 && (i2 += " "), i2 += n2);
+  } else for (n2 in e2) e2[n2] && (i2 && (i2 += " "), i2 += n2);
+  return i2;
+}
+function clsx(e2) {
+  return "object" == typeof e2 ? function clsx$1() {
+    for (var e3, t2, n2 = 0, i2 = "", o2 = arguments.length; n2 < o2; n2++) (e3 = arguments[n2]) && (t2 = r(e3)) && (i2 && (i2 += " "), i2 += t2);
+    return i2;
+  }(e2) : e2 ?? "";
+}
+const ue = [..." 	\n\r\f \v\uFEFF"];
+function set_class(e2, t2, n2, i2, o2, s2) {
+  if (e2.__className !== n2) {
+    var a2 = function to_class(e3, t3, n3) {
+      var i3 = null == e3 ? "" : "" + e3;
+      if (t3 && (i3 = i3 ? i3 + " " + t3 : t3), n3) {
+        for (var o3 in n3) if (n3[o3]) i3 = i3 ? i3 + " " + o3 : o3;
+        else if (i3.length) for (var s3 = o3.length, a3 = 0; (a3 = i3.indexOf(o3, a3)) >= 0; ) {
+          var l3 = a3 + s3;
+          0 !== a3 && !ue.includes(i3[a3 - 1]) || l3 !== i3.length && !ue.includes(i3[l3]) ? a3 = l3 : i3 = (0 === a3 ? "" : i3.substring(0, a3)) + i3.substring(l3 + 1);
+        }
+      }
+      return "" === i3 ? null : i3;
+    }(n2, i2, s2);
+    null == a2 ? e2.removeAttribute("class") : t2 ? e2.className = a2 : e2.setAttribute("class", a2), // @ts-expect-error need to add __className to patched prototype
+    e2.__className = n2;
+  } else if (s2) for (var l2 in s2) {
+    var c2 = !!s2[l2];
+    null != o2 && c2 === !!o2[l2] || e2.classList.toggle(l2, c2);
+  }
+  return s2;
+}
+const de = Symbol("class");
+function set_selected(e2, t2) {
+  t2 ? (
+    // The selected option could've changed via user selection, and
+    // setting the value without this check would set it back.
+    e2.hasAttribute("selected") || e2.setAttribute("selected", "")
+  ) : e2.removeAttribute("selected");
+}
+function set_attribute(e2, t2, n2, i2) {
+  var o2 = e2.__attributes ?? (e2.__attributes = {});
+  o2[t2] !== (o2[t2] = n2) && ("style" === t2 && "__styles" in e2 && // reset styles to force style: directive to update
+  (e2.__styles = {}), "loading" === t2 && // @ts-expect-error
+  (e2[k] = n2), null == n2 ? e2.removeAttribute(t2) : "string" != typeof n2 && get_setters(e2).includes(t2) ? (
+    // @ts-ignore
+    e2[t2] = n2
+  ) : e2.setAttribute(t2, n2));
+}
+function set_attributes(e2, t2, n2, i2, o2 = false, s2 = false, a2 = false) {
+  var l2 = t2 || {}, c2 = "OPTION" === e2.tagName;
+  for (var u2 in t2) u2 in n2 || (n2[u2] = null);
+  n2.class ? n2.class = clsx(n2.class) : (i2 || n2[de]) && (n2.class = null);
+  var d2 = get_setters(e2), f2 = (
+    /** @type {Record<string, unknown>} **/
+    e2.__attributes ?? (e2.__attributes = {})
+  );
+  for (const m2 in n2) {
+    let b2 = n2[m2];
+    if (c2 && "value" === m2 && null == b2)
+      e2.value = e2.__value = "", l2[m2] = b2;
+    else if ("class" !== m2) {
+      var p2 = l2[m2];
+      if (b2 !== p2) {
+        l2[m2] = b2;
+        var _2 = m2[0] + m2[1];
+        if ("$$" !== _2) {
+          if ("on" === _2) {
+            const y2 = {}, $2 = "$$" + m2;
+            let w2 = m2.slice(2);
+            var v2 = is_delegated(w2);
+            if (is_capture_event(w2) && (w2 = w2.slice(0, -7), y2.capture = true), !v2 && p2) {
+              if (null != b2) continue;
+              e2.removeEventListener(w2, l2[$2], y2), l2[$2] = null;
+            }
+            if (null != b2) if (v2)
+              e2[`__${w2}`] = b2, delegate([w2]);
+            else {
+              let handle = function(e3) {
+                l2[m2].call(this, e3);
+              };
+              l2[$2] = create_event(w2, e2, handle, y2);
+            }
+            else v2 && // @ts-ignore
+            (e2[`__${w2}`] = void 0);
+          } else if ("style" === m2 && null != b2) e2.style.cssText = b2 + "";
+          else if ("autofocus" === m2) autofocus(
+            /** @type {HTMLElement} */
+            e2,
+            Boolean(b2)
+          );
+          else if (s2 || "__value" !== m2 && ("value" !== m2 || null == b2)) if ("selected" === m2 && c2) set_selected(
+            /** @type {HTMLOptionElement} */
+            e2,
+            b2
+          );
+          else {
+            var g2 = m2;
+            o2 || (g2 = normalize_attribute(g2));
+            var h2 = "defaultValue" === g2 || "defaultChecked" === g2;
+            if (null != b2 || s2 || h2) h2 || d2.includes(g2) && (s2 || "string" != typeof b2) ? (
+              // @ts-ignore
+              e2[g2] = b2
+            ) : "function" != typeof b2 && set_attribute(e2, g2, b2);
+            else if (f2[m2] = null, "value" === g2 || "checked" === g2) {
+              let x2 = (
+                /** @type {HTMLInputElement} */
+                e2
+              );
+              const k2 = void 0 === t2;
+              if ("value" === g2) {
+                let C2 = x2.defaultValue;
+                x2.removeAttribute(g2), x2.defaultValue = C2, // @ts-ignore
+                x2.value = x2.__value = k2 ? C2 : null;
+              } else {
+                let M2 = x2.defaultChecked;
+                x2.removeAttribute(g2), x2.defaultChecked = M2, x2.checked = !!k2 && M2;
+              }
+            } else e2.removeAttribute(m2);
+          }
+          else
+            e2.value = e2.__value = b2;
+          "style" === m2 && "__styles" in e2 && // reset styles to force style: directive to update
+          (e2.__styles = {});
+        }
+      }
+    } else {
+      set_class(e2, "http://www.w3.org/1999/xhtml" === e2.namespaceURI, b2, i2, t2 == null ? void 0 : t2[de], n2[de]), l2[m2] = b2, l2[de] = n2[de];
+    }
+  }
+  return l2;
+}
+var fe = /* @__PURE__ */ new Map();
+function get_setters(e2) {
+  var t2, n2 = fe.get(e2.nodeName);
+  if (n2) return n2;
+  fe.set(e2.nodeName, n2 = []);
+  for (var i2 = e2, o2 = Element.prototype; o2 !== i2; ) {
+    for (var s2 in t2 = a(i2)) t2[s2].set && n2.push(s2);
+    i2 = u(i2);
+  }
+  return n2;
+}
+function set_style(e2, t2, n2, i2) {
+  var o2 = e2.__styles ?? (e2.__styles = {});
+  o2[t2] !== n2 && (o2[t2] = n2, null == n2 ? e2.style.removeProperty(t2) : e2.style.setProperty(t2, n2, ""));
+}
+const pe = {
+  // don't access requestAnimationFrame eagerly outside method
+  // this allows basic testing of user code without JSDOM
+  // bunder will eval and remove ternary when the user's app is built
+  tick: (
+    /** @param {any} _ */
+    (e2) => requestAnimationFrame(e2)
+  ),
+  now: () => performance.now(),
+  tasks: /* @__PURE__ */ new Set()
+};
+function run_tasks() {
+  const e2 = pe.now();
+  pe.tasks.forEach((t2) => {
+    t2.c(e2) || (pe.tasks.delete(t2), t2.f());
+  }), 0 !== pe.tasks.size && pe.tick(run_tasks);
+}
+function dispatch_event(e2, t2) {
+  without_reactive_context(() => {
+    e2.dispatchEvent(new CustomEvent(t2));
+  });
+}
+function css_property_to_camelcase(e2) {
+  if ("float" === e2) return "cssFloat";
+  if ("offset" === e2) return "cssOffset";
+  if (e2.startsWith("--")) return e2;
+  const t2 = e2.split("-");
+  return 1 === t2.length ? t2[0] : t2[0] + t2.slice(1).map(
+    /** @param {any} word */
+    (e3) => e3[0].toUpperCase() + e3.slice(1)
+  ).join("");
+}
+function css_to_keyframe(e2) {
+  const t2 = {}, n2 = e2.split(";");
+  for (const e3 of n2) {
+    const [n3, i2] = e3.split(":");
+    if (!n3 || void 0 === i2) break;
+    t2[css_property_to_camelcase(n3.trim())] = i2.trim();
+  }
+  return t2;
+}
+const linear = (e2) => e2;
+function transition(e2, t2, n2, i2) {
+  var o2, s2, a2, l2 = !!(4 & e2), c2 = t2.inert, u2 = t2.style.overflow;
+  function get_options() {
+    var e3 = F, s3 = H;
+    set_active_reaction(null), set_active_effect(null);
+    try {
+      return o2 ?? (o2 = n2()(t2, (i2 == null ? void 0 : i2()) ?? /** @type {P} */
+      {}, {
+        direction: "both"
+      }));
+    } finally {
+      set_active_reaction(e3), set_active_effect(s3);
+    }
+  }
+  var d2 = {
+    is_global: l2,
+    in() {
+      t2.inert = c2, dispatch_event(t2, "introstart"), s2 = animate(t2, get_options(), a2, 1, () => {
+        dispatch_event(t2, "introend"), // Ensure we cancel the animation to prevent leaking
+        s2 == null ? void 0 : s2.abort(), s2 = o2 = void 0, t2.style.overflow = u2;
+      });
+    },
+    out(e3) {
+      t2.inert = true, dispatch_event(t2, "outrostart"), a2 = animate(t2, get_options(), s2, 0, () => {
+        dispatch_event(t2, "outroend"), e3 == null ? void 0 : e3();
+      });
+    },
+    stop: () => {
+      s2 == null ? void 0 : s2.abort(), a2 == null ? void 0 : a2.abort();
+    }
+  }, f2 = (
+    /** @type {Effect} */
+    H
+  );
+  if ((f2.transitions ?? (f2.transitions = [])).push(d2), se) {
+    var p2 = l2;
+    if (!p2) {
+      for (var _2 = (
+        /** @type {Effect | null} */
+        f2.parent
+      ); _2 && _2.f & y; ) for (; (_2 = _2.parent) && !(16 & _2.f); ) ;
+      p2 = !_2 || !!(32768 & _2.f);
+    }
+    p2 && effect(() => {
+      untrack(() => d2.in());
+    });
+  }
+}
+function animate(e2, t2, n2, i2, o2) {
+  var s2 = 1 === i2;
+  if (is_function(t2)) {
+    var a2, l2 = false;
+    return queue_micro_task(() => {
+      if (!l2) {
+        var c3 = t2({
+          direction: s2 ? "in" : "out"
+        });
+        a2 = animate(e2, c3, n2, i2, o2);
+      }
+    }), {
+      abort: () => {
+        l2 = true, a2 == null ? void 0 : a2.abort();
+      },
+      deactivate: () => a2.deactivate(),
+      reset: () => a2.reset(),
+      t: () => a2.t()
+    };
+  }
+  if (n2 == null ? void 0 : n2.deactivate(), !(t2 == null ? void 0 : t2.duration)) return o2(), {
+    abort: noop,
+    deactivate: noop,
+    reset: noop,
+    t: () => i2
+  };
+  const { delay: c2 = 0, css: u2, tick: d2, easing: f2 = linear } = t2;
+  var p2 = [];
+  if (s2 && void 0 === n2 && (d2 && d2(0, 1), u2)) {
+    var _2 = css_to_keyframe(u2(0, 1));
+    p2.push(_2, _2);
+  }
+  var get_t = () => 1 - i2, v2 = e2.animate(p2, {
+    duration: c2
+  });
+  return v2.onfinish = () => {
+    var s3 = (n2 == null ? void 0 : n2.t()) ?? 1 - i2;
+    n2 == null ? void 0 : n2.abort();
+    var a3 = i2 - s3, l3 = (
+      /** @type {number} */
+      t2.duration * Math.abs(a3)
+    ), c3 = [];
+    if (l3 > 0) {
+      var p3 = false;
+      if (u2)
+        for (var _3 = Math.ceil(l3 / (1e3 / 60)), g2 = 0; g2 <= _3; g2 += 1) {
+          var h2 = s3 + a3 * f2(g2 / _3), m2 = css_to_keyframe(u2(h2, 1 - h2));
+          c3.push(m2), p3 || (p3 = "hidden" === m2.overflow);
+        }
+      p3 && /** @type {HTMLElement} */
+      (e2.style.overflow = "hidden"), get_t = () => {
+        var e3 = (
+          /** @type {number} */
+          /** @type {globalThis.Animation} */
+          v2.currentTime
+        );
+        return s3 + a3 * f2(e3 / l3);
+      }, d2 && function loop(e3) {
+        let t3;
+        return 0 === pe.tasks.size && pe.tick(run_tasks), {
+          promise: new Promise((n3) => {
+            pe.tasks.add(t3 = {
+              c: e3,
+              f: n3
+            });
+          }),
+          abort() {
+            pe.tasks.delete(t3);
+          }
+        };
+      }(() => {
+        if ("running" !== v2.playState) return false;
+        var e3 = get_t();
+        return d2(e3, 1 - e3), true;
+      });
+    }
+    (v2 = e2.animate(c3, {
+      duration: l3,
+      fill: "forwards"
+    })).onfinish = () => {
+      get_t = () => i2, d2 == null ? void 0 : d2(i2, 1 - i2), o2();
+    };
+  }, {
+    abort: () => {
+      v2 && (v2.cancel(), // This prevents memory leaks in Chromium
+      v2.effect = null, // This prevents onfinish to be launched after cancel(),
+      // which can happen in some rare cases
+      // see https://github.com/sveltejs/svelte/issues/13681
+      v2.onfinish = noop);
+    },
+    deactivate: () => {
+      o2 = noop;
+    },
+    reset: () => {
+      0 === i2 && (d2 == null ? void 0 : d2(1, 0));
+    },
+    t: () => get_t()
+  };
+}
+function is_numberlike_input(e2) {
+  var t2 = e2.type;
+  return "number" === t2 || "range" === t2;
+}
+function to_number(e2) {
+  return "" === e2 ? null : +e2;
+}
+function is_bound_this(e2, t2) {
+  return e2 === t2 || (e2 == null ? void 0 : e2[w]) === t2;
+}
+function bind_this(e2 = {}, t2, n2, i2) {
+  return effect(() => {
+    var i3, o2;
+    return render_effect(() => {
+      i3 = o2, // We only track changes to the parts, not the value itself to avoid unnecessary reruns.
+      o2 = [], untrack(() => {
+        e2 !== n2(...o2) && (t2(e2, ...o2), // If this is an effect rerun (cause: each block context changes), then nullfiy the binding at
+        // the previous position if it isn't already taken over by a different effect.
+        i3 && is_bound_this(n2(...i3), e2) && t2(null, ...i3));
+      });
+    }), () => {
+      queue_micro_task(() => {
+        o2 && is_bound_this(n2(...o2), e2) && t2(null, ...o2);
+      });
+    };
+  }), e2;
+}
+function init(e2 = false) {
+  const t2 = (
+    /** @type {ComponentContextLegacy} */
+    T
+  ), n2 = t2.l.u;
+  if (!n2) return;
+  let props = () => deep_read_state(t2.s);
+  if (e2) {
+    let e3 = 0, n3 = (
+      /** @type {Record<string, any>} */
+      {}
+    );
+    const i2 = /* @__PURE__ */ derived(() => {
+      let i3 = false;
+      const o2 = t2.s;
+      for (const e4 in o2) o2[e4] !== n3[e4] && (n3[e4] = o2[e4], i3 = true);
+      return i3 && e3++, e3;
+    });
+    props = () => get$1(i2);
+  }
+  n2.b.length && function user_pre_effect(e3) {
+    return validate_effect(), render_effect(e3);
+  }(() => {
+    observe_all(t2, props), run_all(n2.b);
+  }), // onMount (must run before afterUpdate)
+  user_effect(() => {
+    const e3 = untrack(() => n2.m.map(run));
+    return () => {
+      for (const t3 of e3) "function" == typeof t3 && t3();
+    };
+  }), // afterUpdate
+  n2.a.length && user_effect(() => {
+    observe_all(t2, props), run_all(n2.a);
+  });
+}
+function observe_all(e2, t2) {
+  if (e2.l.s) for (const t3 of e2.l.s) get$1(t3);
+  t2();
+}
+function subscribe_to_store(e2, t2, n2) {
+  if (null == e2)
+    return t2(void 0), noop;
+  const i2 = untrack(() => e2.subscribe(
+    t2,
+    // @ts-expect-error
+    n2
+  ));
+  return i2.unsubscribe ? () => i2.unsubscribe() : i2;
+}
+const _e = [];
+function writable(e2, t2 = noop) {
+  let n2 = null;
+  const i2 = /* @__PURE__ */ new Set();
+  function set2(t3) {
+    if (safe_not_equal(e2, t3) && (e2 = t3, n2)) {
+      const t4 = !_e.length;
+      for (const t5 of i2) t5[1](), _e.push(t5, e2);
+      if (t4) {
+        for (let e3 = 0; e3 < _e.length; e3 += 2) _e[e3][0](_e[e3 + 1]);
+        _e.length = 0;
+      }
+    }
+  }
+  function update2(t3) {
+    set2(t3(
+      /** @type {T} */
+      e2
+    ));
+  }
+  return {
+    set: set2,
+    update: update2,
+    subscribe: function subscribe(o2, s2 = noop) {
+      const a2 = [o2, s2];
+      return i2.add(a2), 1 === i2.size && (n2 = t2(set2, update2) || noop), o2(
+        /** @type {T} */
+        e2
+      ), () => {
+        i2.delete(a2), 0 === i2.size && n2 && (n2(), n2 = null);
+      };
+    }
+  };
+}
+function get(e2) {
+  let t2;
+  return subscribe_to_store(e2, (e3) => t2 = e3)(), t2;
+}
+let ve = false, ge = Symbol();
+function store_get(e2, t2, n2) {
+  const i2 = n2[t2] ?? (n2[t2] = {
+    store: null,
+    source: /* @__PURE__ */ mutable_source(void 0),
+    unsubscribe: noop
+  });
+  if (i2.store !== e2 && !(ge in n2)) if (i2.unsubscribe(), i2.store = e2 ?? null, null == e2) i2.source.v = void 0, // see synchronous callback comment below
+  i2.unsubscribe = noop;
+  else {
+    var o2 = true;
+    i2.unsubscribe = subscribe_to_store(e2, (e3) => {
+      o2 ? (
+        // If the first updates to the store value (possibly multiple of them) are synchronously
+        // inside a derived, we will hit the `state_unsafe_mutation` error if we `set` the value
+        i2.source.v = e3
+      ) : set(i2.source, e3);
+    }), o2 = false;
+  }
+  return e2 && ge in n2 ? get(e2) : get$1(i2.source);
+}
+function store_set(e2, t2) {
+  return e2.set(t2), t2;
+}
+function setup_stores() {
+  const e2 = {};
+  return [e2, function cleanup() {
+    teardown(() => {
+      for (var t2 in e2) {
+        e2[t2].unsubscribe();
+      }
+      o(e2, ge, {
+        enumerable: false,
+        value: true
+      });
+    });
+  }];
+}
+const he = {
+  get(e2, t2) {
+    if (!e2.exclude.includes(t2)) return get$1(e2.version), t2 in e2.special ? e2.special[t2]() : e2.props[t2];
+  },
+  set: (e2, t2, n2) => (t2 in e2.special || // Handle props that can temporarily get out of sync with the parent
+  /** @type {Record<string, (v?: unknown) => unknown>} */
+  (e2.special[t2] = prop(
+    {
+      get [t2]() {
+        return e2.props[t2];
+      }
+    },
+    /** @type {string} */
+    t2,
+    4
+  )), e2.special[t2](n2), update(e2.version), true),
+  getOwnPropertyDescriptor(e2, t2) {
+    if (!e2.exclude.includes(t2)) return t2 in e2.props ? {
+      enumerable: true,
+      configurable: true,
+      value: e2.props[t2]
+    } : void 0;
+  },
+  deleteProperty: (e2, t2) => (
+    // Svelte 4 allowed for deletions on $$restProps
+    (e2.exclude.includes(t2) || (e2.exclude.push(t2), update(e2.version)), true)
+  ),
+  has: (e2, t2) => !e2.exclude.includes(t2) && t2 in e2.props,
+  ownKeys: (e2) => Reflect.ownKeys(e2.props).filter((t2) => !e2.exclude.includes(t2))
+};
+function legacy_rest_props(e2, t2) {
+  return new Proxy({
+    props: e2,
+    exclude: t2,
+    special: {},
+    version: source(0)
+  }, he);
+}
+const me = {
+  get(e2, t2) {
+    let n2 = e2.props.length;
+    for (; n2--; ) {
+      let i2 = e2.props[n2];
+      if (is_function(i2) && (i2 = i2()), "object" == typeof i2 && null !== i2 && t2 in i2) return i2[t2];
+    }
+  },
+  set(e2, t2, n2) {
+    let i2 = e2.props.length;
+    for (; i2--; ) {
+      let o2 = e2.props[i2];
+      is_function(o2) && (o2 = o2());
+      const a2 = s(o2, t2);
+      if (a2 && a2.set) return a2.set(n2), true;
+    }
+    return false;
+  },
+  getOwnPropertyDescriptor(e2, t2) {
+    let n2 = e2.props.length;
+    for (; n2--; ) {
+      let i2 = e2.props[n2];
+      if (is_function(i2) && (i2 = i2()), "object" == typeof i2 && null !== i2 && t2 in i2) {
+        const e3 = s(i2, t2);
+        return e3 && !e3.configurable && // Prevent a "Non-configurability Report Error": The target is an array, it does
+        // not actually contain this property. If it is now described as non-configurable,
+        // the proxy throws a validation error. Setting it to true avoids that.
+        (e3.configurable = true), e3;
+      }
+    }
+  },
+  has(e2, t2) {
+    if (t2 === w || t2 === x) return false;
+    for (let n2 of e2.props) if (is_function(n2) && (n2 = n2()), null != n2 && t2 in n2) return true;
+    return false;
+  },
+  ownKeys(e2) {
+    const t2 = [];
+    for (let n2 of e2.props) {
+      is_function(n2) && (n2 = n2());
+      for (const e3 in n2) t2.includes(e3) || t2.push(e3);
+    }
+    return t2;
+  }
+};
+function spread_props(...e2) {
+  return new Proxy({
+    props: e2
+  }, me);
+}
+function prop(e2, t2, n2, i2) {
+  var _a;
+  var o2, a2 = !!(1 & n2), l2 = !C || !!(2 & n2), c2 = !!(8 & n2), u2 = !!(16 & n2), d2 = false;
+  c2 ? [o2, d2] = function capture_store_binding(e3) {
+    var t3 = ve;
+    try {
+      return ve = false, [e3(), ve];
+    } finally {
+      ve = t3;
+    }
+  }(() => (
+    /** @type {V} */
+    e2[t2]
+  )) : o2 = /** @type {V} */
+  e2[t2];
+  var f2, p2 = w in e2 || x in e2, _2 = c2 && (((_a = s(e2, t2)) == null ? void 0 : _a.set) ?? (p2 && t2 in e2 && ((n3) => e2[t2] = n3))) || void 0, v2 = (
+    /** @type {V} */
+    i2
+  ), g2 = true, h2 = false, get_fallback = () => (h2 = true, g2 && (g2 = false, v2 = u2 ? untrack(
+    /** @type {() => V} */
+    i2
+  ) : (
+    /** @type {V} */
+    i2
+  )), v2);
+  if (void 0 === o2 && void 0 !== i2 && (_2 && l2 && function props_invalid_value(e3) {
+    throw new Error("https://svelte.dev/e/props_invalid_value");
+  }(), o2 = get_fallback(), _2 && _2(o2)), l2) f2 = () => {
+    var n3 = (
+      /** @type {V} */
+      e2[t2]
+    );
+    return void 0 === n3 ? get_fallback() : (g2 = true, h2 = false, n3);
+  };
+  else {
+    var m2 = (a2 ? derived : derived_safe_equal)(() => (
+      /** @type {V} */
+      e2[t2]
+    ));
+    m2.f |= 131072, f2 = () => {
+      var e3 = get$1(m2);
+      return void 0 !== e3 && (v2 = /** @type {V} */
+      void 0), void 0 === e3 ? v2 : e3;
+    };
+  }
+  if (!(4 & n2)) return f2;
+  if (_2) {
+    var b2 = e2.$$legacy;
+    return function(e3, t3) {
+      return arguments.length > 0 ? (
+        // We don't want to notify if the value was mutated and the parent is in runes mode.
+        // In that case the state proxy (if it exists) should take care of the notification.
+        // If the parent is not in runes mode, we need to notify on mutation, too, that the prop
+        // has changed because the parent will not be able to detect the change otherwise.
+        (l2 && t3 && !b2 && !d2 || /** @type {Function} */
+        _2(t3 ? f2() : e3), e3)
+      ) : f2();
+    };
+  }
+  var y2 = false, $2 = /* @__PURE__ */ mutable_source(o2), k2 = /* @__PURE__ */ derived(() => {
+    var e3 = f2(), t3 = get$1($2);
+    return y2 ? (y2 = false, t3) : $2.v = e3;
+  });
+  return a2 || (k2.equals = safe_equals), function(e3, t3) {
+    if (arguments.length > 0) {
+      const n3 = t3 ? get$1(k2) : l2 && c2 ? proxy(e3) : e3;
+      return k2.equals(n3) || (y2 = true, set($2, n3), // To ensure the fallback value is consistent when used with proxies, we
+      // update the local fallback_value, but only if the fallback is actively used
+      h2 && void 0 !== v2 && (v2 = n3), untrack(() => get$1(k2))), e3;
+    }
+    return get$1(k2);
+  };
+}
+function onMount(e2) {
+  null === T && lifecycle_outside_component(), C && null !== T.l ? (
+    /**
+    * Legacy-mode: Init callbacks object for onMount/beforeUpdate/afterUpdate
+    * @param {ComponentContext} context
+    */
+    function init_update_callbacks(e3) {
+      var t2 = (
+        /** @type {ComponentContextLegacy} */
+        e3.l
+      );
+      return t2.u ?? (t2.u = {
+        a: [],
+        b: [],
+        m: []
+      });
+    }(T).m.push(e2)
+  ) : user_effect(() => {
+    const t2 = untrack(e2);
+    if ("function" == typeof t2) return t2;
+  });
+}
+"undefined" != typeof window && // @ts-ignore
+(window.__svelte || (window.__svelte = {
+  v: /* @__PURE__ */ new Set()
+})).v.add("5"), function enable_legacy_mode_flag() {
+  C = true;
+}();
+/**
+ * @license lucide-svelte v0.476.0 - ISC
+ *
+ * ISC License
+ * 
+ * Copyright (c) for portions of Lucide are held by Cole Bemis 2013-2022 as part of Feather (MIT). All other copyright (c) for Lucide are held by Lucide Contributors 2022.
+ * 
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ * 
+ */
+const be = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: 24,
+  height: 24,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-width": 2,
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round"
+};
+var ye = /* @__PURE__ */ ns_template("<svg><!><!></svg>");
+function Icon$1(e2, t2) {
+  const n2 = legacy_rest_props(t2, ["children", "$$slots", "$$events", "$$legacy"]), i2 = legacy_rest_props(n2, ["name", "color", "size", "strokeWidth", "absoluteStrokeWidth", "iconNode"]);
+  push(t2, false);
+  let o2 = prop(t2, "name", 8, void 0), s2 = prop(t2, "color", 8, "currentColor"), a2 = prop(t2, "size", 8, 24), l2 = prop(t2, "strokeWidth", 8, 2), c2 = prop(t2, "absoluteStrokeWidth", 8, false), u2 = prop(t2, "iconNode", 24, () => []);
+  init();
+  var d2 = ye();
+  let f2;
+  var p2 = child(d2);
+  each(p2, 1, u2, index, (e3, t3) => {
+    var n3 = comment();
+    !function element(e4, t4, n4, i3, o3, s3) {
+      var a3, l3, c3, u3 = null, d3 = (
+        /** @type {TemplateNode} */
+        e4
+      ), f3 = ce;
+      block(() => {
+        const e5 = t4() || null;
+        var n5 = S;
+        if (e5 !== a3) {
+          var o4 = ce;
+          set_current_each_item(f3), c3 && (null === e5 ? (
+            // start outro
+            pause_effect(c3, () => {
+              c3 = null, l3 = null;
+            })
+          ) : e5 === l3 ? (
+            // same tag as is currently rendered — abort outro
+            resume_effect(c3)
+          ) : (
+            // tag is changing — destroy immediately, render contents without intro transitions
+            (destroy_effect(c3), set_should_intro(false))
+          )), e5 && e5 !== l3 && (c3 = branch(() => {
+            if (assign_nodes(u3 = document.createElementNS(n5, e5), u3), i3) {
+              var t5 = (
+                /** @type {TemplateNode} */
+                u3.appendChild(create_text())
+              );
+              i3(u3, t5);
+            }
+            H.nodes_end = u3, d3.before(u3);
+          })), (a3 = e5) && (l3 = a3), set_should_intro(true), set_current_each_item(o4);
+        }
+      }, y);
+    }(first_child(n3), () => get$1(t3)[0], 0, (e4, n4) => {
+      let i3;
+      template_effect(() => i3 = set_attributes(e4, i3, {
+        ...get$1(t3)[1]
+      }, void 0, e4.namespaceURI === S, e4.nodeName.includes("-")));
+    }), append(e3, n3);
+  }), slot(sibling(p2), t2, "default", {}, null), template_effect((e3, t3) => f2 = set_attributes(d2, f2, {
+    ...be,
+    ...i2,
+    width: a2(),
+    height: a2(),
+    stroke: s2(),
+    "stroke-width": e3,
+    class: t3
+  }, void 0, true), [() => c2() ? 24 * Number(l2()) / Number(a2()) : l2(), () => ((...e3) => e3.filter((e4, t3, n3) => Boolean(e4) && n3.indexOf(e4) === t3).join(" "))("lucide-icon", "lucide", o2() ? `lucide-${o2()}` : "", n2.class)], derived_safe_equal), append(e2, d2), pop();
+}
+function Loader_circle(e2, t2) {
+  const n2 = legacy_rest_props(t2, ["children", "$$slots", "$$events", "$$legacy"]);
+  Icon$1(e2, spread_props({
+    name: "loader-circle"
+  }, () => n2, {
+    iconNode: [["path", {
+      d: "M21 12a9 9 0 1 1-6.219-8.56"
+    }]],
+    children: (e3, n3) => {
+      var i2 = comment();
+      slot(first_child(i2), t2, "default", {}, null), append(e3, i2);
+    },
+    $$slots: {
+      default: true
+    }
+  }));
+}
+var on_click$2 = (e2, t2) => {
+  var _a;
+  (_a = t2.onClick) == null ? void 0 : _a.call(t2);
+}, $e = /* @__PURE__ */ template('<button id="floating playlight button" aria-label="Open Playlight Discovery"><p class="z-2 flex items-center overflow-hidden svelte-1j97rta"><!> <span class="mr-0.25 inline-block svelte-1j97rta">More Games</span></p> <div class="absolute bottom-0 left-0 h-full w-0 bg-black transition-all duration-300 group-hover:w-full svelte-1j97rta"></div></button>');
+function FloatingButton(e2, t2) {
+  push(t2, true);
+  let n2 = prop(t2, "position", 3, "bottom-right"), i2 = prop(t2, "visible", 3, true);
+  var o2 = comment(), s2 = first_child(o2), consequent = (e3) => {
+    var i3 = $e();
+    i3.__click = [on_click$2, t2];
+    var o3 = child(i3);
+    !function Gamepad(e4, t3) {
+      const n3 = legacy_rest_props(t3, ["children", "$$slots", "$$events", "$$legacy"]);
+      Icon$1(e4, spread_props({
+        name: "gamepad"
+      }, () => n3, {
+        iconNode: [["line", {
+          x1: "6",
+          x2: "10",
+          y1: "12",
+          y2: "12"
+        }], ["line", {
+          x1: "8",
+          x2: "8",
+          y1: "10",
+          y2: "14"
+        }], ["line", {
+          x1: "15",
+          x2: "15.01",
+          y1: "13",
+          y2: "13"
+        }], ["line", {
+          x1: "18",
+          x2: "18.01",
+          y1: "11",
+          y2: "11"
+        }], ["rect", {
+          width: "20",
+          height: "12",
+          x: "2",
+          y: "6",
+          rx: "2"
+        }]],
+        children: (e5, n4) => {
+          var i4 = comment();
+          slot(first_child(i4), t3, "default", {}, null), append(e5, i4);
+        },
+        $$slots: {
+          default: true
+        }
+      }));
+    }(child(o3), {
+      size: 26,
+      strokeWidth: 1.75,
+      class: "z-2 mr-2 transform transition-all duration-300 group-hover:rotate-12"
+    }), template_effect(() => set_class(i3, 1, `fixed ${("bottom-left" == n2() ? "bottom-4 left-4" : "bottom-right" == n2() ? "right-4 bottom-4" : "") ?? ""} group children-text-white z-99990 flex cursor-pointer gap-2 rounded-md bg-white p-3 font-bold text-black uppercase shadow-lg transition-all hover:scale-105`, "svelte-1j97rta")), append(e3, i3);
+  };
+  if_block(s2, (e3) => {
+    i2() && e3(consequent);
+  }), append(e2, o2), pop();
+}
+function cubic_out(e2) {
+  const t2 = e2 - 1;
+  return t2 * t2 * t2 + 1;
+}
+function cubic_in_out(e2) {
+  return e2 < 0.5 ? 4 * e2 * e2 * e2 : 0.5 * Math.pow(2 * e2 - 2, 3) + 1;
+}
+function split_css_unit(e2) {
+  const t2 = "string" == typeof e2 && e2.match(/^\s*(-?[\d.]+)([^\s]*)\s*$/);
+  return t2 ? [parseFloat(t2[1]), t2[2] || "px"] : [
+    /** @type {number} */
+    e2,
+    "px"
+  ];
+}
+function blur(e2, { delay: t2 = 0, duration: n2 = 400, easing: i2 = cubic_in_out, amount: o2 = 5, opacity: s2 = 0 } = {}) {
+  const a2 = getComputedStyle(e2), l2 = +a2.opacity, c2 = "none" === a2.filter ? "" : a2.filter, u2 = l2 * (1 - s2), [d2, f2] = split_css_unit(o2);
+  return {
+    delay: t2,
+    duration: n2,
+    easing: i2,
+    css: (e3, t3) => `opacity: ${l2 - u2 * t3}; filter: ${c2} blur(${t3 * d2}${f2});`
+  };
+}
+function fly(e2, { delay: t2 = 0, duration: n2 = 400, easing: i2 = cubic_out, x: o2 = 0, y: s2 = 0, opacity: a2 = 0 } = {}) {
+  const l2 = getComputedStyle(e2), c2 = +l2.opacity, u2 = "none" === l2.transform ? "" : l2.transform, d2 = c2 * (1 - a2), [f2, p2] = split_css_unit(o2), [_2, v2] = split_css_unit(s2);
+  return {
+    delay: t2,
+    duration: n2,
+    easing: i2,
+    css: (e3, t3) => `
+			transform: ${u2} translate(${(1 - e3) * f2}${p2}, ${(1 - e3) * _2}${v2});
+			opacity: ${c2 - d2 * t3}`
+  };
+}
+function slide(e2, { delay: t2 = 0, duration: n2 = 400, easing: i2 = cubic_out, axis: o2 = "y" } = {}) {
+  const s2 = getComputedStyle(e2), a2 = +s2.opacity, l2 = "y" === o2 ? "height" : "width", c2 = parseFloat(s2[l2]), u2 = "y" === o2 ? ["top", "bottom"] : ["left", "right"], d2 = u2.map((e3) => (
+    /** @type {'Left' | 'Right' | 'Top' | 'Bottom'} */
+    `${e3[0].toUpperCase()}${e3.slice(1)}`
+  )), f2 = parseFloat(s2[`padding${d2[0]}`]), p2 = parseFloat(s2[`padding${d2[1]}`]), _2 = parseFloat(s2[`margin${d2[0]}`]), v2 = parseFloat(s2[`margin${d2[1]}`]), g2 = parseFloat(s2[`border${d2[0]}Width`]), h2 = parseFloat(s2[`border${d2[1]}Width`]);
+  return {
+    delay: t2,
+    duration: n2,
+    easing: i2,
+    css: (e3) => `overflow: hidden;opacity: ${Math.min(20 * e3, 1) * a2};${l2}: ${e3 * c2}px;padding-${u2[0]}: ${e3 * f2}px;padding-${u2[1]}: ${e3 * p2}px;margin-${u2[0]}: ${e3 * _2}px;margin-${u2[1]}: ${e3 * v2}px;border-${u2[0]}-width: ${e3 * g2}px;border-${u2[1]}-width: ${e3 * h2}px;min-${l2}: 0`
+  };
+}
+function scale(e2, { delay: t2 = 0, duration: n2 = 400, easing: i2 = cubic_out, start: o2 = 0, opacity: s2 = 0 } = {}) {
+  const a2 = getComputedStyle(e2), l2 = +a2.opacity, c2 = "none" === a2.transform ? "" : a2.transform, u2 = 1 - o2, d2 = l2 * (1 - s2);
+  return {
+    delay: t2,
+    duration: n2,
+    easing: i2,
+    css: (e3, t3) => `
+			transform: ${c2} scale(${1 - u2 * t3});
+			opacity: ${l2 - d2 * t3}
+		`
+  };
+}
+delegate(["click"]);
+var we = /* @__PURE__ */ ns_template('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" height="20" width="20"><path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm3.857-9.809a.75.75 0 00-1.214-.882l-3.483 4.79-1.88-1.88a.75.75 0 10-1.06 1.061l2.5 2.5a.75.75 0 001.137-.089l4-5.5z" clip-rule="evenodd"></path></svg>'), xe = /* @__PURE__ */ ns_template('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" height="20" width="20"><path fill-rule="evenodd" d="M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-8-5a.75.75 0 01.75.75v4.5a.75.75 0 01-1.5 0v-4.5A.75.75 0 0110 5zm0 10a1 1 0 100-2 1 1 0 000 2z" clip-rule="evenodd"></path></svg>'), ke = /* @__PURE__ */ ns_template('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" height="20" width="20"><path fill-rule="evenodd" d="M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-7-4a1 1 0 11-2 0 1 1 0 012 0zM9 9a.75.75 0 000 1.5h.253a.25.25 0 01.244.304l-.459 2.066A1.75 1.75 0 0010.747 15H11a.75.75 0 000-1.5h-.253a.25.25 0 01-.244-.304l.459-2.066A1.75 1.75 0 009.253 9H9z" clip-rule="evenodd"></path></svg>'), Ce = /* @__PURE__ */ ns_template('<svg viewBox="0 0 64 64" fill="currentColor" height="20" width="20" xmlns="http://www.w3.org/2000/svg"><path d="M32.427,7.987c2.183,0.124 4,1.165 5.096,3.281l17.936,36.208c1.739,3.66 -0.954,8.585 -5.373,8.656l-36.119,0c-4.022,-0.064 -7.322,-4.631 -5.352,-8.696l18.271,-36.207c0.342,-0.65 0.498,-0.838 0.793,-1.179c1.186,-1.375 2.483,-2.111 4.748,-2.063Zm-0.295,3.997c-0.687,0.034 -1.316,0.419 -1.659,1.017c-6.312,11.979 -12.397,24.081 -18.301,36.267c-0.546,1.225 0.391,2.797 1.762,2.863c12.06,0.195 24.125,0.195 36.185,0c1.325,-0.064 2.321,-1.584 1.769,-2.85c-5.793,-12.184 -11.765,-24.286 -17.966,-36.267c-0.366,-0.651 -0.903,-1.042 -1.79,-1.03Z"></path><path d="M33.631,40.581l-3.348,0l-0.368,-16.449l4.1,0l-0.384,16.449Zm-3.828,5.03c0,-0.609 0.197,-1.113 0.592,-1.514c0.396,-0.4 0.935,-0.601 1.618,-0.601c0.684,0 1.223,0.201 1.618,0.601c0.395,0.401 0.593,0.905 0.593,1.514c0,0.587 -0.193,1.078 -0.577,1.473c-0.385,0.395 -0.929,0.593 -1.634,0.593c-0.705,0 -1.249,-0.198 -1.634,-0.593c-0.384,-0.395 -0.576,-0.886 -0.576,-1.473Z"></path></svg>');
+function Icon(e2, t2) {
+  let n2 = prop(t2, "type", 8, "success");
+  var i2 = comment(), o2 = first_child(i2), consequent = (e3) => {
+    append(e3, we());
+  }, alternate_3 = (e3) => {
+    var t3 = comment(), i3 = first_child(t3), consequent_1 = (e4) => {
+      append(e4, xe());
+    }, alternate_2 = (e4) => {
+      var t4 = comment(), i4 = first_child(t4), consequent_2 = (e5) => {
+        append(e5, ke());
+      }, alternate_1 = (e5) => {
+        var t5 = comment(), i5 = first_child(t5), consequent_3 = (e6) => {
+          append(e6, Ce());
+        }, alternate = (e6) => {
+        };
+        if_block(i5, (e6) => {
+          "warning" === n2() ? e6(consequent_3) : e6(alternate, false);
+        }, true), append(e5, t5);
+      };
+      if_block(i4, (e5) => {
+        "info" === n2() ? e5(consequent_2) : e5(alternate_1, false);
+      }, true), append(e4, t4);
+    };
+    if_block(i3, (e4) => {
+      "error" === n2() ? e4(consequent_1) : e4(alternate_2, false);
+    }, true), append(e3, t3);
+  };
+  if_block(o2, (e3) => {
+    "success" === n2() ? e3(consequent) : e3(alternate_3, false);
+  }), append(e2, i2);
+}
+var Me = /* @__PURE__ */ template('<div class="sonner-loading-bar"></div>'), Se = /* @__PURE__ */ template('<div class="sonner-loading-wrapper"><div class="sonner-spinner"></div></div>');
+function Loader(e2, t2) {
+  push(t2, false);
+  let n2 = prop(t2, "visible", 8);
+  const i2 = Array(12).fill(0);
+  init();
+  var o2 = Se();
+  each(child(o2), 5, () => i2, index, (e3, t3) => {
+    append(e3, Me());
+  }), template_effect(() => set_attribute(o2, "data-visible", n2())), append(e2, o2), pop();
+}
+function cn(...e2) {
+  return e2.filter(Boolean).join(" ");
+}
+const Te = "undefined" != typeof document;
+function clientWritable(e2) {
+  const t2 = writable(e2);
+  return {
+    subscribe: t2.subscribe,
+    set: function set2(e3) {
+      Te && t2.set(e3);
+    },
+    update: function update2(e3) {
+      Te && t2.update(e3);
+    }
+  };
+}
+let qe = 0;
+const Ie = function createToastState() {
+  const e2 = clientWritable([]), t2 = clientWritable([]);
+  function addToast(t3) {
+    e2.update((e3) => [t3, ...e3]);
+  }
+  function create(t3) {
+    var _a;
+    const { message: n2, ...i2 } = t3, o2 = "number" == typeof (t3 == null ? void 0 : t3.id) || t3.id && ((_a = t3.id) == null ? void 0 : _a.length) > 0 ? t3.id : qe++, s2 = void 0 === t3.dismissable || t3.dismissable, a2 = void 0 === t3.type ? "default" : t3.type, l2 = get(e2).find((e3) => e3.id === o2);
+    return l2 ? e2.update((e3) => e3.map((e4) => e4.id === o2 ? {
+      ...e4,
+      ...t3,
+      id: o2,
+      title: n2,
+      dismissable: s2,
+      type: a2,
+      updated: true
+    } : {
+      ...e4,
+      updated: false
+    })) : addToast({
+      ...i2,
+      id: o2,
+      title: n2,
+      dismissable: s2,
+      type: a2
+    }), o2;
+  }
+  function dismiss(t3) {
+    if (void 0 !== t3) return e2.update((e3) => e3.map((e4) => e4.id === t3 ? {
+      ...e4,
+      dismiss: true
+    } : e4)), t3;
+    e2.update((e3) => e3.map((e4) => ({
+      ...e4,
+      dismiss: true
+    })));
+  }
+  return {
+    // methods
+    create,
+    addToast,
+    dismiss,
+    remove: function remove(t3) {
+      if (void 0 !== t3) return e2.update((e3) => e3.filter((e4) => e4.id !== t3)), t3;
+      e2.set([]);
+    },
+    message: function message(e3, t3) {
+      return create({
+        ...t3,
+        type: "default",
+        message: e3
+      });
+    },
+    error: function error(e3, t3) {
+      return create({
+        ...t3,
+        type: "error",
+        message: e3
+      });
+    },
+    success: function success(e3, t3) {
+      return create({
+        ...t3,
+        type: "success",
+        message: e3
+      });
+    },
+    info: function info(e3, t3) {
+      return create({
+        ...t3,
+        type: "info",
+        message: e3
+      });
+    },
+    warning: function warning(e3, t3) {
+      return create({
+        ...t3,
+        type: "warning",
+        message: e3
+      });
+    },
+    loading: function loading(e3, t3) {
+      return create({
+        ...t3,
+        type: "loading",
+        message: e3
+      });
+    },
+    promise: function promise(e3, t3) {
+      if (!t3)
+        return;
+      let n2;
+      void 0 !== t3.loading && (n2 = create({
+        ...t3,
+        promise: e3,
+        type: "loading",
+        message: t3.loading
+      }));
+      const i2 = e3 instanceof Promise ? e3 : e3();
+      let o2 = void 0 !== n2;
+      return i2.then((e4) => {
+        if (e4 && "boolean" == typeof e4.ok && !e4.ok) {
+          o2 = false;
+          const i3 = "function" == typeof t3.error ? (
+            // @ts-expect-error: Incorrect response type
+            t3.error(`HTTP error! status: ${e4.status}`)
+          ) : t3.error;
+          create({
+            id: n2,
+            type: "error",
+            message: i3
+          });
+        } else if (void 0 !== t3.success) {
+          o2 = false;
+          const i3 = (
+            // @ts-expect-error: TODO: Better function checking
+            "function" == typeof t3.success ? t3.success(e4) : t3.success
+          );
+          create({
+            id: n2,
+            type: "success",
+            message: i3
+          });
+        }
+      }).catch((e4) => {
+        if (void 0 !== t3.error) {
+          o2 = false;
+          const i3 = (
+            // @ts-expect-error: TODO: Better function checking
+            "function" == typeof t3.error ? t3.error(e4) : t3.error
+          );
+          create({
+            id: n2,
+            type: "error",
+            message: i3
+          });
+        }
+      }).finally(() => {
+        var _a;
+        o2 && // Toast is still in load state (and will be indefinitely — dismiss it)
+        (dismiss(n2), n2 = void 0), (_a = t3.finally) == null ? void 0 : _a.call(t3);
+      }), n2;
+    },
+    custom: function custom(e3, t3) {
+      const n2 = (t3 == null ? void 0 : t3.id) || qe++;
+      return create({
+        component: e3,
+        id: n2,
+        ...t3
+      }), n2;
+    },
+    removeHeight: function removeHeight(e3) {
+      t2.update((t3) => t3.filter((t4) => t4.toastId !== e3));
+    },
+    setHeight: function setHeight(e3) {
+      void 0 !== get(t2).find((t3) => t3.toastId === e3.toastId) ? t2.update((t3) => t3.map((t4) => t4.toastId === e3.toastId ? e3 : t4)) : t2.update((t3) => [e3, ...t3]);
+    },
+    reset: function reset() {
+      e2.set([]), t2.set([]);
+    },
+    // stores
+    toasts: e2,
+    heights: t2
+  };
+}();
+const Pe = function toastFunction(e2, t2) {
+  return Ie.create({
+    message: e2,
+    ...t2
+  });
+}, Oe = Object.assign(Pe, {
+  success: Ie.success,
+  info: Ie.info,
+  warning: Ie.warning,
+  error: Ie.error,
+  custom: Ie.custom,
+  message: Ie.message,
+  promise: Ie.promise,
+  dismiss: Ie.dismiss,
+  loading: Ie.loading
+});
+var Ee = /* @__PURE__ */ template('<button aria-label="Close toast" data-close-button=""><svg xmlns="http://www.w3.org/2000/svg" width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg></button>'), je = /* @__PURE__ */ template('<div data-icon=""><!> <!></div>'), Ne = /* @__PURE__ */ template('<div data-title=""><!></div>'), Be = /* @__PURE__ */ template('<div data-description=""><!></div>'), ze = /* @__PURE__ */ template('<button data-button="" data-cancel=""> </button>'), De = /* @__PURE__ */ template('<button data-button=""> </button>'), Ae = /* @__PURE__ */ template('<!> <div data-content=""><!> <!></div> <!> <!>', 1), Le = /* @__PURE__ */ template('<li aria-atomic="true" role="status" data-sonner-toast=""><!> <!></li>');
+function Toast(e2, t2) {
+  const n2 = legacy_rest_props(t2, ["children", "$$slots", "$$events", "$$legacy"]);
+  push(t2, false);
+  const [i2, o2] = setup_stores(), $heights = () => store_get(y2, "$heights", i2), $effect = () => store_get(get$1(Q2), "$effect", i2), s2 = mutable_state(void 0, true), a2 = mutable_state(void 0, true), l2 = mutable_state(void 0, true), c2 = mutable_state(void 0, true), u2 = mutable_state(void 0, true), d2 = mutable_state(void 0, true), f2 = mutable_state(void 0, true), p2 = mutable_state(void 0, true), _2 = mutable_state(void 0, true), v2 = mutable_state(void 0, true), g2 = mutable_state(void 0, true), h2 = mutable_state(void 0, true), m2 = {
+    toast: "",
+    title: "",
+    description: "",
+    loader: "",
+    closeButton: "",
+    cancelButton: "",
+    actionButton: "",
+    action: "",
+    warning: "",
+    error: "",
+    success: "",
+    default: "",
+    info: "",
+    loading: ""
+  }, { toasts: b2, heights: y2, removeHeight: $2, setHeight: w2, remove: x2 } = Ie;
+  let k2 = prop(t2, "toast", 9), C2 = prop(t2, "index", 9), M2 = prop(t2, "expanded", 9), S2 = prop(t2, "invert", 13), T2 = prop(t2, "position", 9), q2 = prop(t2, "visibleToasts", 9), I2 = prop(t2, "expandByDefault", 9), P2 = prop(t2, "closeButton", 9), O2 = prop(t2, "interacting", 9), E2 = prop(t2, "cancelButtonStyle", 9, ""), j2 = prop(t2, "actionButtonStyle", 9, ""), N2 = prop(t2, "duration", 9, 4e3), B2 = prop(t2, "descriptionClass", 9, ""), z2 = prop(t2, "classes", 29, () => ({})), D2 = prop(t2, "unstyled", 9, false), A2 = mutable_state(false, true), L2 = mutable_state(false, true), W2 = mutable_state(false, true), F2 = mutable_state(false, true), G2 = mutable_state(0, true), H2 = mutable_state(0, true), R2 = mutable_state(void 0, true), V2 = mutable_state(0, true), K2 = 0, U2 = 0, Z2 = null;
+  function deleteToast() {
+    set(L2, true), // Save the offset for the exit swipe animation
+    set(G2, get$1(V2)), $2(k2().id), setTimeout(() => {
+      x2(k2().id);
+    }, 200);
+  }
+  let Y2 = mutable_state(void 0, true), J2 = mutable_state(k2().duration || N2() || 4e3, true);
+  function startTimer() {
+    K2 = (/* @__PURE__ */ new Date()).getTime(), // Let the toast know it has started
+    set(Y2, setTimeout(() => {
+      var _a, _b;
+      (_b = (_a = k2()).onAutoClose) == null ? void 0 : _b.call(_a, k2()), deleteToast();
+    }, get$1(J2)));
+  }
+  let Q2 = mutable_state(void 0, true);
+  onMount(() => {
+    set(A2, true);
+    const e3 = get$1(R2).getBoundingClientRect().height;
+    return set(H2, e3), w2({
+      toastId: k2().id,
+      height: e3
+    }), () => $2(k2().id);
+  }), legacy_pre_effect(() => deep_read_state(z2()), () => {
+    z2({
+      ...m2,
+      ...z2()
+    });
+  }), legacy_pre_effect(() => deep_read_state(C2()), () => {
+    set(s2, 0 === C2());
+  }), legacy_pre_effect(() => (deep_read_state(C2()), deep_read_state(q2())), () => {
+    set(a2, C2() + 1 <= q2());
+  }), legacy_pre_effect(() => deep_read_state(k2()), () => {
+    set(l2, k2().title);
+  }), legacy_pre_effect(() => deep_read_state(k2()), () => {
+    set(c2, k2().description);
+  }), legacy_pre_effect(() => deep_read_state(k2()), () => {
+    set(u2, k2().type);
+  }), legacy_pre_effect(() => deep_read_state(k2()), () => {
+    set(d2, k2().class || "");
+  }), legacy_pre_effect(() => deep_read_state(k2()), () => {
+    set(f2, k2().descriptionClass || "");
+  }), legacy_pre_effect(() => ($heights(), deep_read_state(k2())), () => {
+    set(p2, $heights().findIndex((e3) => e3.toastId === k2().id) || 0);
+  }), legacy_pre_effect(() => deep_read_state(T2()), () => {
+    set(_2, T2().split("-"));
+  }), legacy_pre_effect(() => ($heights(), get$1(p2)), () => {
+    set(v2, $heights().reduce((e3, t3, n3) => (
+      // Calculate offset up untill current  toast
+      n3 >= get$1(p2) ? e3 : e3 + t3.height
+    ), 0));
+  }), legacy_pre_effect(() => (deep_read_state(S2()), deep_read_state(k2())), () => {
+    S2(k2().invert || S2());
+  }), legacy_pre_effect(() => get$1(u2), () => {
+    set(g2, "loading" === get$1(u2));
+  }), legacy_pre_effect(() => (get$1(p2), get$1(v2)), () => {
+    set(V2, Math.round(14 * get$1(p2) + get$1(v2)));
+  }), legacy_pre_effect(() => (get$1(l2), get$1(c2)), () => {
+    get$1(l2), get$1(c2), // Listen to height changes
+    async function updateHeights() {
+      if (!get$1(A2)) return;
+      let e3;
+      await tick(), e3 = M2() || I2() ? 1 : 1 - 0.05 * C2(), get$1(R2).style.setProperty("height", "auto");
+      const t3 = get$1(R2).offsetHeight, n3 = get$1(R2).getBoundingClientRect().height, i3 = Math.round(100 * (n3 / e3 + Number.EPSILON)) / 100;
+      let o3;
+      get$1(R2).style.removeProperty("height"), // Use scaledRectHeight as it's more precise
+      o3 = Math.abs(i3 - t3) < 1 ? i3 : t3, set(H2, o3), w2({
+        toastId: k2().id,
+        height: o3
+      });
+    }();
+  }), legacy_pre_effect(() => (deep_read_state(k2()), get$1(Y2), deep_read_state(N2())), () => {
+    k2().updated && // if the toast has been updated after the initial render,
+    // we want to reset the timer and set the remaining time to the
+    // new duration
+    (clearTimeout(get$1(Y2)), set(J2, k2().duration || N2() || 4e3), startTimer());
+  }), legacy_pre_effect(() => (deep_read_state(k2()), get$1(u2)), () => {
+    set(h2, k2().promise && "loading" === get$1(u2) || k2().duration === Number.POSITIVE_INFINITY);
+  }), legacy_pre_effect(() => (get$1(h2), deep_read_state(M2()), deep_read_state(O2()), get$1(Y2)), () => {
+    var e3;
+    !function store_unsub(e4, t3, n3) {
+      let i3 = n3[t3];
+      return i3 && i3.store !== e4 && // Don't reset store yet, so that store_get above can resubscribe to new store if necessary
+      (i3.unsubscribe(), i3.unsubscribe = noop), e4;
+    }(set(Q2, (e3 = () => (get$1(h2) || (M2() || O2() ? (
+      // If toast's duration changes, it will be out of sync with the
+      // remainingAtTimeout, so we know we need to restart the timer
+      // with the new duration
+      // Pause the tmer on each hover
+      function pauseTimer() {
+        if (U2 < K2) {
+          const e4 = (/* @__PURE__ */ new Date()).getTime() - K2;
+          set(J2, get$1(J2) - e4);
+        }
+        U2 = (/* @__PURE__ */ new Date()).getTime();
+      }()
+    ) : startTimer()), () => clearTimeout(get$1(Y2))), {
+      subscribe: e3
+    })), "$effect", i2);
+  }), legacy_pre_effect(() => $effect(), () => {
+    $effect();
+  }), legacy_pre_effect(() => deep_read_state(k2()), () => {
+    k2().delete && deleteToast();
+  }), legacy_pre_effect_reset(), init(true);
+  var ee2 = Le();
+  set_attribute(ee2, "tabindex", 0);
+  var te2 = child(ee2), consequent = (e3) => {
+    var t3 = Ee();
+    template_effect((e4) => {
+      set_attribute(t3, "data-disabled", get$1(g2)), set_class(t3, 1, clsx(e4));
+    }, [() => {
+      var _a, _b, _c;
+      return cn((_a = z2()) == null ? void 0 : _a.closeButton, (_c = (_b = k2()) == null ? void 0 : _b.classes) == null ? void 0 : _c.closeButton);
+    }], derived_safe_equal), event("click", t3, function(...e4) {
+      var _a;
+      (_a = get$1(g2) ? void 0 : () => {
+        var _a2, _b;
+        deleteToast(), (_b = (_a2 = k2()).onDismiss) == null ? void 0 : _b.call(_a2, k2());
+      }) == null ? void 0 : _a.apply(this, e4);
+    }), append(e3, t3);
+  };
+  if_block(te2, (e3) => {
+    P2() && !k2().component && e3(consequent);
+  });
+  var ne2 = sibling(te2, 2), consequent_1 = (e3) => {
+    var t3 = comment();
+    component(first_child(t3), () => k2().component, (e4, t4) => {
+      t4(e4, spread_props(() => k2().componentProps, {
+        $$events: {
+          closeToast: deleteToast
+        }
+      }));
+    }), append(e3, t3);
+  }, alternate_6 = (e3) => {
+    var n3 = Ae(), i3 = first_child(n3), consequent_8 = (e4) => {
+      var n4 = je(), i4 = child(n4), consequent_2 = (e5) => {
+        var n5 = comment();
+        slot(first_child(n5), t2, "loading-icon", {}, null), append(e5, n5);
+      };
+      if_block(i4, (e5) => {
+        !k2().promise && "loading" !== get$1(u2) || k2().icon || e5(consequent_2);
+      });
+      var o4 = sibling(i4, 2), consequent_3 = (e5) => {
+        var t3 = comment();
+        component(first_child(t3), () => k2().icon, (e6, t4) => {
+          t4(e6, {});
+        }), append(e5, t3);
+      }, alternate_3 = (e5) => {
+        var n5 = comment(), i5 = first_child(n5), consequent_4 = (e6) => {
+          var n6 = comment();
+          slot(first_child(n6), t2, "success-icon", {}, null), append(e6, n6);
+        }, alternate_2 = (e6) => {
+          var n6 = comment(), i6 = first_child(n6), consequent_5 = (e7) => {
+            var n7 = comment();
+            slot(first_child(n7), t2, "error-icon", {}, null), append(e7, n7);
+          }, alternate_1 = (e7) => {
+            var n7 = comment(), i7 = first_child(n7), consequent_6 = (e8) => {
+              var n8 = comment();
+              slot(first_child(n8), t2, "warning-icon", {}, null), append(e8, n8);
+            }, alternate = (e8) => {
+              var n8 = comment(), i8 = first_child(n8), consequent_7 = (e9) => {
+                var n9 = comment();
+                slot(first_child(n9), t2, "info-icon", {}, null), append(e9, n9);
+              };
+              if_block(i8, (e9) => {
+                "info" === get$1(u2) && e9(consequent_7);
+              }, true), append(e8, n8);
+            };
+            if_block(i7, (e8) => {
+              "warning" === get$1(u2) ? e8(consequent_6) : e8(alternate, false);
+            }, true), append(e7, n7);
+          };
+          if_block(i6, (e7) => {
+            "error" === get$1(u2) ? e7(consequent_5) : e7(alternate_1, false);
+          }, true), append(e6, n6);
+        };
+        if_block(i5, (e6) => {
+          "success" === get$1(u2) ? e6(consequent_4) : e6(alternate_2, false);
+        }, true), append(e5, n5);
+      };
+      if_block(o4, (e5) => {
+        k2().icon ? e5(consequent_3) : e5(alternate_3, false);
+      }), append(e4, n4);
+    };
+    if_block(i3, (e4) => {
+      ("default" !== get$1(u2) || k2().icon || k2().promise) && e4(consequent_8);
+    });
+    var o3 = sibling(i3, 2), s3 = child(o3), consequent_10 = (e4) => {
+      var t3 = Ne(), n4 = child(t3), consequent_9 = (e5) => {
+        var t4 = comment();
+        component(first_child(t4), () => k2().title, (e6, t5) => {
+          t5(e6, spread_props(() => k2().componentProps));
+        }), append(e5, t4);
+      }, alternate_4 = (e5) => {
+        var t4 = text();
+        template_effect(() => set_text(t4, k2().title)), append(e5, t4);
+      };
+      if_block(n4, (e5) => {
+        "string" != typeof k2().title ? e5(consequent_9) : e5(alternate_4, false);
+      }), template_effect((e5) => set_class(t3, 1, clsx(e5)), [() => {
+        var _a, _b, _c;
+        return cn((_a = z2()) == null ? void 0 : _a.title, (_c = (_b = k2()) == null ? void 0 : _b.classes) == null ? void 0 : _c.title);
+      }], derived_safe_equal), append(e4, t3);
+    };
+    if_block(s3, (e4) => {
+      k2().title && e4(consequent_10);
+    });
+    var a3 = sibling(s3, 2), consequent_12 = (e4) => {
+      var t3 = Be(), n4 = child(t3), consequent_11 = (e5) => {
+        var t4 = comment();
+        component(first_child(t4), () => k2().description, (e6, t5) => {
+          t5(e6, spread_props(() => k2().componentProps));
+        }), append(e5, t4);
+      }, alternate_5 = (e5) => {
+        var t4 = text();
+        template_effect(() => set_text(t4, k2().description)), append(e5, t4);
+      };
+      if_block(n4, (e5) => {
+        "string" != typeof k2().description ? e5(consequent_11) : e5(alternate_5, false);
+      }), template_effect((e5) => set_class(t3, 1, clsx(e5)), [() => {
+        var _a, _b;
+        return cn(B2(), get$1(f2), (_a = z2()) == null ? void 0 : _a.description, (_b = k2().classes) == null ? void 0 : _b.description);
+      }], derived_safe_equal), append(e4, t3);
+    };
+    if_block(a3, (e4) => {
+      k2().description && e4(consequent_12);
+    });
+    var l3 = sibling(o3, 2), consequent_13 = (e4) => {
+      var t3 = ze(), n4 = child(t3);
+      template_effect((e5) => {
+        set_attribute(t3, "style", E2()), set_class(t3, 1, clsx(e5)), set_text(n4, k2().cancel.label);
+      }, [() => {
+        var _a, _b, _c;
+        return cn((_a = z2()) == null ? void 0 : _a.cancelButton, (_c = (_b = k2()) == null ? void 0 : _b.classes) == null ? void 0 : _c.cancelButton);
+      }], derived_safe_equal), event("click", t3, () => {
+        var _a;
+        deleteToast(), ((_a = k2().cancel) == null ? void 0 : _a.onClick) && k2().cancel.onClick();
+      }), append(e4, t3);
+    };
+    if_block(l3, (e4) => {
+      k2().cancel && e4(consequent_13);
+    });
+    var c3 = sibling(l3, 2), consequent_14 = (e4) => {
+      var t3 = De(), n4 = child(t3);
+      template_effect((e5) => {
+        set_attribute(t3, "style", j2()), set_class(t3, 1, clsx(e5)), set_text(n4, k2().action.label);
+      }, [() => {
+        var _a, _b, _c;
+        return cn((_a = z2()) == null ? void 0 : _a.actionButton, (_c = (_b = k2()) == null ? void 0 : _b.classes) == null ? void 0 : _c.actionButton);
+      }], derived_safe_equal), event("click", t3, (e5) => {
+        var _a;
+        (_a = k2().action) == null ? void 0 : _a.onClick(e5), e5.defaultPrevented || deleteToast();
+      }), append(e4, t3);
+    };
+    if_block(c3, (e4) => {
+      k2().action && e4(consequent_14);
+    }), append(e3, n3);
+  };
+  if_block(ne2, (e3) => {
+    k2().component ? e3(consequent_1) : e3(alternate_6, false);
+  }), bind_this(ee2, (e3) => set(R2, e3), () => get$1(R2)), template_effect((e3, t3, o3) => {
+    var _a;
+    set_attribute(ee2, "aria-live", k2().important ? "assertive" : "polite"), set_class(ee2, 1, clsx(e3)), set_attribute(ee2, "data-styled", !(k2().component || ((_a = k2()) == null ? void 0 : _a.unstyled) || D2())), set_attribute(ee2, "data-mounted", get$1(A2)), set_attribute(ee2, "data-promise", t3), set_attribute(ee2, "data-removed", get$1(L2)), set_attribute(ee2, "data-visible", get$1(a2)), set_attribute(ee2, "data-y-position", get$1(_2)[0]), set_attribute(ee2, "data-x-position", get$1(_2)[1]), set_attribute(ee2, "data-index", C2()), set_attribute(ee2, "data-front", get$1(s2)), set_attribute(ee2, "data-swiping", get$1(W2)), set_attribute(ee2, "data-type", get$1(u2)), set_attribute(ee2, "data-invert", S2()), set_attribute(ee2, "data-swipe-out", get$1(F2)), set_attribute(ee2, "data-expanded", o3), set_attribute(ee2, "style", `${n2.style} ${k2().style}`), set_style(ee2, "--index", C2()), set_style(ee2, "--toasts-before", C2()), set_style(ee2, "--z-index", store_get(b2, "$toasts", i2).length - C2()), set_style(ee2, "--offset", `${get$1(L2) ? get$1(G2) : get$1(V2)}px`), set_style(ee2, "--initial-height", `${get$1(H2)}px`);
+  }, [() => {
+    var _a, _b, _c, _d, _e2, _f;
+    return cn(n2.class, get$1(d2), (_a = z2()) == null ? void 0 : _a.toast, (_c = (_b = k2()) == null ? void 0 : _b.classes) == null ? void 0 : _c.toast, (_d = z2()) == null ? void 0 : _d[get$1(u2)], (_f = (_e2 = k2()) == null ? void 0 : _e2.classes) == null ? void 0 : _f[get$1(u2)]);
+  }, () => Boolean(k2().promise), () => Boolean(M2() || I2() && get$1(A2))], derived_safe_equal), event("pointerdown", ee2, function onPointerDown(e3) {
+    if (get$1(g2)) return;
+    set(G2, get$1(V2));
+    const t3 = e3.target;
+    t3.setPointerCapture(e3.pointerId), "BUTTON" !== t3.tagName && (set(W2, true), Z2 = {
+      x: e3.clientX,
+      y: e3.clientY
+    });
+  }), event("pointerup", ee2, function onPointerUp() {
+    var _a, _b, _c;
+    if (get$1(F2)) return;
+    Z2 = null;
+    const e3 = Number(((_a = get$1(R2)) == null ? void 0 : _a.style.getPropertyValue("--swipe-amount").replace("px", "")) || 0);
+    if (Math.abs(e3) >= 20) return set(G2, get$1(V2)), (_c = (_b = k2()).onDismiss) == null ? void 0 : _c.call(_b, k2()), deleteToast(), void set(F2, true);
+    get$1(R2).style.setProperty("--swipe-amount", "0px"), set(W2, false);
+  }), event("pointermove", ee2, function onPointerMove(e3) {
+    if (!Z2) return;
+    const t3 = e3.clientY - Z2.y, n3 = e3.clientX - Z2.x, i3 = ("top" === get$1(_2)[0] ? Math.min : Math.max)(0, t3), o3 = "touch" === e3.pointerType ? 10 : 2;
+    Math.abs(i3) > o3 ? get$1(R2).style.setProperty("--swipe-amount", `${t3}px`) : Math.abs(n3) > o3 && // User is swiping in wrong direction so we disable swipe gesture
+    // for the current pointer down interaction
+    (Z2 = null);
+  }), append(e2, ee2), pop(), o2();
+}
+var We = /* @__PURE__ */ template("<ol></ol>"), Fe = /* @__PURE__ */ template('<section class="svelte-1fo5d1m"></section>');
+function Toaster(e2, t2) {
+  const n2 = legacy_rest_props(t2, ["children", "$$slots", "$$events", "$$legacy"]), i2 = legacy_rest_props(n2, ["invert", "theme", "position", "hotkey", "containerAriaLabel", "richColors", "expand", "duration", "visibleToasts", "closeButton", "toastOptions", "offset", "dir"]);
+  push(t2, false);
+  const [o2, s2] = setup_stores(), $toasts = () => store_get(k2, "$toasts", o2), a2 = mutable_state(), l2 = mutable_state(), c2 = "dark", u2 = "light";
+  function getDocumentDirection() {
+    if ("undefined" == typeof window) return "ltr";
+    if ("undefined" == typeof document) return "ltr";
+    const e3 = document.documentElement.getAttribute("dir");
+    return "auto" !== e3 && e3 ? e3 : window.getComputedStyle(document.documentElement).direction;
+  }
+  let d2 = prop(t2, "invert", 8, false), f2 = prop(t2, "theme", 8, "light"), p2 = prop(t2, "position", 8, "bottom-right"), _2 = prop(t2, "hotkey", 24, () => ["altKey", "KeyT"]), v2 = prop(t2, "containerAriaLabel", 8, "Notifications"), g2 = prop(t2, "richColors", 8, false), h2 = prop(t2, "expand", 8, false), m2 = prop(t2, "duration", 8, 4e3), b2 = prop(t2, "visibleToasts", 8, 3), y2 = prop(t2, "closeButton", 8, false), $2 = prop(t2, "toastOptions", 24, () => ({})), w2 = prop(t2, "offset", 8, null), x2 = prop(t2, "dir", 24, getDocumentDirection);
+  const { toasts: k2, heights: C2, reset: M2 } = Ie;
+  let S2 = mutable_state(false), q2 = mutable_state(false), I2 = mutable_state(function getInitialTheme(e3) {
+    return "system" !== e3 ? e3 : "undefined" != typeof window && window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches ? c2 : u2;
+  }(f2())), P2 = mutable_state(), O2 = null, E2 = false;
+  function handleBlur(e3) {
+    E2 && !e3.currentTarget.contains(e3.relatedTarget) && (E2 = false, O2 && (O2.focus({
+      preventScroll: true
+    }), O2 = null));
+  }
+  function handleFocus(e3) {
+    E2 || (E2 = true, O2 = e3.relatedTarget);
+  }
+  !function onDestroy(e3) {
+    null === T && lifecycle_outside_component(), onMount(() => () => untrack(e3));
+  }(() => {
+    get$1(P2) && O2 && (O2.focus({
+      preventScroll: true
+    }), O2 = null, E2 = false);
+  }), onMount(() => {
+    M2();
+    const handleKeydown = (e3) => {
+      var _a, _b;
+      _2().every((t3) => (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        e3[t3] || e3.code === t3
+      )) && (set(S2, true), (_a = get$1(P2)) == null ? void 0 : _a.focus()), "Escape" !== e3.code || document.activeElement !== get$1(P2) && !((_b = get$1(P2)) == null ? void 0 : _b.contains(document.activeElement)) || set(S2, false);
+    };
+    return document.addEventListener("keydown", handleKeydown), () => {
+      document.removeEventListener("keydown", handleKeydown);
+    };
+  }), legacy_pre_effect(() => (deep_read_state(p2()), $toasts()), () => {
+    set(a2, Array.from(new Set([p2(), ...$toasts().filter((e3) => e3.position).map((e3) => e3.position)].filter(Boolean))));
+  }), legacy_pre_effect(() => deep_read_state(_2()), () => {
+    set(l2, _2().join("+").replace(/Key/g, "").replace(/Digit/g, ""));
+  }), legacy_pre_effect(() => $toasts(), () => {
+    $toasts().length <= 1 && set(S2, false);
+  }), legacy_pre_effect(() => $toasts(), () => {
+    const e3 = $toasts().filter((e4) => e4.dismiss && !e4.delete);
+    if (e3.length > 0) {
+      const t3 = $toasts().map((t4) => e3.find((e4) => e4.id === t4.id) ? {
+        ...t4,
+        delete: true
+      } : t4);
+      k2.set(t3);
+    }
+  }), legacy_pre_effect(() => deep_read_state(f2()), () => {
+    if ("system" !== f2() && set(I2, f2()), "undefined" != typeof window) {
+      "system" === f2() && // check if current preference is dark
+      (window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches ? (
+        // it's currently dark
+        set(I2, c2)
+      ) : (
+        // it's not dark
+        set(I2, u2)
+      ));
+      const e3 = window.matchMedia("(prefers-color-scheme: dark)"), changeHandler = ({ matches: e4 }) => {
+        set(I2, e4 ? c2 : u2);
+      };
+      "addEventListener" in e3 ? e3.addEventListener("change", changeHandler) : (
+        // @ts-expect-error deprecated API
+        e3.addListener(changeHandler)
+      );
+    }
+  }), legacy_pre_effect_reset(), init();
+  var j2 = comment(), N2 = first_child(j2), consequent = (e3) => {
+    var s3 = Fe();
+    set_attribute(s3, "tabindex", -1), each(s3, 5, () => get$1(a2), index, (e4, s4, a3, l3) => {
+      var c3 = We();
+      let u3;
+      each(c3, 7, () => $toasts().filter((e5) => !e5.position && 0 === a3 || e5.position === get$1(s4)), (e5) => e5.id, (e5, n3, i3, o3) => {
+        const a4 = /* @__PURE__ */ derived_safe_equal(() => {
+          var _a;
+          return ((_a = $2()) == null ? void 0 : _a.actionButtonStyle) || "";
+        }), l4 = /* @__PURE__ */ derived_safe_equal(() => {
+          var _a;
+          return ((_a = $2()) == null ? void 0 : _a.cancelButtonStyle) || "";
+        }), c4 = /* @__PURE__ */ derived_safe_equal(() => {
+          var _a;
+          return ((_a = $2()) == null ? void 0 : _a.class) || "";
+        }), u4 = /* @__PURE__ */ derived_safe_equal(() => {
+          var _a;
+          return ((_a = $2()) == null ? void 0 : _a.descriptionClass) || "";
+        }), f3 = /* @__PURE__ */ derived_safe_equal(() => $2().classes || {}), p3 = /* @__PURE__ */ derived_safe_equal(() => {
+          var _a;
+          return ((_a = $2()) == null ? void 0 : _a.duration) ?? m2();
+        }), _3 = /* @__PURE__ */ derived_safe_equal(() => $2().unstyled || false);
+        Toast(e5, {
+          get index() {
+            return get$1(i3);
+          },
+          get toast() {
+            return get$1(n3);
+          },
+          get invert() {
+            return d2();
+          },
+          get visibleToasts() {
+            return b2();
+          },
+          get closeButton() {
+            return y2();
+          },
+          get interacting() {
+            return get$1(q2);
+          },
+          get position() {
+            return get$1(s4);
+          },
+          get expandByDefault() {
+            return h2();
+          },
+          get expanded() {
+            return get$1(S2);
+          },
+          get actionButtonStyle() {
+            return get$1(a4);
+          },
+          get cancelButtonStyle() {
+            return get$1(l4);
+          },
+          get class() {
+            return get$1(c4);
+          },
+          get descriptionClass() {
+            return get$1(u4);
+          },
+          get classes() {
+            return get$1(f3);
+          },
+          get duration() {
+            return get$1(p3);
+          },
+          get unstyled() {
+            return get$1(_3);
+          },
+          $$slots: {
+            "loading-icon": (e6, i4) => {
+              var o4 = comment();
+              slot(first_child(o4), t2, "loading-icon", {}, (e7) => {
+                const t3 = /* @__PURE__ */ derived_safe_equal(() => "loading" === get$1(n3).type);
+                Loader(e7, {
+                  get visible() {
+                    return get$1(t3);
+                  }
+                });
+              }), append(e6, o4);
+            },
+            "success-icon": (e6, n4) => {
+              var i4 = comment();
+              slot(first_child(i4), t2, "success-icon", {}, (e7) => {
+                Icon(e7, {
+                  type: "success"
+                });
+              }), append(e6, i4);
+            },
+            "error-icon": (e6, n4) => {
+              var i4 = comment();
+              slot(first_child(i4), t2, "error-icon", {}, (e7) => {
+                Icon(e7, {
+                  type: "error"
+                });
+              }), append(e6, i4);
+            },
+            "warning-icon": (e6, n4) => {
+              var i4 = comment();
+              slot(first_child(i4), t2, "warning-icon", {}, (e7) => {
+                Icon(e7, {
+                  type: "warning"
+                });
+              }), append(e6, i4);
+            },
+            "info-icon": (e6, n4) => {
+              var i4 = comment();
+              slot(first_child(i4), t2, "info-icon", {}, (e7) => {
+                Icon(e7, {
+                  type: "info"
+                });
+              }), append(e6, i4);
+            }
+          }
+        });
+      }), bind_this(c3, (e5) => set(P2, e5), () => get$1(P2)), template_effect((e5, t3, s5) => {
+        var _a;
+        u3 = set_attributes(c3, u3, {
+          tabIndex: -1,
+          class: n2.class,
+          "data-sonner-toaster": true,
+          "data-theme": get$1(I2),
+          "data-rich-colors": g2(),
+          dir: e5,
+          "data-y-position": t3,
+          "data-x-position": s5,
+          style: n2.style,
+          ...i2
+        }, "svelte-1fo5d1m"), set_style(c3, "--front-toast-height", `${(_a = store_get(C2, "$heights", o2)[0]) == null ? void 0 : _a.height}px`), set_style(c3, "--offset", "number" == typeof w2() ? `${w2()}px` : w2() || "32px"), set_style(c3, "--width", "356px"), set_style(c3, "--gap", "14px"), c3.dir = c3.dir;
+      }, [() => "auto" === x2() ? getDocumentDirection() : x2(), () => get$1(s4).split("-")[0], () => get$1(s4).split("-")[1]], derived_safe_equal), event("blur", c3, handleBlur), event("focus", c3, handleFocus), event("mouseenter", c3, () => set(S2, true)), event("mousemove", c3, () => set(S2, true)), event("mouseleave", c3, () => {
+        get$1(q2) || set(S2, false);
+      }), event("pointerdown", c3, () => set(q2, true)), event("pointerup", c3, () => set(q2, false)), append(e4, c3);
+    }), template_effect(() => set_attribute(s3, "aria-label", `${v2()} ${get$1(l2)}`)), append(e3, s3);
+  };
+  if_block(N2, (e3) => {
+    $toasts().length > 0 && e3(consequent);
+  }), append(e2, j2), pop(), s2();
+}
+const Ge = writable(false), He = writable("https://sdk.playlight.dev");
+function handleClick(e2, t2) {
+  var _a;
+  (_a = t2.onClick) == null ? void 0 : _a.call(t2, t2.game.id), window.open("https://" + t2.game.domain, "_blank", "noopener");
+}
+var Re = /* @__PURE__ */ template('<div><p class="uppercase">New</p></div>'), Ve = /* @__PURE__ */ template('<video playsinline="" loop preload="auto"></video>', 2), Ke = /* @__PURE__ */ template('<div id="overlay" class="bg-background/75 text-foreground absolute right-0 bottom-0 left-0 z-11 flex max-h-1/3 flex-col overflow-hidden backdrop-blur-xl"><div class="hide-scrollbar h-full w-full overflow-y-auto p-3 svelte-styo3v"><h3 class="mb-2 truncate text-center text-lg font-bold"> </h3> <p class="text-muted-foreground mb-4 text-center text-sm text-balance"> </p></div> <div class="fade-mask bg-background/75 pointer-events-none absolute right-0 bottom-0 left-0 h-8 svelte-styo3v"></div></div>'), Ue = /* @__PURE__ */ template('<div role="button" tabindex="0"><!> <!> <img alt="cover" loading="eager"> <!> <img alt="game logo" loading="eager"></div>');
+function GameCard(e2, t2) {
+  push(t2, true);
+  const [n2, i2] = setup_stores();
+  let o2 = state(false), s2 = state(void 0), a2 = state(false), l2 = state(false), c2 = state(false), u2 = state(false);
+  function handleMouseEnter() {
+    get$1(o2) || function playSound(e3, t3 = 1) {
+      try {
+        const n3 = new Audio(e3);
+        n3.volume = t3, n3.play();
+      } catch (e4) {
+        console.error("Error playing sound:", e4);
+      }
+    }(store_get(He, "$projectUrl", n2) + "/static/sounds/hover-selection.ogg", 0.25), // Original hover logic
+    set(o2, true), get$1(s2) && t2.game.cover_video_url && (set(u2, true), // Flag that we're attempting to load the video
+    get$1(s2).play().catch((e3) => console.error("Video play error:", e3)));
+  }
+  function handleMouseLeave() {
+    set(o2, false), // Only pause if it's already loaded and playing
+    get$1(s2) && get$1(a2) && get$1(s2).pause();
+  }
+  var d2 = Ue();
+  d2.__touchstart = handleMouseEnter, d2.__touchend = handleMouseLeave, d2.__click = [handleClick, t2];
+  var f2 = child(d2), consequent = (e3) => {
+    var t3 = Re();
+    let n3;
+    template_effect(() => n3 = set_class(t3, 1, "bg-foreground text-background absolute top-4 right-4 z-13 px-2 py-0.5 font-bold transition-opacity", null, n3, {
+      "opacity-0": get$1(o2)
+    })), append(e3, t3);
+  };
+  if_block(f2, (e3) => {
+    var _a;
+    (function isNewGame(e4) {
+      const t3 = /* @__PURE__ */ new Date();
+      return t3.setDate(t3.getDate() - 7), new Date(e4) > t3;
+    })((_a = t2.game) == null ? void 0 : _a.created_at) && e3(consequent);
+  });
+  var p2 = sibling(f2, 2), consequent_1 = (e3) => {
+    var n3 = Ve();
+    let i3;
+    n3.muted = true, bind_this(n3, (e4) => set(s2, e4), () => get$1(s2)), template_effect(() => {
+      set_attribute(n3, "src", t2.game.cover_video_url), i3 = set_class(n3, 1, "absolute top-0 left-0 z-5 h-full w-full object-cover opacity-0", null, i3, {
+        "opacity-100": get$1(o2) && get$1(a2) && t2.game.cover_video_url
+      });
+    }), event("loadeddata", n3, () => {
+      set(a2, true), set(u2, false);
+    }), append(e3, n3);
+  };
+  if_block(p2, (e3) => {
+    t2.game.cover_video_url && e3(consequent_1);
+  });
+  var _2 = sibling(p2, 2);
+  let v2;
+  var g2 = sibling(_2, 2), consequent_2 = (e3) => {
+    var n3 = Ke(), i3 = child(n3), o3 = child(i3), s3 = child(o3), a3 = child(sibling(o3, 2));
+    template_effect(() => {
+      set_text(s3, t2.game.name), set_text(a3, t2.game.description || "No description.");
+    }), transition(3, n3, () => slide), append(e3, n3);
+  };
+  if_block(g2, (e3) => {
+    get$1(o2) && e3(consequent_2);
+  });
+  var h2 = sibling(g2, 2);
+  let m2;
+  template_effect(() => {
+    set_class(d2, 1, `bg-background highlight-border group relative mt-5 mb-[calc(3dvh+1.5vw)] flex aspect-[2/3] h-1/2 max-h-[75vh] min-h-92 cursor-pointer flex-col shadow-xl transition hover:outline-2 hover:brightness-105 lg:h-3/7 ${(get$1(l2) ? "" : "animate-pulse") ?? ""}`, "svelte-styo3v"), set_attribute(_2, "src", t2.game.cover_image_url), v2 = set_class(_2, 1, "absolute top-0 left-0 z-10 h-full w-full object-cover opacity-0 transition svelte-styo3v", null, v2, {
+      "opacity-100": get$1(l2) && (!get$1(o2) || !get$1(a2) || !t2.game.cover_video_url)
+    }), set_attribute(h2, "src", t2.game.logo_url), m2 = set_class(h2, 1, "absolute right-0 -bottom-[18%] left-0 z-12 mx-auto aspect-square w-1/5 rounded-full object-center opacity-0 transition group-hover:outline-2 svelte-styo3v", null, m2, {
+      "opacity-100": get$1(c2)
+    });
+  }), event("mouseenter", d2, handleMouseEnter), event("focus", d2, handleMouseEnter), event("mouseleave", d2, handleMouseLeave), event("blur", d2, handleMouseLeave), event("touchcancel", d2, handleMouseLeave), event("load", _2, () => {
+    set(l2, true);
+  }), event("load", h2, () => {
+    set(c2, true);
+  }), append(e2, d2), pop(), i2();
+}
+delegate(["touchstart", "touchend", "click"]);
+const Ze = new class PlayLightAPI {
+  constructor() {
+    this.baseUrl = "https://api.playlight.dev/platform", this.cachedCategories = null, this.currentGame = null;
+  }
+  async request(e2, t2 = {}) {
+    try {
+      const n2 = `${this.baseUrl}${e2}`, i2 = await fetch(n2, {
+        ...t2,
+        headers: {
+          "Content-Type": "application/json",
+          ...t2.headers
+        }
+      });
+      if (!i2.ok) {
+        let e3;
+        try {
+          e3 = await i2.json();
+        } catch {
+        } finally {
+          if (429 !== i2.status && 404 !== i2.status) throw new Error(`API request failed: ${(e3 == null ? void 0 : e3.error) || (e3 == null ? void 0 : e3.message) || i2.status}`);
+          return 429 === i2.status ? console.warn("Playlight request didn't go through due to rate limiting.") : console.warn("Playlight game not found. This is normal in a test / local environment, but should not appear in production.");
+        }
+      }
+      return await i2.json();
+    } catch (e3) {
+      Oe.error("Error: " + e3), console.error("Playlight API error:", e3);
+    }
+  }
+  // Get all categories
+  async getCategories() {
+    if (this.cachedCategories) return this.cachedCategories;
+    const e2 = await this.request("/categories");
+    return this.cachedCategories = e2, e2;
+  }
+  // Get game suggestions, optionally filtered by category
+  async getSuggestions(e2 = null, t2 = 1, n2) {
+    let i2 = "/suggestions";
+    return e2 && (i2 += "/" + e2), t2 && (i2 += "?page=" + t2), n2 && (i2 += "&without=" + n2), await this.request(i2);
+  }
+  // Get game suggestions, optionally filtered by category
+  async getCurrentGameInfo() {
+    if (this.currentGame) return this.currentGame;
+    let e2 = "/game-by-domain/" + window.location.hostname;
+    return this.currentGame = await this.request(e2), {
+      ...this.currentGame
+    };
+  }
+  // Track discovery overlay open
+  async trackOpen() {
+    const e2 = window.location.hostname;
+    await this.request("/event/open", {
+      method: "POST",
+      body: JSON.stringify({
+        domain: e2
+      })
+    });
+  }
+  // Track game click (pass id of the game that was clicked on)
+  async trackClick(e2) {
+    const t2 = window.location.hostname;
+    await this.request("/event/click", {
+      method: "POST",
+      body: JSON.stringify({
+        sourceDomain: t2,
+        gameId: e2
+      })
+    });
+  }
+}();
+function cubicOut(e2) {
+  const t2 = e2 - 1;
+  return t2 * t2 * t2 + 1;
+}
+function elasticOut(e2) {
+  return Math.sin(-13 * (e2 + 1) * Math.PI / 2) * Math.pow(2, -10 * e2) + 1;
+}
+function flip(e2, { from: t2, to: n2 }, i2 = {}) {
+  var { delay: o2 = 0, duration: s2 = (e3) => 120 * Math.sqrt(e3), easing: a2 = cubicOut } = i2, l2 = getComputedStyle(e2), c2 = "none" === l2.transform ? "" : l2.transform, [u2, d2] = l2.transformOrigin.split(" ").map(parseFloat);
+  u2 /= e2.clientWidth, d2 /= e2.clientHeight;
+  var f2 = (
+    /**
+    * @param {Element} element
+    */
+    function get_zoom(e3) {
+      if ("currentCSSZoom" in e3)
+        return e3.currentCSSZoom;
+      var t3 = e3, n3 = 1;
+      for (; null !== t3; ) n3 *= +getComputedStyle(t3).zoom, t3 = /** @type {Element | null} */
+      t3.parentElement;
+      return n3;
+    }(e2)
+  ), p2 = e2.clientWidth / n2.width / f2, _2 = e2.clientHeight / n2.height / f2, v2 = t2.left + t2.width * u2, g2 = t2.top + t2.height * d2, h2 = n2.left + n2.width * u2, m2 = n2.top + n2.height * d2, b2 = (v2 - h2) * p2, y2 = (g2 - m2) * _2, $2 = t2.width / n2.width, w2 = t2.height / n2.height;
+  return {
+    delay: o2,
+    duration: "function" == typeof s2 ? s2(Math.sqrt(b2 * b2 + y2 * y2)) : s2,
+    easing: a2,
+    css: (e3, t3) => `transform: ${c2} translate(${t3 * b2}px, ${t3 * y2}px) scale(${e3 + t3 * $2}, ${e3 + t3 * w2});`
+  };
+}
+var on_click$1 = (e2, t2, n2) => {
+  set(t2, ""), set(n2, !get$1(n2));
+}, Ye = /* @__PURE__ */ template('<div class="text-muted-foreground animate-pulse p-4 text-center">Loading...</div>'), Je = /* @__PURE__ */ template('<div class="text-muted-foreground p-4 text-center">No categories found.</div>'), on_click_1$1 = (e2, t2, n2, i2) => {
+  t2(n2), set(i2, false);
+}, Xe = /* @__PURE__ */ template("<button> </button>"), Qe = /* @__PURE__ */ template('<div class="space-y-1 p-1"></div>'), et = /* @__PURE__ */ template('<div class="bg-background/85 fixed left-1/2 z-50 mt-24 w-30 w-full max-w-xs -translate-x-1/2 transform border shadow-lg backdrop-blur"><div class="border-b p-3"><div class="relative"><div class="pointer-events-none absolute inset-y-0 left-0 flex items-center pl-1"><!></div> <input type="text" placeholder="Search categories..." class="w-full border-0 p-1 pl-10 text-white focus:ring-0 focus:outline-none"></div></div> <div class="max-h-60 overflow-y-auto"><!></div></div>'), tt = /* @__PURE__ */ template('<div class="flex w-full flex-col py-2"><h1 class="mb-0! py-2 text-center text-2xl font-bold text-white drop-shadow-xl lg:text-4xl"><span> </span> <button class="group mx-1 inline-flex cursor-pointer items-center bg-white px-3 py-1 text-black transition hover:rotate-5"><span class="max-w-[40vw] truncate"> </span> <!></button> <span>games?</span></h1> <!></div>');
+function Navigation(e2, t2) {
+  push(t2, true);
+  let n2, i2 = prop(t2, "categories", 19, () => []), o2 = prop(t2, "selectedCategory", 15), s2 = state(false), a2 = /* @__PURE__ */ derived(() => o2() || (i2().length > 0 ? i2()[0] : "...")), l2 = state(""), c2 = state(void 0), u2 = /* @__PURE__ */ derived(() => get$1(l2) ? i2().filter((e3) => e3.toLowerCase().includes(get$1(l2).toLowerCase())) : i2());
+  const d2 = ["Looking for", "Interested in", "Searching for", "Fancy some", "What about these"];
+  let f2, p2 = state(proxy(d2[0]));
+  onMount(function updateRandomPhrase() {
+    let e3;
+    for (e3 = Math.floor(Math.random() * (d2 == null ? void 0 : d2.length)); e3 == f2; ) e3 = Math.floor(Math.random() * (d2 == null ? void 0 : d2.length));
+    set(p2, proxy(d2[e3])), f2 = e3;
+  });
+  var _2 = tt();
+  event("click", I, function handleClickOutside(e3) {
+    get$1(c2) && !get$1(c2).contains(e3.target) && n2 && !n2.contains(e3.target) && set(s2, false);
+  });
+  var v2 = child(_2), g2 = child(v2), h2 = child(g2), m2 = sibling(g2, 2);
+  m2.__click = [on_click$1, l2, s2];
+  var b2 = child(m2), y2 = child(b2), $2 = sibling(b2, 2);
+  const w2 = /* @__PURE__ */ derived(() => get$1(s2) ? "rotate-180 transform" : "");
+  !function Chevron_down(e3, t3) {
+    const n3 = legacy_rest_props(t3, ["children", "$$slots", "$$events", "$$legacy"]);
+    Icon$1(e3, spread_props({
+      name: "chevron-down"
+    }, () => n3, {
+      iconNode: [["path", {
+        d: "m6 9 6 6 6-6"
+      }]],
+      children: (e4, n4) => {
+        var i3 = comment();
+        slot(first_child(i3), t3, "default", {}, null), append(e4, i3);
+      },
+      $$slots: {
+        default: true
+      }
+    }));
+  }($2, {
+    size: 25,
+    strokeWidth: 3,
+    get class() {
+      return `mt-1 ml-1 text-black ${get$1(w2) ?? ""} transition-transform duration-200`;
+    }
+  }), bind_this(m2, (e3) => n2 = e3, () => n2);
+  var x2 = sibling(v2, 2), consequent_2 = (e3) => {
+    var t3 = et(), n3 = child(t3), a3 = child(n3), d3 = child(a3);
+    !function Search(e4, t4) {
+      const n4 = legacy_rest_props(t4, ["children", "$$slots", "$$events", "$$legacy"]);
+      Icon$1(e4, spread_props({
+        name: "search"
+      }, () => n4, {
+        iconNode: [["circle", {
+          cx: "11",
+          cy: "11",
+          r: "8"
+        }], ["path", {
+          d: "m21 21-4.3-4.3"
+        }]],
+        children: (e5, n5) => {
+          var i3 = comment();
+          slot(first_child(i3), t4, "default", {}, null), append(e5, i3);
+        },
+        $$slots: {
+          default: true
+        }
+      }));
+    }(child(d3), {
+      size: 18,
+      class: "text-muted-foreground"
+    });
+    var f3 = sibling(d3, 2), p3 = child(sibling(n3, 2)), consequent = (e4) => {
+      append(e4, Ye());
+    }, alternate_1 = (e4) => {
+      var t4 = comment(), n4 = first_child(t4), consequent_1 = (e5) => {
+        append(e5, Je());
+      }, alternate = (e5) => {
+        var t5 = Qe();
+        each(t5, 28, () => get$1(u2), (e6) => e6, (e6, t6) => {
+          var n5 = Xe();
+          n5.__click = [on_click_1$1, o2, t6, s2];
+          var i3 = child(n5);
+          template_effect(() => {
+            set_class(n5, 1, `w-full cursor-pointer px-4 py-2 text-left transition-colors ${(o2() != t6 ? "hover:bg-muted-foreground/20" : "") ?? ""} ${(o2() == t6 ? "bg-white text-black" : "text-white") ?? ""}`), set_text(i3, t6);
+          }), function animation(e7, t7, n6) {
+            var i4, o3, s3, a4 = (
+              /** @type {EachItem} */
+              ce
+            ), l3 = null;
+            a4.a ?? (a4.a = {
+              element: e7,
+              measure() {
+                i4 = this.element.getBoundingClientRect();
+              },
+              apply() {
+                if (s3 == null ? void 0 : s3.abort(), o3 = this.element.getBoundingClientRect(), i4.left !== o3.left || i4.right !== o3.right || i4.top !== o3.top || i4.bottom !== o3.bottom) {
+                  const e8 = t7()(this.element, {
+                    from: i4,
+                    to: o3
+                  }, n6 == null ? void 0 : n6());
+                  s3 = animate(this.element, e8, void 0, 1, () => {
+                    s3 == null ? void 0 : s3.abort(), s3 = void 0;
+                  });
+                }
+              },
+              fix() {
+                if (!e7.getAnimations().length) {
+                  var { position: t8, width: n7, height: o4 } = getComputedStyle(e7);
+                  if ("absolute" !== t8 && "fixed" !== t8) {
+                    var s4 = (
+                      /** @type {HTMLElement | SVGElement} */
+                      e7.style
+                    );
+                    l3 = {
+                      position: s4.position,
+                      width: s4.width,
+                      height: s4.height,
+                      transform: s4.transform
+                    }, s4.position = "absolute", s4.width = n7, s4.height = o4;
+                    var a5 = e7.getBoundingClientRect();
+                    if (i4.left !== a5.left || i4.top !== a5.top) {
+                      var c3 = `translate(${i4.left - a5.left}px, ${i4.top - a5.top}px)`;
+                      s4.transform = s4.transform ? `${s4.transform} ${c3}` : c3;
+                    }
+                  }
+                }
+              },
+              unfix() {
+                if (l3) {
+                  var t8 = (
+                    /** @type {HTMLElement | SVGElement} */
+                    e7.style
+                  );
+                  t8.position = l3.position, t8.width = l3.width, t8.height = l3.height, t8.transform = l3.transform;
+                }
+              }
+            }), // in the case of a `<svelte:element>`, it's possible for `$.animation(...)` to be called
+            // when an animation manager already exists, if the tag changes. in that case, we need to
+            // swap out the element rather than creating a new manager, in case it happened at the same
+            // moment as a reconciliation
+            a4.a.element = e7;
+          }(n5, () => flip, () => ({
+            duration: 150
+          })), append(e6, n5);
+        }), append(e5, t5);
+      };
+      if_block(n4, (e5) => {
+        0 === get$1(u2).length ? e5(consequent_1) : e5(alternate, false);
+      }, true), append(e4, t4);
+    };
+    if_block(p3, (e4) => {
+      0 === i2().length ? e4(consequent) : e4(alternate_1, false);
+    }), bind_this(t3, (e4) => set(c2, e4), () => get$1(c2)), function bind_value(e4, t4, n4 = t4) {
+      var i3 = is_runes();
+      listen_to_event_and_reset_event(e4, "input", (o3) => {
+        var s3 = o3 ? e4.defaultValue : e4.value;
+        if (s3 = is_numberlike_input(e4) ? to_number(s3) : s3, n4(s3), i3 && s3 !== (s3 = t4())) {
+          var a4 = e4.selectionStart, l3 = e4.selectionEnd;
+          e4.value = s3 ?? "", // Restore selection
+          null !== l3 && (e4.selectionStart = a4, e4.selectionEnd = Math.min(l3, e4.value.length));
+        }
+      }), // If we are hydrating and the value has since changed,
+      // then use the updated value from the input instead.
+      // If defaultValue is set, then value == defaultValue
+      // TODO Svelte 6: remove input.value check and set to empty string?
+      null == untrack(t4) && e4.value && n4(is_numberlike_input(e4) ? to_number(e4.value) : e4.value), render_effect(() => {
+        var n5 = t4();
+        is_numberlike_input(e4) && n5 === to_number(e4.value) || ("date" !== e4.type || n5 || e4.value) && n5 !== e4.value && // @ts-expect-error the value is coerced on assignment
+        (e4.value = n5 ?? "");
+      });
+    }(f3, () => get$1(l2), (e4) => set(l2, e4)), transition(3, t3, () => fly, () => ({
+      y: -5,
+      duration: 250
+    })), append(e3, t3);
+  };
+  if_block(x2, (e3) => {
+    get$1(s2) && e3(consequent_2);
+  }), template_effect(() => {
+    set_text(h2, get$1(p2)), set_text(y2, get$1(a2));
+  }), transition(3, _2, () => scale, () => ({
+    duration: 600,
+    delay: 50,
+    easing: elasticOut,
+    start: 0.95
+  })), append(e2, _2), pop();
+}
+delegate(["click"]);
+var on_click = (e2, t2) => {
+  localStorage.getItem("playlight_exit_intent_disabled_by_user") ? localStorage.removeItem("playlight_exit_intent_disabled_by_user") : localStorage.setItem("playlight_exit_intent_disabled_by_user", true), set(t2, !get$1(t2));
+}, on_click_1 = (e2, t2) => store_set(Ge, false), nt = /* @__PURE__ */ template('<div class="flex h-4/5 items-center justify-center gap-4"><!></div>'), rt = /* @__PURE__ */ template('<div class="text-muted-foreground flex h-4/5 items-center justify-center gap-4"><p>No games found that match the filter.</p></div>'), it = /* @__PURE__ */ template('<div class="mx-auto flex h-full flex-wrap content-start justify-center gap-10 lg:max-w-4/5"><!> <div class="flex h-10 w-full justify-center"><!></div></div>'), ot = /* @__PURE__ */ template('<div class="bg-background/75 fixed inset-0 top-0 right-0 bottom-0 left-0 z-99999 flex flex-col justify-center text-white backdrop-blur-md"><div class="ml-2 flex items-center justify-between p-4"><a href="https://playlight.dev" target="_blank"><img alt="logo" class="w-50"></a> <div class="mt-4 mr-2 flex items-center justify-evenly gap-8 overflow-hidden md:mr-4"><button class="cursor-pointer truncate text-sm text-nowrap text-white opacity-50 transition hover:opacity-25 max-md:hidden"><p class="bg-background/50 p-1 px-2"> </p></button> <button class="cursor-pointer text-white transition hover:opacity-50" aria-label="Close"><!></button></div></div> <div class="mx-auto p-2 px-5"><!></div> <div class="mask-fade no-scrollbar relative h-full w-full overflow-y-auto p-4 svelte-12skmk8"><!></div> <div class="fixed right-0 bottom-0 flex items-center justify-between p-4"><a href="https://playlight.dev" target="_blank" class="text-muted-foreground flex items-center gap-1 text-sm transition hover:text-white">Game Developer? Join Playlight <!></a></div></div>');
+function DiscoveryOverlay(e2, t2) {
+  push(t2, true);
+  const [n2, i2] = setup_stores();
+  let o2, s2 = state(void 0), a2 = state(true), l2 = state(false), c2 = state(void 0), u2 = state(proxy([])), d2 = state(proxy([])), f2 = state(true), p2 = state(1), _2 = state(true), v2 = state(void 0), g2 = state(false);
+  async function fetchGames() {
+    if (!(get$1(a2) && get$1(p2) > 1 || get$1(l2))) try {
+      1 === get$1(p2) ? set(a2, true) : set(l2, true);
+      const e3 = get$1(g2) ? null : get$1(s2), t3 = await Ze.getSuggestions(e3, get$1(p2), window.location.hostname), n3 = (t3 == null ? void 0 : t3.games) || [], i3 = n3.filter((e4) => !get$1(u2).some((t4) => t4.id === e4.id));
+      set(u2, proxy([...get$1(u2), ...i3])), n3.length < 10 ? !get$1(g2) && get$1(s2) ? (
+        // Try with all games
+        (set(g2, true), set(p2, 1), setTimeout(() => fetchGames(), 100))
+      ) : set(_2, false) : set(p2, get$1(p2) + 1);
+    } catch (e3) {
+      console.error(e3), Oe.error("Failed to load games: " + e3);
+    } finally {
+      set(a2, false), set(l2, false), // For Chrome: manually check if element is still in view and should trigger another load
+      get$1(_2) && get$1(v2) && setTimeout(() => {
+        const e3 = get$1(v2).getBoundingClientRect();
+        !(e3.top >= -200 && // Include rootMargin
+        e3.left >= 0 && e3.bottom <= window.innerHeight + 200 && // Include rootMargin
+        e3.right <= window.innerWidth) || get$1(a2) || get$1(l2) || fetchGames();
+      }, 150);
+    }
+  }
+  onMount(() => (set(f2, !Boolean(localStorage.getItem("playlight_exit_intent_disabled_by_user"))), // Setup scroll observer
+  o2 = new IntersectionObserver((e3) => {
+    e3[0].isIntersecting && get$1(_2) && !get$1(a2) && !get$1(l2) && fetchGames();
+  }, {
+    rootMargin: "200px"
+  }), () => o2 == null ? void 0 : o2.disconnect())), onMount(async () => {
+    const e3 = await Ze.getCurrentGameInfo();
+    set(c2, proxy(e3 == null ? void 0 : e3.category)), await async function fetchCategories() {
+      var _a, _b, _c, _d;
+      set(d2, proxy(await Ze.getCategories())), !get$1(s2) && ((_a = get$1(d2)) == null ? void 0 : _a.length) > 0 && set(s2, proxy(get$1(c2) && ((_b = get$1(d2)) == null ? void 0 : _b.includes(get$1(c2))) ? get$1(c2) : (_d = get$1(d2)) == null ? void 0 : _d[((_c = get$1(d2)) == null ? void 0 : _c.length) - 1]));
+    }();
+  }), user_effect(() => {
+    get$1(s2) && (set(u2, proxy([])), set(p2, 1), set(_2, true), set(g2, false), set(a2, true), // Delay fetch to prevent rapid requests
+    setTimeout(async () => {
+      await fetchGames(), get$1(u2).length < 10 && await fetchGames();
+    }, 100));
+  }), user_effect(() => {
+    get$1(v2) && o2 && o2.observe(get$1(v2));
+  });
+  var h2 = ot();
+  event("keydown", I, (e3) => {
+    "Escape" == e3.key && store_set(Ge, false);
+  });
+  var m2 = child(h2), b2 = child(m2), y2 = child(b2), $2 = child(sibling(b2, 2));
+  $2.__click = [on_click, f2];
+  var w2 = child($2), x2 = child(w2), k2 = sibling($2, 2);
+  k2.__click = [on_click_1, () => store_get(Ge, "$discoveryOpen", n2)], function X(e3, t3) {
+    const n3 = legacy_rest_props(t3, ["children", "$$slots", "$$events", "$$legacy"]);
+    Icon$1(e3, spread_props({
+      name: "x"
+    }, () => n3, {
+      iconNode: [["path", {
+        d: "M18 6 6 18"
+      }], ["path", {
+        d: "m6 6 12 12"
+      }]],
+      children: (e4, n4) => {
+        var i3 = comment();
+        slot(first_child(i3), t3, "default", {}, null), append(e4, i3);
+      },
+      $$slots: {
+        default: true
+      }
+    }));
+  }(child(k2), {
+    size: 24
+  });
+  var C2 = sibling(m2, 2);
+  Navigation(child(C2), {
+    get categories() {
+      return get$1(d2);
+    },
+    get selectedCategory() {
+      return get$1(s2);
+    },
+    set selectedCategory(e3) {
+      set(s2, proxy(e3));
+    }
+  });
+  var M2 = sibling(C2, 2), S2 = child(M2), consequent = (e3) => {
+    var t3 = nt();
+    Loader_circle(child(t3), {
+      class: "animate-spin opacity-75",
+      size: 50,
+      strokeWidth: 2.5
+    }), append(e3, t3);
+  }, alternate_1 = (e3) => {
+    var t3 = comment(), n3 = first_child(t3), consequent_1 = (e4) => {
+      append(e4, rt());
+    }, alternate = (e4) => {
+      var t4 = it(), n4 = child(t4);
+      each(n4, 17, () => get$1(u2), index, (e5, t5) => {
+        GameCard(e5, {
+          get game() {
+            return get$1(t5);
+          },
+          onClick: () => Ze.trackClick(get$1(t5).id)
+        });
+      });
+      var i3 = sibling(n4, 2), o3 = child(i3), consequent_2 = (e5) => {
+        Loader_circle(e5, {
+          class: "animate-spin opacity-75",
+          size: 30,
+          strokeWidth: 2.5
+        });
+      };
+      if_block(o3, (e5) => {
+        get$1(l2) && e5(consequent_2);
+      }), bind_this(i3, (e5) => set(v2, e5), () => get$1(v2)), append(e4, t4);
+    };
+    if_block(n3, (e4) => {
+      0 !== get$1(u2).length || get$1(a2) ? e4(alternate, false) : e4(consequent_1);
+    }, true), append(e3, t3);
+  };
+  if_block(S2, (e3) => {
+    get$1(a2) && 0 === get$1(u2).length ? e3(consequent) : e3(alternate_1, false);
+  });
+  var T2 = child(sibling(M2, 2));
+  !function External_link(e3, t3) {
+    const n3 = legacy_rest_props(t3, ["children", "$$slots", "$$events", "$$legacy"]);
+    Icon$1(e3, spread_props({
+      name: "external-link"
+    }, () => n3, {
+      iconNode: [["path", {
+        d: "M15 3h6v6"
+      }], ["path", {
+        d: "M10 14 21 3"
+      }], ["path", {
+        d: "M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"
+      }]],
+      children: (e4, n4) => {
+        var i3 = comment();
+        slot(first_child(i3), t3, "default", {}, null), append(e4, i3);
+      },
+      $$slots: {
+        default: true
+      }
+    }));
+  }(sibling(child(T2)), {
+    size: 14,
+    style: "margin-top: 1px;"
+  }), template_effect(() => {
+    set_attribute(y2, "src", store_get(He, "$projectUrl", n2) + "/static/images/logo-white-small.png"), set_text(x2, get$1(f2) ? "Ignore exit intent" : "Trigger on exit intent");
+  }), transition(3, h2, () => blur, () => ({
+    duration: 250
+  })), append(e2, h2), pop(), i2();
+}
+delegate(["click"]);
+var st = /* @__PURE__ */ template('<div class="fixed top-0 left-0 right-0 h-2 z-99990"></div>');
+delegate(["mouseover"]);
+var at = /* @__PURE__ */ template("<!> <!> <!> <!>", 1);
+function App(e2, t2) {
+  var _a, _b, _c, _d;
+  push(t2, true);
+  const [n2, i2] = setup_stores(), $discoveryOpen = () => store_get(Ge, "$discoveryOpen", n2);
+  let o2 = proxy((_b = (_a = t2.config) == null ? void 0 : _a.button) == null ? void 0 : _b.position), s2 = proxy((_d = (_c = t2.config) == null ? void 0 : _c.button) == null ? void 0 : _d.visible);
+  function openDiscovery() {
+    store_set(Ge, true), Ze.trackOpen();
+  }
+  var a2 = at(), l2 = first_child(a2);
+  FloatingButton(l2, {
+    get position() {
+      return o2;
+    },
+    get visible() {
+      return s2;
+    },
+    onClick: openDiscovery
+  });
+  var c2 = sibling(l2, 2), consequent = (e3) => {
+    DiscoveryOverlay(e3, {});
+  };
+  if_block(c2, (e3) => {
+    $discoveryOpen() && e3(consequent);
+  });
+  var u2 = sibling(c2, 2);
+  const d2 = /* @__PURE__ */ derived(() => {
+    var _a2, _b2;
+    return (_b2 = (_a2 = t2.config) == null ? void 0 : _a2.exitIntent) == null ? void 0 : _b2.enabled;
+  });
+  !function ExitIntentDetector(e3, t3) {
+    push(t3, true);
+    let n3, i3 = prop(t3, "enabled", 3, true), o3 = false;
+    onMount(() => {
+      "undefined" != typeof window && (n3 = window.innerHeight);
+    });
+    var s3 = st();
+    event("mouseleave", I, () => {
+      o3 = false;
+    }), event("mousemove", I, (e4) => {
+      const t4 = e4.clientY;
+      if (!o3) return o3 = true, void (n3 = t4);
+      n3 = t4;
+    }), s3.__mouseover = (e4) => {
+      var _a2;
+      const s4 = e4.clientY;
+      s4 < n3 && o3 && i3() && !localStorage.getItem("playlight_exit_intent_disabled_by_user") && ((_a2 = t3.onIntent) == null ? void 0 : _a2.call(t3)), // Update lastMouseY after checking
+      n3 = s4;
+    }, append(e3, s3), pop();
+  }(u2, {
+    get enabled() {
+      return get$1(d2);
+    },
+    onIntent: () => {
+      $discoveryOpen() || openDiscovery();
+    }
+  }), Toaster(sibling(u2, 2), {}), append(e2, a2), pop(), i2();
+}
+const lt = {
+  button: {
+    position: "bottom-right",
+    visible: true
+  },
+  exitIntent: {
+    enabled: true
+  }
+};
+let ct = {
+  ...lt
+};
+function initializeConfig(e2 = {}) {
+  return ct = deepMerge(lt, e2), ct;
+}
+function deepMerge(e2, t2) {
+  const n2 = {
+    ...e2
+  };
+  return isObject(e2) && isObject(t2) && Object.keys(t2).forEach((i2) => {
+    isObject(t2[i2]) ? i2 in e2 ? n2[i2] = deepMerge(e2[i2], t2[i2]) : Object.assign(n2, {
+      [i2]: t2[i2]
+    }) : Object.assign(n2, {
+      [i2]: t2[i2]
+    });
+  }), n2;
+}
+function isObject(e2) {
+  return e2 && "object" == typeof e2 && !Array.isArray(e2);
+}
+const ut = new class PlaylightSDK {
+  constructor() {
+    this.container = null, this.app = null, this.isInitialized = false, this.config = null, this.api = Ze;
+  }
+  async init(e2 = {}) {
+    if (!this.isInitialized)
+      return this.config = initializeConfig(e2), // Create container for Svelte app
+      this.container = document.createElement("div"), this.container.id = "playlight-sdk-container", document.body.appendChild(this.container), // Use mount function (client-side equivalent of render)
+      this.app = mount(App, {
+        target: this.container,
+        props: {
+          config: this.config
+        }
+      }), // Fetch current game info to cache it
+      await this.api.getCurrentGameInfo(), this.isInitialized = true, this;
+  }
+  // Public methods
+  setDiscovery(e2) {
+    this.isInitialized && (Ge.set(e2), get(Ge) && Ze.trackOpen());
+  }
+}();
+"undefined" != typeof window && (window.playlightSDK = ut);
+export {
+  ut as default
+};
+//# sourceMappingURL=playlight-sdk.es.js.map