vistaview 0.10.15 → 0.10.17

package/dist/svelte.js

@@ -1,41 +1,1851 @@
-import { onDestroy as v, onMount as y } from "svelte";
-import { vistaView as d } from "./vistaview.js";
-function w(e) {
-  const o = d(e);
-  return v(() => {
-    o == null || o.destroy();
-  }), {
-    open: (r = 0) => o == null ? void 0 : o.open(r),
-    close: () => (o == null ? void 0 : o.close()) ?? Promise.resolve(),
-    reset: () => o == null ? void 0 : o.reset(),
-    next: () => o == null ? void 0 : o.next(),
-    prev: () => o == null ? void 0 : o.prev(),
-    zoomIn: () => o == null ? void 0 : o.zoomIn(),
-    zoomOut: () => o == null ? void 0 : o.zoomOut(),
-    getCurrentIndex: () => (o == null ? void 0 : o.getCurrentIndex()) ?? -1,
-    view: (r) => o == null ? void 0 : o.view(r),
-    destroy: () => o == null ? void 0 : o.destroy()
+var nr = Object.defineProperty;
+var lt = (e) => {
+  throw TypeError(e);
+};
+var ir = (e, t, r) => t in e ? nr(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var H = (e, t, r) => ir(e, typeof t != "symbol" ? t + "" : t, r), Ye = (e, t, r) => t.has(e) || lt("Cannot " + r);
+var a = (e, t, r) => (Ye(e, t, "read from private field"), r ? r.call(e) : t.get(e)), T = (e, t, r) => t.has(e) ? lt("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, r), K = (e, t, r, n) => (Ye(e, t, "write to private field"), n ? n.call(e, r) : t.set(e, r), r), F = (e, t, r) => (Ye(e, t, "access private method"), r);
+import { onMount as fr, onDestroy as lr } from "svelte";
+import { vistaView as sr } from "./vistaview.js";
+const ur = "5";
+var bt;
+typeof window < "u" && ((bt = window.__svelte ?? (window.__svelte = {})).v ?? (bt.v = /* @__PURE__ */ new Set())).add(ur);
+const or = 2, Be = Symbol(), ar = "http://www.w3.org/1999/xhtml", cr = "@attach", Ke = !1;
+var vr = Array.isArray, dr = Array.prototype.indexOf, hr = Object.defineProperty, _r = Object.getOwnPropertyDescriptors, pr = Object.getPrototypeOf;
+function gr(e) {
+  for (var t = 0; t < e.length; t++)
+    e[t]();
+}
+function Et() {
+  var e, t, r = new Promise((n, i) => {
+    e = n, t = i;
+  });
+  return { promise: r, resolve: e, reject: t };
+}
+const O = 2, Xe = 4, wr = 8, mt = 1 << 24, te = 16, re = 32, be = 64, et = 128, B = 512, S = 1024, M = 2048, Z = 4096, z = 8192, $ = 16384, yt = 32768, ye = 65536, At = 1 << 18, qe = 1 << 19, br = 1 << 20, ue = 32768, We = 1 << 21, Tt = 1 << 22, J = 1 << 23, st = Symbol("$state"), Er = Symbol(""), ve = new class extends Error {
+  constructor() {
+    super(...arguments);
+    H(this, "name", "StaleReactionError");
+    H(this, "message", "The reaction that called `getAbortSignal()` was re-run or destroyed");
+  }
+}();
+function mr() {
+  throw new Error("https://svelte.dev/e/async_derived_orphan");
+}
+function yr() {
+  throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
+}
+function Ar() {
+  console.warn("https://svelte.dev/e/select_multiple_invalid_value");
+}
+function St(e) {
+  return e === this.v;
+}
+let Tr = !1, G = null;
+function Ie(e) {
+  G = e;
+}
+function Sr(e, t = !1, r) {
+  G = {
+    p: G,
+    i: !1,
+    c: null,
+    e: null,
+    s: e,
+    x: null,
+    l: null
+  };
+}
+function kr(e) {
+  var t = (
+    /** @type {ComponentContext} */
+    G
+  ), r = t.e;
+  if (r !== null) {
+    t.e = null;
+    for (var n of r)
+      Wr(n);
+  }
+  return t.i = !0, G = t.p, /** @type {T} */
+  {};
+}
+function Or() {
+  return !0;
+}
+let de = [];
+function Nr() {
+  var e = de;
+  de = [], gr(e);
+}
+function tt(e) {
+  if (de.length === 0) {
+    var t = de;
+    queueMicrotask(() => {
+      t === de && Nr();
+    });
+  }
+  de.push(e);
+}
+function Cr(e) {
+  var t = b;
+  if (t === null)
+    return p.f |= J, e;
+  if ((t.f & yt) === 0) {
+    if ((t.f & et) === 0)
+      throw e;
+    t.b.error(e);
+  } else
+    Me(e, t);
+}
+function Me(e, t) {
+  for (; t !== null; ) {
+    if ((t.f & et) !== 0)
+      try {
+        t.b.error(e);
+        return;
+      } catch (r) {
+        e = r;
+      }
+    t = t.parent;
+  }
+  throw e;
+}
+const Ce = /* @__PURE__ */ new Set();
+let _ = null, m = null, q = [], rt = null, Ge = !1;
+var _e, pe, ie, fe, Te, ge, we, y, Ze, ne, $e, kt, Ot;
+const xe = class xe {
+  constructor() {
+    T(this, y);
+    H(this, "committed", !1);
+    /**
+     * The current values of any sources that are updated in this batch
+     * They keys of this map are identical to `this.#previous`
+     * @type {Map<Source, any>}
+     */
+    H(this, "current", /* @__PURE__ */ new Map());
+    /**
+     * The values of any sources that are updated in this batch _before_ those updates took place.
+     * They keys of this map are identical to `this.#current`
+     * @type {Map<Source, any>}
+     */
+    H(this, "previous", /* @__PURE__ */ new Map());
+    /**
+     * When the batch is committed (and the DOM is updated), we need to remove old branches
+     * and append new ones by calling the functions added inside (if/each/key/etc) blocks
+     * @type {Set<() => void>}
+     */
+    T(this, _e, /* @__PURE__ */ new Set());
+    /**
+     * If a fork is discarded, we need to destroy any effects that are no longer needed
+     * @type {Set<(batch: Batch) => void>}
+     */
+    T(this, pe, /* @__PURE__ */ new Set());
+    /**
+     * The number of async effects that are currently in flight
+     */
+    T(this, ie, 0);
+    /**
+     * The number of async effects that are currently in flight, _not_ inside a pending boundary
+     */
+    T(this, fe, 0);
+    /**
+     * A deferred that resolves when the batch is committed, used with `settled()`
+     * TODO replace with Promise.withResolvers once supported widely enough
+     * @type {{ promise: Promise<void>, resolve: (value?: any) => void, reject: (reason: unknown) => void } | null}
+     */
+    T(this, Te, null);
+    /**
+     * Deferred effects (which run after async work has completed) that are DIRTY
+     * @type {Effect[]}
+     */
+    T(this, ge, []);
+    /**
+     * Deferred effects that are MAYBE_DIRTY
+     * @type {Effect[]}
+     */
+    T(this, we, []);
+    /**
+     * A set of branches that still exist, but will be destroyed when this batch
+     * is committed — we skip over these during `process`
+     * @type {Set<Effect>}
+     */
+    H(this, "skipped_effects", /* @__PURE__ */ new Set());
+    H(this, "is_fork", !1);
+  }
+  is_deferred() {
+    return this.is_fork || a(this, fe) > 0;
+  }
+  /**
+   *
+   * @param {Effect[]} root_effects
+   */
+  process(t) {
+    var n;
+    q = [], this.apply();
+    var r = {
+      parent: null,
+      effect: null,
+      effects: [],
+      render_effects: [],
+      block_effects: []
+    };
+    for (const i of t)
+      F(this, y, Ze).call(this, i, r);
+    this.is_fork || F(this, y, kt).call(this), this.is_deferred() ? (F(this, y, ne).call(this, r.effects), F(this, y, ne).call(this, r.render_effects), F(this, y, ne).call(this, r.block_effects)) : (_ = null, ut(r.render_effects), ut(r.effects), (n = a(this, Te)) == null || n.resolve()), m = null;
+  }
+  /**
+   * Associate a change to a given source with the current
+   * batch, noting its previous and current values
+   * @param {Source} source
+   * @param {any} value
+   */
+  capture(t, r) {
+    this.previous.has(t) || this.previous.set(t, r), (t.f & J) === 0 && (this.current.set(t, t.v), m == null || m.set(t, t.v));
+  }
+  activate() {
+    _ = this, this.apply();
+  }
+  deactivate() {
+    _ === this && (_ = null, m = null);
+  }
+  flush() {
+    if (this.activate(), q.length > 0) {
+      if (Ir(), _ !== null && _ !== this)
+        return;
+    } else a(this, ie) === 0 && this.process([]);
+    this.deactivate();
+  }
+  discard() {
+    for (const t of a(this, pe)) t(this);
+    a(this, pe).clear();
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  increment(t) {
+    K(this, ie, a(this, ie) + 1), t && K(this, fe, a(this, fe) + 1);
+  }
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  decrement(t) {
+    K(this, ie, a(this, ie) - 1), t && K(this, fe, a(this, fe) - 1), this.revive();
+  }
+  revive() {
+    for (const t of a(this, ge))
+      k(t, M), oe(t);
+    for (const t of a(this, we))
+      k(t, Z), oe(t);
+    K(this, ge, []), K(this, we, []), this.flush();
+  }
+  /** @param {() => void} fn */
+  oncommit(t) {
+    a(this, _e).add(t);
+  }
+  /** @param {(batch: Batch) => void} fn */
+  ondiscard(t) {
+    a(this, pe).add(t);
+  }
+  settled() {
+    return (a(this, Te) ?? K(this, Te, Et())).promise;
+  }
+  static ensure() {
+    if (_ === null) {
+      const t = _ = new xe();
+      Ce.add(_), xe.enqueue(() => {
+        _ === t && t.flush();
+      });
+    }
+    return _;
+  }
+  /** @param {() => void} task */
+  static enqueue(t) {
+    tt(t);
+  }
+  apply() {
+  }
+};
+_e = new WeakMap(), pe = new WeakMap(), ie = new WeakMap(), fe = new WeakMap(), Te = new WeakMap(), ge = new WeakMap(), we = new WeakMap(), y = new WeakSet(), /**
+ * Traverse the effect tree, executing effects or stashing
+ * them for later execution as appropriate
+ * @param {Effect} root
+ * @param {EffectTarget} target
+ */
+Ze = function(t, r) {
+  var d;
+  t.f ^= S;
+  for (var n = t.first; n !== null; ) {
+    var i = n.f, f = (i & (re | be)) !== 0, l = f && (i & S) !== 0, s = l || (i & z) !== 0 || this.skipped_effects.has(n);
+    if ((n.f & et) !== 0 && ((d = n.b) != null && d.is_pending()) && (r = {
+      parent: r,
+      effect: n,
+      effects: [],
+      render_effects: [],
+      block_effects: []
+    }), !s && n.fn !== null) {
+      f ? n.f ^= S : (i & Xe) !== 0 ? r.effects.push(n) : Ne(n) && ((n.f & te) !== 0 && r.block_effects.push(n), Ae(n));
+      var o = n.first;
+      if (o !== null) {
+        n = o;
+        continue;
+      }
+    }
+    var u = n.parent;
+    for (n = n.next; n === null && u !== null; )
+      u === r.effect && (F(this, y, ne).call(this, r.effects), F(this, y, ne).call(this, r.render_effects), F(this, y, ne).call(this, r.block_effects), r = /** @type {EffectTarget} */
+      r.parent), n = u.next, u = u.parent;
+  }
+}, /**
+ * @param {Effect[]} effects
+ */
+ne = function(t) {
+  for (const r of t)
+    ((r.f & M) !== 0 ? a(this, ge) : a(this, we)).push(r), F(this, y, $e).call(this, r.deps), k(r, S);
+}, /**
+ * @param {Value[] | null} deps
+ */
+$e = function(t) {
+  if (t !== null)
+    for (const r of t)
+      (r.f & O) === 0 || (r.f & ue) === 0 || (r.f ^= ue, F(this, y, $e).call(
+        this,
+        /** @type {Derived} */
+        r.deps
+      ));
+}, kt = function() {
+  if (a(this, fe) === 0) {
+    for (const t of a(this, _e)) t();
+    a(this, _e).clear();
+  }
+  a(this, ie) === 0 && F(this, y, Ot).call(this);
+}, Ot = function() {
+  var f;
+  if (Ce.size > 1) {
+    this.previous.clear();
+    var t = m, r = !0, n = {
+      parent: null,
+      effect: null,
+      effects: [],
+      render_effects: [],
+      block_effects: []
+    };
+    for (const l of Ce) {
+      if (l === this) {
+        r = !1;
+        continue;
+      }
+      const s = [];
+      for (const [u, d] of this.current) {
+        if (l.current.has(u))
+          if (r && d !== l.current.get(u))
+            l.current.set(u, d);
+          else
+            continue;
+        s.push(u);
+      }
+      if (s.length === 0)
+        continue;
+      const o = [...l.current.keys()].filter((u) => !this.current.has(u));
+      if (o.length > 0) {
+        var i = q;
+        q = [];
+        const u = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Map();
+        for (const c of s)
+          Nt(c, o, u, d);
+        if (q.length > 0) {
+          _ = l, l.apply();
+          for (const c of q)
+            F(f = l, y, Ze).call(f, c, n);
+          l.deactivate();
+        }
+        q = i;
+      }
+    }
+    _ = null, m = t;
+  }
+  this.committed = !0, Ce.delete(this);
+};
+let Re = xe;
+function Ir() {
+  var e = se;
+  Ge = !0;
+  var t = null;
+  try {
+    var r = 0;
+    for (Le(!0); q.length > 0; ) {
+      var n = Re.ensure();
+      if (r++ > 1e3) {
+        var i, f;
+        Mr();
+      }
+      n.process(q), Q.clear();
+    }
+  } finally {
+    Ge = !1, Le(e), rt = null;
+  }
+}
+function Mr() {
+  try {
+    yr();
+  } catch (e) {
+    Me(e, rt);
+  }
+}
+let V = null;
+function ut(e) {
+  var t = e.length;
+  if (t !== 0) {
+    for (var r = 0; r < t; ) {
+      var n = e[r++];
+      if ((n.f & ($ | z)) === 0 && Ne(n) && (V = /* @__PURE__ */ new Set(), Ae(n), n.deps === null && n.first === null && n.nodes === null && (n.teardown === null && n.ac === null ? Bt(n) : n.fn = null), (V == null ? void 0 : V.size) > 0)) {
+        Q.clear();
+        for (const i of V) {
+          if ((i.f & ($ | z)) !== 0) continue;
+          const f = [i];
+          let l = i.parent;
+          for (; l !== null; )
+            V.has(l) && (V.delete(l), f.push(l)), l = l.parent;
+          for (let s = f.length - 1; s >= 0; s--) {
+            const o = f[s];
+            (o.f & ($ | z)) === 0 && Ae(o);
+          }
+        }
+        V.clear();
+      }
+    }
+    V = null;
+  }
+}
+function Nt(e, t, r, n) {
+  if (!r.has(e) && (r.add(e), e.reactions !== null))
+    for (const i of e.reactions) {
+      const f = i.f;
+      (f & O) !== 0 ? Nt(
+        /** @type {Derived} */
+        i,
+        t,
+        r,
+        n
+      ) : (f & (Tt | te)) !== 0 && (f & M) === 0 && Ct(i, t, n) && (k(i, M), oe(
+        /** @type {Effect} */
+        i
+      ));
+    }
+}
+function Ct(e, t, r) {
+  const n = r.get(e);
+  if (n !== void 0) return n;
+  if (e.deps !== null)
+    for (const i of e.deps) {
+      if (t.includes(i))
+        return !0;
+      if ((i.f & O) !== 0 && Ct(
+        /** @type {Derived} */
+        i,
+        t,
+        r
+      ))
+        return r.set(
+          /** @type {Derived} */
+          i,
+          !0
+        ), !0;
+    }
+  return r.set(e, !1), !1;
+}
+function oe(e) {
+  for (var t = rt = e; t.parent !== null; ) {
+    t = t.parent;
+    var r = t.f;
+    if (Ge && t === b && (r & te) !== 0 && (r & At) === 0)
+      return;
+    if ((r & (be | re)) !== 0) {
+      if ((r & S) === 0) return;
+      t.f ^= S;
+    }
+  }
+  q.push(t);
+}
+function Rr(e, t, r, n) {
+  const i = Pr;
+  if (r.length === 0 && e.length === 0) {
+    n(t.map(i));
+    return;
+  }
+  var f = _, l = (
+    /** @type {Effect} */
+    b
+  ), s = Fr();
+  function o() {
+    Promise.all(r.map((u) => /* @__PURE__ */ Dr(u))).then((u) => {
+      s();
+      try {
+        n([...t.map(i), ...u]);
+      } catch (d) {
+        (l.f & $) === 0 && Me(d, l);
+      }
+      f == null || f.deactivate(), Fe();
+    }).catch((u) => {
+      Me(u, l);
+    });
+  }
+  e.length > 0 ? Promise.all(e).then(() => {
+    s();
+    try {
+      return o();
+    } finally {
+      f == null || f.deactivate(), Fe();
+    }
+  }) : o();
+}
+function Fr() {
+  var e = b, t = p, r = G, n = _;
+  return function(f = !0) {
+    ee(e), X(t), Ie(r), f && (n == null || n.activate());
+  };
+}
+function Fe() {
+  ee(null), X(null), Ie(null);
+}
+// @__NO_SIDE_EFFECTS__
+function Pr(e) {
+  var t = O | M, r = p !== null && (p.f & O) !== 0 ? (
+    /** @type {Derived} */
+    p
+  ) : null;
+  return b !== null && (b.f |= qe), {
+    ctx: G,
+    deps: null,
+    effects: null,
+    equals: St,
+    f: t,
+    fn: e,
+    reactions: null,
+    rv: 0,
+    v: (
+      /** @type {V} */
+      Be
+    ),
+    wv: 0,
+    parent: r ?? b,
+    ac: null
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Dr(e, t) {
+  let r = (
+    /** @type {Effect | null} */
+    b
+  );
+  r === null && mr();
+  var n = (
+    /** @type {Boundary} */
+    r.b
+  ), i = (
+    /** @type {Promise<V>} */
+    /** @type {unknown} */
+    void 0
+  ), f = jr(
+    /** @type {V} */
+    Be
+  ), l = !p, s = /* @__PURE__ */ new Map();
+  return Gr(() => {
+    var v;
+    var o = Et();
+    i = o.promise;
+    try {
+      Promise.resolve(e()).then(o.resolve, o.reject).then(() => {
+        u === _ && u.committed && u.deactivate(), Fe();
+      });
+    } catch (A) {
+      o.reject(A), Fe();
+    }
+    var u = (
+      /** @type {Batch} */
+      _
+    );
+    if (l) {
+      var d = !n.is_pending();
+      n.update_pending_count(1), u.increment(d), (v = s.get(u)) == null || v.reject(ve), s.delete(u), s.set(u, o);
+    }
+    const c = (A, E = void 0) => {
+      if (u.activate(), E)
+        E !== ve && (f.f |= J, ot(f, E));
+      else {
+        (f.f & J) !== 0 && (f.f ^= J), ot(f, A);
+        for (const [I, L] of s) {
+          if (s.delete(I), I === u) break;
+          L.reject(ve);
+        }
+      }
+      l && (n.update_pending_count(-1), u.decrement(d));
+    };
+    o.promise.then(c, (A) => c(null, A || "unknown"));
+  }), Lt(() => {
+    for (const o of s.values())
+      o.reject(ve);
+  }), new Promise((o) => {
+    function u(d) {
+      function c() {
+        d === i ? o(f) : u(i);
+      }
+      d.then(c, c);
+    }
+    u(i);
+  });
+}
+function It(e) {
+  var t = e.effects;
+  if (t !== null) {
+    e.effects = null;
+    for (var r = 0; r < t.length; r += 1)
+      U(
+        /** @type {Effect} */
+        t[r]
+      );
+  }
+}
+function Lr(e) {
+  for (var t = e.parent; t !== null; ) {
+    if ((t.f & O) === 0)
+      return (t.f & $) === 0 ? (
+        /** @type {Effect} */
+        t
+      ) : null;
+    t = t.parent;
+  }
+  return null;
+}
+function nt(e) {
+  var t, r = b;
+  ee(Lr(e));
+  try {
+    e.f &= ~ue, It(e), t = Wt(e);
+  } finally {
+    ee(r);
+  }
+  return t;
+}
+function Mt(e) {
+  var t = nt(e);
+  if (e.equals(t) || (_ != null && _.is_fork || (e.v = t), e.wv = Ht()), !Oe)
+    if (m !== null)
+      (Pe() || _ != null && _.is_fork) && m.set(e, t);
+    else {
+      var r = (e.f & B) === 0 ? Z : S;
+      k(e, r);
+    }
+}
+let Je = /* @__PURE__ */ new Set();
+const Q = /* @__PURE__ */ new Map();
+let Rt = !1;
+function jr(e, t) {
+  var r = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: e,
+    reactions: null,
+    equals: St,
+    rv: 0,
+    wv: 0
+  };
+  return r;
+}
+function ot(e, t) {
+  if (!e.equals(t)) {
+    var r = e.v;
+    Oe ? Q.set(e, t) : Q.set(e, r), e.v = t;
+    var n = Re.ensure();
+    n.capture(e, r), (e.f & O) !== 0 && ((e.f & M) !== 0 && nt(
+      /** @type {Derived} */
+      e
+    ), k(e, (e.f & B) !== 0 ? S : Z)), e.wv = Ht(), Ft(e, M), b !== null && (b.f & S) !== 0 && (b.f & (re | be)) === 0 && (j === null ? tn([e]) : j.push(e)), !n.is_fork && Je.size > 0 && !Rt && Vr();
+  }
+  return t;
+}
+function Vr() {
+  Rt = !1;
+  var e = se;
+  Le(!0);
+  const t = Array.from(Je);
+  try {
+    for (const r of t)
+      (r.f & S) !== 0 && k(r, Z), Ne(r) && Ae(r);
+  } finally {
+    Le(e);
+  }
+  Je.clear();
+}
+function Ft(e, t) {
+  var r = e.reactions;
+  if (r !== null)
+    for (var n = r.length, i = 0; i < n; i++) {
+      var f = r[i], l = f.f, s = (l & M) === 0;
+      if (s && k(f, t), (l & O) !== 0) {
+        var o = (
+          /** @type {Derived} */
+          f
+        );
+        m == null || m.delete(o), (l & ue) === 0 && (l & B && (f.f |= ue), Ft(o, Z));
+      } else s && ((l & te) !== 0 && V !== null && V.add(
+        /** @type {Effect} */
+        f
+      ), oe(
+        /** @type {Effect} */
+        f
+      ));
+    }
+}
+function at(e) {
+  try {
+    if (e !== null && typeof e == "object" && st in e)
+      return e[st];
+  } catch {
+  }
+  return e;
+}
+function xr(e, t) {
+  return Object.is(at(e), at(t));
+}
+var Ur, Br, qr;
+function ct(e = "") {
+  return document.createTextNode(e);
+}
+// @__NO_SIDE_EFFECTS__
+function Pt(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    Br.call(e)
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function Dt(e) {
+  return (
+    /** @type {TemplateNode | null} */
+    qr.call(e)
+  );
+}
+function Yr(e, t) {
+  return /* @__PURE__ */ Pt(e);
+}
+function zr() {
+  return !1;
+}
+function Hr(e, t) {
+  if (t) {
+    const r = document.body;
+    e.autofocus = !0, tt(() => {
+      document.activeElement === r && e.focus();
+    });
+  }
+}
+function it(e) {
+  var t = p, r = b;
+  X(null), ee(null);
+  try {
+    return e();
+  } finally {
+    X(t), ee(r);
+  }
+}
+function Kr(e, t) {
+  var r = t.last;
+  r === null ? t.last = t.first = e : (r.next = e, e.prev = r, t.last = e);
+}
+function ae(e, t, r) {
+  var n = b;
+  n !== null && (n.f & z) !== 0 && (e |= z);
+  var i = {
+    ctx: G,
+    deps: null,
+    nodes: null,
+    f: e | M | B,
+    first: null,
+    fn: t,
+    last: null,
+    next: null,
+    parent: n,
+    b: n && n.b,
+    prev: null,
+    teardown: null,
+    wv: 0,
+    ac: null
   };
+  if (r)
+    try {
+      Ae(i), i.f |= yt;
+    } catch (s) {
+      throw U(i), s;
+    }
+  else t !== null && oe(i);
+  var f = i;
+  if (r && f.deps === null && f.teardown === null && f.nodes === null && f.first === f.last && // either `null`, or a singular child
+  (f.f & qe) === 0 && (f = f.first, (e & te) !== 0 && (e & ye) !== 0 && f !== null && (f.f |= ye)), f !== null && (f.parent = n, n !== null && Kr(f, n), p !== null && (p.f & O) !== 0 && (e & be) === 0)) {
+    var l = (
+      /** @type {Derived} */
+      p
+    );
+    (l.effects ?? (l.effects = [])).push(f);
+  }
+  return i;
+}
+function Pe() {
+  return p !== null && !he;
+}
+function Lt(e) {
+  const t = ae(wr, null, !1);
+  return k(t, S), t.teardown = e, t;
+}
+function Wr(e) {
+  return ae(Xe | br, e, !1);
+}
+function jt(e) {
+  return ae(Xe, e, !1);
+}
+function Gr(e) {
+  return ae(Tt | qe, e, !0);
+}
+function Zr(e, t = 0) {
+  var r = ae(te | t, e, !0);
+  return r;
+}
+function Vt(e, t = 0) {
+  var r = ae(mt | t, e, !0);
+  return r;
+}
+function De(e) {
+  return ae(re | qe, e, !0);
+}
+function xt(e) {
+  var t = e.teardown;
+  if (t !== null) {
+    const r = Oe, n = p;
+    vt(!0), X(null);
+    try {
+      t.call(null);
+    } finally {
+      vt(r), X(n);
+    }
+  }
+}
+function Ut(e, t = !1) {
+  var r = e.first;
+  for (e.first = e.last = null; r !== null; ) {
+    const i = r.ac;
+    i !== null && it(() => {
+      i.abort(ve);
+    });
+    var n = r.next;
+    (r.f & be) !== 0 ? r.parent = null : U(r, t), r = n;
+  }
+}
+function $r(e) {
+  for (var t = e.first; t !== null; ) {
+    var r = t.next;
+    (t.f & re) === 0 && U(t), t = r;
+  }
+}
+function U(e, t = !0) {
+  var r = !1;
+  (t || (e.f & At) !== 0) && e.nodes !== null && e.nodes.end !== null && (Jr(
+    e.nodes.start,
+    /** @type {TemplateNode} */
+    e.nodes.end
+  ), r = !0), Ut(e, t && !r), Ve(e, 0), k(e, $);
+  var n = e.nodes && e.nodes.t;
+  if (n !== null)
+    for (const f of n)
+      f.stop();
+  xt(e);
+  var i = e.parent;
+  i !== null && i.first !== null && Bt(e), e.next = e.prev = e.teardown = e.ctx = e.deps = e.fn = e.nodes = e.ac = null;
+}
+function Jr(e, t) {
+  for (; e !== null; ) {
+    var r = e === t ? null : /* @__PURE__ */ Dt(e);
+    e.remove(), e = r;
+  }
+}
+function Bt(e) {
+  var t = e.parent, r = e.prev, n = e.next;
+  r !== null && (r.next = n), n !== null && (n.prev = r), t !== null && (t.first === e && (t.first = n), t.last === e && (t.last = r));
+}
+function Qr(e, t, r = !0) {
+  var n = [];
+  qt(e, n, !0);
+  var i = () => {
+    r && U(e), t && t();
+  }, f = n.length;
+  if (f > 0) {
+    var l = () => --f || i();
+    for (var s of n)
+      s.out(l);
+  } else
+    i();
+}
+function qt(e, t, r) {
+  if ((e.f & z) === 0) {
+    e.f ^= z;
+    var n = e.nodes && e.nodes.t;
+    if (n !== null)
+      for (const s of n)
+        (s.is_global || r) && t.push(s);
+    for (var i = e.first; i !== null; ) {
+      var f = i.next, l = (i.f & ye) !== 0 || // If this is a branch effect without a block effect parent,
+      // it means the parent block effect was pruned. In that case,
+      // transparency information was transferred to the branch effect.
+      (i.f & re) !== 0 && (e.f & te) !== 0;
+      qt(i, t, l ? r : !1), i = f;
+    }
+  }
+}
+function Xr(e) {
+  Yt(e, !0);
+}
+function Yt(e, t) {
+  if ((e.f & z) !== 0) {
+    e.f ^= z, (e.f & S) === 0 && (k(e, M), oe(e));
+    for (var r = e.first; r !== null; ) {
+      var n = r.next, i = (r.f & ye) !== 0 || (r.f & re) !== 0;
+      Yt(r, i ? t : !1), r = n;
+    }
+    var f = e.nodes && e.nodes.t;
+    if (f !== null)
+      for (const l of f)
+        (l.is_global || t) && l.in();
+  }
+}
+function en(e, t) {
+  if (e.nodes)
+    for (var r = e.nodes.start, n = e.nodes.end; r !== null; ) {
+      var i = r === n ? null : /* @__PURE__ */ Dt(r);
+      t.append(r), r = i;
+    }
+}
+let se = !1;
+function Le(e) {
+  se = e;
+}
+let Oe = !1;
+function vt(e) {
+  Oe = e;
+}
+let p = null, he = !1;
+function X(e) {
+  p = e;
+}
+let b = null;
+function ee(e) {
+  b = e;
+}
+let W = null, C = null, P = 0, j = null;
+function tn(e) {
+  j = e;
+}
+let zt = 1, je = 0;
+function Ht() {
+  return ++zt;
+}
+function Ne(e) {
+  var t = e.f;
+  if ((t & M) !== 0)
+    return !0;
+  if (t & O && (e.f &= ~ue), (t & Z) !== 0) {
+    var r = e.deps;
+    if (r !== null)
+      for (var n = r.length, i = 0; i < n; i++) {
+        var f = r[i];
+        if (Ne(
+          /** @type {Derived} */
+          f
+        ) && Mt(
+          /** @type {Derived} */
+          f
+        ), f.wv > e.wv)
+          return !0;
+      }
+    (t & B) !== 0 && // During time traveling we don't want to reset the status so that
+    // traversal of the graph in the other batches still happens
+    m === null && k(e, S);
+  }
+  return !1;
+}
+function Kt(e, t, r = !0) {
+  var n = e.reactions;
+  if (n !== null && !(W != null && W.includes(e)))
+    for (var i = 0; i < n.length; i++) {
+      var f = n[i];
+      (f.f & O) !== 0 ? Kt(
+        /** @type {Derived} */
+        f,
+        t,
+        !1
+      ) : t === f && (r ? k(f, M) : (f.f & S) !== 0 && k(f, Z), oe(
+        /** @type {Effect} */
+        f
+      ));
+    }
+}
+function Wt(e) {
+  var A;
+  var t = C, r = P, n = j, i = p, f = W, l = G, s = he, o = e.f;
+  C = /** @type {null | Value[]} */
+  null, P = 0, j = null, p = (o & (re | be)) === 0 ? e : null, W = null, Ie(e.ctx), he = !1, ++je, e.ac !== null && (it(() => {
+    e.ac.abort(ve);
+  }), e.ac = null);
+  try {
+    e.f |= We;
+    var u = (
+      /** @type {Function} */
+      e.fn
+    ), d = u(), c = e.deps;
+    if (C !== null) {
+      var v;
+      if (Ve(e, P), c !== null && P > 0)
+        for (c.length = P + C.length, v = 0; v < C.length; v++)
+          c[P + v] = C[v];
+      else
+        e.deps = c = C;
+      if (Pe() && (e.f & B) !== 0)
+        for (v = P; v < c.length; v++)
+          ((A = c[v]).reactions ?? (A.reactions = [])).push(e);
+    } else c !== null && P < c.length && (Ve(e, P), c.length = P);
+    if (Or() && j !== null && !he && c !== null && (e.f & (O | Z | M)) === 0)
+      for (v = 0; v < /** @type {Source[]} */
+      j.length; v++)
+        Kt(
+          j[v],
+          /** @type {Effect} */
+          e
+        );
+    return i !== null && i !== e && (je++, j !== null && (n === null ? n = j : n.push(.../** @type {Source[]} */
+    j))), (e.f & J) !== 0 && (e.f ^= J), d;
+  } catch (E) {
+    return Cr(E);
+  } finally {
+    e.f ^= We, C = t, P = r, j = n, p = i, W = f, Ie(l), he = s;
+  }
+}
+function rn(e, t) {
+  let r = t.reactions;
+  if (r !== null) {
+    var n = dr.call(r, e);
+    if (n !== -1) {
+      var i = r.length - 1;
+      i === 0 ? r = t.reactions = null : (r[n] = r[i], r.pop());
+    }
+  }
+  r === null && (t.f & O) !== 0 && // 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
+  (C === null || !C.includes(t)) && (k(t, Z), (t.f & B) !== 0 && (t.f ^= B, t.f &= ~ue), It(
+    /** @type {Derived} **/
+    t
+  ), Ve(
+    /** @type {Derived} **/
+    t,
+    0
+  ));
+}
+function Ve(e, t) {
+  var r = e.deps;
+  if (r !== null)
+    for (var n = t; n < r.length; n++)
+      rn(e, r[n]);
+}
+function Ae(e) {
+  var t = e.f;
+  if ((t & $) === 0) {
+    k(e, S);
+    var r = b, n = se;
+    b = e, se = !0;
+    try {
+      (t & (te | mt)) !== 0 ? $r(e) : Ut(e), xt(e);
+      var i = Wt(e);
+      e.teardown = typeof i == "function" ? i : null, e.wv = zt;
+      var f;
+      Ke && Tr && (e.f & M) !== 0 && e.deps;
+    } finally {
+      se = n, b = r;
+    }
+  }
+}
+function nn(e) {
+  var t = e.f, r = (t & O) !== 0;
+  if (p !== null && !he) {
+    var n = b !== null && (b.f & $) !== 0;
+    if (!n && !(W != null && W.includes(e))) {
+      var i = p.deps;
+      if ((p.f & We) !== 0)
+        e.rv < je && (e.rv = je, C === null && i !== null && i[P] === e ? P++ : C === null ? C = [e] : C.includes(e) || C.push(e));
+      else {
+        (p.deps ?? (p.deps = [])).push(e);
+        var f = e.reactions;
+        f === null ? e.reactions = [p] : f.includes(p) || f.push(p);
+      }
+    }
+  }
+  if (Oe) {
+    if (Q.has(e))
+      return Q.get(e);
+    if (r) {
+      var l = (
+        /** @type {Derived} */
+        e
+      ), s = l.v;
+      return ((l.f & S) === 0 && l.reactions !== null || Zt(l)) && (s = nt(l)), Q.set(l, s), s;
+    }
+  } else r && (!(m != null && m.has(e)) || _ != null && _.is_fork && !Pe()) && (l = /** @type {Derived} */
+  e, Ne(l) && Mt(l), se && Pe() && (l.f & B) === 0 && Gt(l));
+  if (m != null && m.has(e))
+    return m.get(e);
+  if ((e.f & J) !== 0)
+    throw e.v;
+  return e.v;
+}
+function Gt(e) {
+  if (e.deps !== null) {
+    e.f ^= B;
+    for (const t of e.deps)
+      (t.reactions ?? (t.reactions = [])).push(e), (t.f & O) !== 0 && (t.f & B) === 0 && Gt(
+        /** @type {Derived} */
+        t
+      );
+  }
+}
+function Zt(e) {
+  if (e.v === Be) return !0;
+  if (e.deps === null) return !1;
+  for (const t of e.deps)
+    if (Q.has(t) || (t.f & O) !== 0 && Zt(
+      /** @type {Derived} */
+      t
+    ))
+      return !0;
+  return !1;
+}
+const fn = -7169;
+function k(e, t) {
+  e.f = e.f & fn | t;
+}
+const ln = /* @__PURE__ */ new Set(), sn = /* @__PURE__ */ new Set();
+function un(e, t, r, n = {}) {
+  function i(f) {
+    if (n.capture || an.call(t, f), !f.cancelBubble)
+      return it(() => r == null ? void 0 : r.call(this, f));
+  }
+  return e.startsWith("pointer") || e.startsWith("touch") || e === "wheel" ? tt(() => {
+    t.addEventListener(e, i, n);
+  }) : t.addEventListener(e, i, n), i;
+}
+function on(e) {
+  for (var t = 0; t < e.length; t++)
+    ln.add(e[t]);
+  for (var r of sn)
+    r(e);
+}
+let dt = null;
+function an(e) {
+  var L;
+  var t = this, r = (
+    /** @type {Node} */
+    t.ownerDocument
+  ), n = e.type, i = ((L = e.composedPath) == null ? void 0 : L.call(e)) || [], f = (
+    /** @type {null | Element} */
+    i[0] || e.target
+  );
+  dt = e;
+  var l = 0, s = dt === e && e.__root;
+  if (s) {
+    var o = i.indexOf(s);
+    if (o !== -1 && (t === document || t === /** @type {any} */
+    window)) {
+      e.__root = t;
+      return;
+    }
+    var u = i.indexOf(t);
+    if (u === -1)
+      return;
+    o <= u && (l = o);
+  }
+  if (f = /** @type {Element} */
+  i[l] || e.target, f !== t) {
+    hr(e, "currentTarget", {
+      configurable: !0,
+      get() {
+        return f || r;
+      }
+    });
+    var d = p, c = b;
+    X(null), ee(null);
+    try {
+      for (var v, A = []; f !== null; ) {
+        var E = f.assignedSlot || f.parentNode || /** @type {any} */
+        f.host || null;
+        try {
+          var I = f["__" + n];
+          I != null && (!/** @type {any} */
+          f.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
+          e.target === f) && I.call(f, e);
+        } catch (h) {
+          v ? A.push(h) : v = h;
+        }
+        if (e.cancelBubble || E === t || E === null)
+          break;
+        f = E;
+      }
+      if (v) {
+        for (let h of A)
+          queueMicrotask(() => {
+            throw h;
+          });
+        throw v;
+      }
+    } finally {
+      e.__root = t, delete e.currentTarget, X(d), ee(c);
+    }
+  }
+}
+function cn(e) {
+  var t = document.createElement("template");
+  return t.innerHTML = e.replaceAll("<!>", "<!---->"), t.content;
+}
+function vn(e, t) {
+  var r = (
+    /** @type {Effect} */
+    b
+  );
+  r.nodes === null && (r.nodes = { start: e, end: t, a: null, t: null });
+}
+// @__NO_SIDE_EFFECTS__
+function dn(e, t) {
+  var r = (t & or) !== 0, n, i = !e.startsWith("<!>");
+  return () => {
+    n === void 0 && (n = cn(i ? e : "<!>" + e), n = /** @type {TemplateNode} */
+    /* @__PURE__ */ Pt(n));
+    var f = (
+      /** @type {TemplateNode} */
+      r || Ur ? document.importNode(n, !0) : n.cloneNode(!0)
+    );
+    return vn(f, f), f;
+  };
+}
+function hn(e, t) {
+  e !== null && e.before(
+    /** @type {Node} */
+    t
+  );
+}
+function _n(e) {
+  return e.endsWith("capture") && e !== "gotpointercapture" && e !== "lostpointercapture";
+}
+const pn = [
+  "beforeinput",
+  "click",
+  "change",
+  "dblclick",
+  "contextmenu",
+  "focusin",
+  "focusout",
+  "input",
+  "keydown",
+  "keyup",
+  "mousedown",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "mouseup",
+  "pointerdown",
+  "pointermove",
+  "pointerout",
+  "pointerover",
+  "pointerup",
+  "touchend",
+  "touchmove",
+  "touchstart"
+];
+function gn(e) {
+  return pn.includes(e);
+}
+const wn = {
+  // 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 bn(e) {
+  return e = e.toLowerCase(), wn[e] ?? e;
+}
+var x, Y, D, le, Se, ke, Ue;
+class En {
+  /**
+   * @param {TemplateNode} anchor
+   * @param {boolean} transition
+   */
+  constructor(t, r = !0) {
+    /** @type {TemplateNode} */
+    H(this, "anchor");
+    /** @type {Map<Batch, Key>} */
+    T(this, x, /* @__PURE__ */ new Map());
+    /**
+     * Map of keys to effects that are currently rendered in the DOM.
+     * These effects are visible and actively part of the document tree.
+     * Example:
+     * ```
+     * {#if condition}
+     * 	foo
+     * {:else}
+     * 	bar
+     * {/if}
+     * ```
+     * Can result in the entries `true->Effect` and `false->Effect`
+     * @type {Map<Key, Effect>}
+     */
+    T(this, Y, /* @__PURE__ */ new Map());
+    /**
+     * Similar to #onscreen with respect to the keys, but contains branches that are not yet
+     * in the DOM, because their insertion is deferred.
+     * @type {Map<Key, Branch>}
+     */
+    T(this, D, /* @__PURE__ */ new Map());
+    /**
+     * Keys of effects that are currently outroing
+     * @type {Set<Key>}
+     */
+    T(this, le, /* @__PURE__ */ new Set());
+    /**
+     * Whether to pause (i.e. outro) on change, or destroy immediately.
+     * This is necessary for `<svelte:element>`
+     */
+    T(this, Se, !0);
+    T(this, ke, () => {
+      var t = (
+        /** @type {Batch} */
+        _
+      );
+      if (a(this, x).has(t)) {
+        var r = (
+          /** @type {Key} */
+          a(this, x).get(t)
+        ), n = a(this, Y).get(r);
+        if (n)
+          Xr(n), a(this, le).delete(r);
+        else {
+          var i = a(this, D).get(r);
+          i && (a(this, Y).set(r, i.effect), a(this, D).delete(r), i.fragment.lastChild.remove(), this.anchor.before(i.fragment), n = i.effect);
+        }
+        for (const [f, l] of a(this, x)) {
+          if (a(this, x).delete(f), f === t)
+            break;
+          const s = a(this, D).get(l);
+          s && (U(s.effect), a(this, D).delete(l));
+        }
+        for (const [f, l] of a(this, Y)) {
+          if (f === r || a(this, le).has(f)) continue;
+          const s = () => {
+            if (Array.from(a(this, x).values()).includes(f)) {
+              var u = document.createDocumentFragment();
+              en(l, u), u.append(ct()), a(this, D).set(f, { effect: l, fragment: u });
+            } else
+              U(l);
+            a(this, le).delete(f), a(this, Y).delete(f);
+          };
+          a(this, Se) || !n ? (a(this, le).add(f), Qr(l, s, !1)) : s();
+        }
+      }
+    });
+    /**
+     * @param {Batch} batch
+     */
+    T(this, Ue, (t) => {
+      a(this, x).delete(t);
+      const r = Array.from(a(this, x).values());
+      for (const [n, i] of a(this, D))
+        r.includes(n) || (U(i.effect), a(this, D).delete(n));
+    });
+    this.anchor = t, K(this, Se, r);
+  }
+  /**
+   *
+   * @param {any} key
+   * @param {null | ((target: TemplateNode) => void)} fn
+   */
+  ensure(t, r) {
+    var n = (
+      /** @type {Batch} */
+      _
+    ), i = zr();
+    if (r && !a(this, Y).has(t) && !a(this, D).has(t))
+      if (i) {
+        var f = document.createDocumentFragment(), l = ct();
+        f.append(l), a(this, D).set(t, {
+          effect: De(() => r(l)),
+          fragment: f
+        });
+      } else
+        a(this, Y).set(
+          t,
+          De(() => r(this.anchor))
+        );
+    if (a(this, x).set(n, t), i) {
+      for (const [s, o] of a(this, Y))
+        s === t ? n.skipped_effects.delete(o) : n.skipped_effects.add(o);
+      for (const [s, o] of a(this, D))
+        s === t ? n.skipped_effects.delete(o.effect) : n.skipped_effects.add(o.effect);
+      n.oncommit(a(this, ke)), n.ondiscard(a(this, Ue));
+    } else
+      a(this, ke).call(this);
+  }
+}
+x = new WeakMap(), Y = new WeakMap(), D = new WeakMap(), le = new WeakMap(), Se = new WeakMap(), ke = new WeakMap(), Ue = new WeakMap();
+function mn(e, t, ...r) {
+  var n = new En(e);
+  Zr(() => {
+    const i = t() ?? null;
+    n.ensure(i, i && ((f) => i(f, ...r)));
+  }, ye);
+}
+function yn(e, t) {
+  var r = void 0, n;
+  Vt(() => {
+    r !== (r = t()) && (n && (U(n), n = null), r && (n = De(() => {
+      jt(() => (
+        /** @type {(node: Element) => void} */
+        r(e)
+      ));
+    })));
+  });
+}
+function $t(e) {
+  var t, r, n = "";
+  if (typeof e == "string" || typeof e == "number") n += e;
+  else if (typeof e == "object") if (Array.isArray(e)) {
+    var i = e.length;
+    for (t = 0; t < i; t++) e[t] && (r = $t(e[t])) && (n && (n += " "), n += r);
+  } else for (r in e) e[r] && (n && (n += " "), n += r);
+  return n;
+}
+function An() {
+  for (var e, t, r = 0, n = "", i = arguments.length; r < i; r++) (e = arguments[r]) && (t = $t(e)) && (n && (n += " "), n += t);
+  return n;
+}
+function Tn(e) {
+  return typeof e == "object" ? An(e) : e ?? "";
+}
+const ht = [...` 	
+\r\f \v\uFEFF`];
+function Sn(e, t, r) {
+  var n = e == null ? "" : "" + e;
+  if (r) {
+    for (var i in r)
+      if (r[i])
+        n = n ? n + " " + i : i;
+      else if (n.length)
+        for (var f = i.length, l = 0; (l = n.indexOf(i, l)) >= 0; ) {
+          var s = l + f;
+          (l === 0 || ht.includes(n[l - 1])) && (s === n.length || ht.includes(n[s])) ? n = (l === 0 ? "" : n.substring(0, l)) + n.substring(s + 1) : l = s;
+        }
+  }
+  return n === "" ? null : n;
+}
+function _t(e, t = !1) {
+  var r = t ? " !important;" : ";", n = "";
+  for (var i in e) {
+    var f = e[i];
+    f != null && f !== "" && (n += " " + i + ": " + f + r);
+  }
+  return n;
+}
+function ze(e) {
+  return e[0] !== "-" || e[1] !== "-" ? e.toLowerCase() : e;
+}
+function kn(e, t) {
+  if (t) {
+    var r = "", n, i;
+    if (Array.isArray(t) ? (n = t[0], i = t[1]) : n = t, e) {
+      e = String(e).replaceAll(/\s*\/\*.*?\*\/\s*/g, "").trim();
+      var f = !1, l = 0, s = !1, o = [];
+      n && o.push(...Object.keys(n).map(ze)), i && o.push(...Object.keys(i).map(ze));
+      var u = 0, d = -1;
+      const I = e.length;
+      for (var c = 0; c < I; c++) {
+        var v = e[c];
+        if (s ? v === "/" && e[c - 1] === "*" && (s = !1) : f ? f === v && (f = !1) : v === "/" && e[c + 1] === "*" ? s = !0 : v === '"' || v === "'" ? f = v : v === "(" ? l++ : v === ")" && l--, !s && f === !1 && l === 0) {
+          if (v === ":" && d === -1)
+            d = c;
+          else if (v === ";" || c === I - 1) {
+            if (d !== -1) {
+              var A = ze(e.substring(u, d).trim());
+              if (!o.includes(A)) {
+                v !== ";" && c++;
+                var E = e.substring(u, c).trim();
+                r += " " + E + ";";
+              }
+            }
+            u = c + 1, d = -1;
+          }
+        }
+      }
+    }
+    return n && (r += _t(n)), i && (r += _t(i, !0)), r = r.trim(), r === "" ? null : r;
+  }
+  return e == null ? null : String(e);
+}
+function On(e, t, r, n, i, f) {
+  var l = e.__className;
+  if (l !== r || l === void 0) {
+    var s = Sn(r, n, f);
+    s == null ? e.removeAttribute("class") : t ? e.className = s : e.setAttribute("class", s), e.__className = r;
+  } else if (f && i !== f)
+    for (var o in f) {
+      var u = !!f[o];
+      (i == null || u !== !!i[o]) && e.classList.toggle(o, u);
+    }
+  return f;
+}
+function He(e, t = {}, r, n) {
+  for (var i in r) {
+    var f = r[i];
+    t[i] !== f && (r[i] == null ? e.style.removeProperty(i) : e.style.setProperty(i, f, n));
+  }
+}
+function Nn(e, t, r, n) {
+  var i = e.__style;
+  if (i !== t) {
+    var f = kn(t, n);
+    f == null ? e.removeAttribute("style") : e.style.cssText = f, e.__style = t;
+  } else n && (Array.isArray(n) ? (He(e, r == null ? void 0 : r[0], n[0]), He(e, r == null ? void 0 : r[1], n[1], "important")) : He(e, r, n));
+  return n;
+}
+function Qe(e, t, r = !1) {
+  if (e.multiple) {
+    if (t == null)
+      return;
+    if (!vr(t))
+      return Ar();
+    for (var n of e.options)
+      n.selected = t.includes(pt(n));
+    return;
+  }
+  for (n of e.options) {
+    var i = pt(n);
+    if (xr(i, t)) {
+      n.selected = !0;
+      return;
+    }
+  }
+  (!r || t !== void 0) && (e.selectedIndex = -1);
+}
+function Cn(e) {
+  var t = new MutationObserver(() => {
+    Qe(e, e.__value);
+  });
+  t.observe(e, {
+    // Listen to option element changes
+    childList: !0,
+    subtree: !0,
+    // because of <optgroup>
+    // Listen to option element value attribute changes
+    // (doesn't get notified of select value changes,
+    // because that property is not reflected as an attribute)
+    attributes: !0,
+    attributeFilter: ["value"]
+  }), Lt(() => {
+    t.disconnect();
+  });
+}
+function pt(e) {
+  return "__value" in e ? e.__value : e.value;
+}
+const Ee = Symbol("class"), me = Symbol("style"), Jt = Symbol("is custom element"), Qt = Symbol("is html");
+function In(e, t) {
+  t ? e.hasAttribute("selected") || e.setAttribute("selected", "") : e.removeAttribute("selected");
+}
+function gt(e, t, r, n) {
+  var i = Xt(e);
+  i[t] !== (i[t] = r) && (t === "loading" && (e[Er] = r), r == null ? e.removeAttribute(t) : typeof r != "string" && er(e).includes(t) ? e[t] = r : e.setAttribute(t, r));
+}
+function Mn(e, t, r, n, i = !1, f = !1) {
+  var l = Xt(e), s = l[Jt], o = !l[Qt], u = t || {}, d = e.tagName === "OPTION";
+  for (var c in t)
+    c in r || (r[c] = null);
+  r.class ? r.class = Tn(r.class) : r[Ee] && (r.class = null), r[me] && (r.style ?? (r.style = null));
+  var v = er(e);
+  for (const g in r) {
+    let w = r[g];
+    if (d && g === "value" && w == null) {
+      e.value = e.__value = "", u[g] = w;
+      continue;
+    }
+    if (g === "class") {
+      var A = e.namespaceURI === "http://www.w3.org/1999/xhtml";
+      On(e, A, w, n, t == null ? void 0 : t[Ee], r[Ee]), u[g] = w, u[Ee] = r[Ee];
+      continue;
+    }
+    if (g === "style") {
+      Nn(e, w, t == null ? void 0 : t[me], r[me]), u[g] = w, u[me] = r[me];
+      continue;
+    }
+    var E = u[g];
+    if (!(w === E && !(w === void 0 && e.hasAttribute(g)))) {
+      u[g] = w;
+      var I = g[0] + g[1];
+      if (I !== "$$")
+        if (I === "on") {
+          const R = {}, ce = "$$" + g;
+          let N = g.slice(2);
+          var L = gn(N);
+          if (_n(N) && (N = N.slice(0, -7), R.capture = !0), !L && E) {
+            if (w != null) continue;
+            e.removeEventListener(N, u[ce], R), u[ce] = null;
+          }
+          if (w != null)
+            if (L)
+              e[`__${N}`] = w, on([N]);
+            else {
+              let tr = function(rr) {
+                u[g].call(this, rr);
+              };
+              u[ce] = un(N, e, tr, R);
+            }
+          else L && (e[`__${N}`] = void 0);
+        } else if (g === "style")
+          gt(e, g, w);
+        else if (g === "autofocus")
+          Hr(
+            /** @type {HTMLElement} */
+            e,
+            !!w
+          );
+        else if (!s && (g === "__value" || g === "value" && w != null))
+          e.value = e.__value = w;
+        else if (g === "selected" && d)
+          In(
+            /** @type {HTMLOptionElement} */
+            e,
+            w
+          );
+        else {
+          var h = g;
+          o || (h = bn(h));
+          var ft = h === "defaultValue" || h === "defaultChecked";
+          if (w == null && !s && !ft)
+            if (l[g] = null, h === "value" || h === "checked") {
+              let R = (
+                /** @type {HTMLInputElement} */
+                e
+              );
+              const ce = t === void 0;
+              if (h === "value") {
+                let N = R.defaultValue;
+                R.removeAttribute(h), R.defaultValue = N, R.value = R.__value = ce ? N : null;
+              } else {
+                let N = R.defaultChecked;
+                R.removeAttribute(h), R.defaultChecked = N, R.checked = ce ? N : !1;
+              }
+            } else
+              e.removeAttribute(g);
+          else ft || v.includes(h) && (s || typeof w != "string") ? (e[h] = w, h in l && (l[h] = Be)) : typeof w != "function" && gt(e, h, w);
+        }
+    }
+  }
+  return u;
+}
+function Rn(e, t, r = [], n = [], i = [], f, l = !1, s = !1) {
+  Rr(i, r, n, (o) => {
+    var u = void 0, d = {}, c = e.nodeName === "SELECT", v = !1;
+    if (Vt(() => {
+      var E = t(...o.map(nn)), I = Mn(
+        e,
+        u,
+        E,
+        f,
+        l,
+        s
+      );
+      v && c && "value" in E && Qe(
+        /** @type {HTMLSelectElement} */
+        e,
+        E.value
+      );
+      for (let h of Object.getOwnPropertySymbols(d))
+        E[h] || U(d[h]);
+      for (let h of Object.getOwnPropertySymbols(E)) {
+        var L = E[h];
+        h.description === cr && (!u || L !== u[h]) && (d[h] && U(d[h]), d[h] = De(() => yn(e, () => L))), I[h] = L;
+      }
+      u = I;
+    }), c) {
+      var A = (
+        /** @type {HTMLSelectElement} */
+        e
+      );
+      jt(() => {
+        Qe(
+          A,
+          /** @type {Record<string | symbol, any>} */
+          u.value,
+          !0
+        ), Cn(A);
+      });
+    }
+    v = !0;
+  });
+}
+function Xt(e) {
+  return (
+    /** @type {Record<string | symbol, unknown>} **/
+    // @ts-expect-error
+    e.__attributes ?? (e.__attributes = {
+      [Jt]: e.nodeName.includes("-"),
+      [Qt]: e.namespaceURI === ar
+    })
+  );
+}
+var wt = /* @__PURE__ */ new Map();
+function er(e) {
+  var t = e.getAttribute("is") || e.nodeName, r = wt.get(t);
+  if (r) return r;
+  wt.set(t, r = []);
+  for (var n, i = e, f = Element.prototype; f !== i; ) {
+    n = _r(i);
+    for (var l in n)
+      n[l].set && r.push(l);
+    i = pr(i);
+  }
+  return r;
+}
+const Fn = {
+  get(e, t) {
+    if (!e.exclude.includes(t))
+      return e.props[t];
+  },
+  set(e, t) {
+    return !1;
+  },
+  getOwnPropertyDescriptor(e, t) {
+    if (!e.exclude.includes(t) && t in e.props)
+      return {
+        enumerable: !0,
+        configurable: !0,
+        value: e.props[t]
+      };
+  },
+  has(e, t) {
+    return e.exclude.includes(t) ? !1 : t in e.props;
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(e.props).filter((t) => !e.exclude.includes(t));
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function Pn(e, t, r) {
+  return new Proxy(
+    { props: e, exclude: t },
+    Fn
+  );
+}
+function Dn(e, t, r, n) {
+  var i = (
+    /** @type {V} */
+    n
+  ), f = !0, l = () => (f && (f = !1, i = /** @type {V} */
+  n), i), s;
+  s = /** @type {V} */
+  e[t], s === void 0 && n !== void 0 && (s = l());
+  var o;
+  return o = () => {
+    var u = (
+      /** @type {V} */
+      e[t]
+    );
+    return u === void 0 ? l() : (f = !0, u);
+  }, o;
+}
+var Ln = /* @__PURE__ */ dn("<div><!></div>");
+function qn(e, t) {
+  Sr(t, !0);
+  const r = Dn(t, "selector", 3, "> a"), n = /* @__PURE__ */ Pn(t, [
+    "$$slots",
+    "$$events",
+    "$$legacy",
+    "children",
+    "id",
+    "selector",
+    "ref",
+    "options"
+  ]);
+  let i;
+  const f = `vvw-gallery-${Math.random().toString(36).slice(2)}`;
+  fr(() => {
+    const o = t.id || f;
+    i = jn({ ...t.options, elements: `#${o} ${r()}` }), t.ref && i && Object.assign(t.ref, i);
+  });
+  var l = Ln();
+  Rn(l, () => ({ ...n, id: t.id || f }));
+  var s = Yr(l);
+  mn(s, () => t.children), hn(e, l), kr();
 }
-function x(e, o) {
-  let r = null;
-  const { selector: m = "> a", ref: t, ...l } = o, u = o.id || e.id || `vvw-gallery-${Math.random().toString(36).substr(2, 9)}`;
-  e.id || (e.id = u);
-  function f() {
-    r = d({
-      ...l,
-      elements: l.elements || `#${u} ${m}`
-    }), t && r && Object.assign(t, r);
-  }
-  return y(() => {
-    f();
+function jn(e) {
+  let t = null;
+  const r = () => (t || (t = sr(e)), t);
+  return lr(() => {
+    t == null || t.destroy(), t = null;
   }), {
-    destroy() {
-      r == null || r.destroy(), r = null;
+    open: (n = 0) => {
+      var i;
+      return (i = r()) == null ? void 0 : i.open(n);
+    },
+    close: () => {
+      var n;
+      return ((n = r()) == null ? void 0 : n.close()) ?? Promise.resolve();
+    },
+    reset: () => {
+      var n;
+      return (n = r()) == null ? void 0 : n.reset();
+    },
+    next: () => {
+      var n;
+      return (n = r()) == null ? void 0 : n.next();
+    },
+    prev: () => {
+      var n;
+      return (n = r()) == null ? void 0 : n.prev();
+    },
+    zoomIn: () => {
+      var n;
+      return (n = r()) == null ? void 0 : n.zoomIn();
+    },
+    zoomOut: () => {
+      var n;
+      return (n = r()) == null ? void 0 : n.zoomOut();
+    },
+    getCurrentIndex: () => {
+      var n;
+      return ((n = r()) == null ? void 0 : n.getCurrentIndex()) ?? -1;
+    },
+    view: (n) => {
+      var i;
+      return (i = r()) == null ? void 0 : i.view(n);
+    },
+    destroy: () => {
+      t == null || t.destroy(), t = null;
     }
   };
 }
 export {
-  x as createVistaView,
-  w as useVistaView
+  qn as VistaView,
+  jn as useVistaView
 };