@mjsz-vbr-elements/core 2.30.2 → 2.31.1

package/dist/useSort-D5U_wkle.js

@@ -0,0 +1,912 @@
+/**
+ * name: @mjsz-vbr-elements/core
+ * version: v2.31.1 - 27/10/2025, 20:57:06
+ * (c) 2025
+ * description: Data visualization for MJSZ VBR
+ * author: Ákos Stegner <akos.stegner@gmail.com>
+ */
+import { ref as R, watch as S, unref as C, reactive as Te, defineComponent as De, h as Le, computed as j, provide as we, inject as Ee, onErrorCaptured as _e, nextTick as se, shallowRef as k, shallowReadonly as xe, toRef as We, readonly as Oe, customRef as Fe, isRef as Ie, getCurrentScope as Me, onScopeDispose as je, toValue as x } from "vue";
+import { _ as Be, C as $e, D as fe, E as Ge, F as ze, x as de, G as H, H as ee, I as q, w as Ke, u as Ue, v as He, J as qe, A as Je } from "./datetime-bWwGbGlR.js";
+import { SORT_STATE_DESCEND as ne, SORT_STATE_ORIGINAL as X, SORT_STATE_ASCEND as Z } from "./constants.js";
+var Ve = /* @__PURE__ */ Be(function e(t, r, n) {
+  return $e(function(s, o, a) {
+    return fe(o) && fe(a) ? e(t, o, a) : t(s, o, a);
+  }, r, n);
+}), Qe = /* @__PURE__ */ Ge(function(t, r) {
+  return Ve(function(n, s, o) {
+    return o;
+  }, t, r);
+});
+function Ot(e, t, r, n) {
+  const s = R(""), o = R(!1), a = (u) => {
+    const i = ze(de(t), u), m = i.length > 0;
+    if (o.value = m, !m)
+      return s.value = "";
+    const f = i.map((d) => ({
+      team: d.team.longName,
+      points: Math.abs(de(t, d))
+    })).map((d) => r(`additionalText.${t}.content`, d)).join(", ");
+    s.value = [
+      r(`additionalText.${t}.prependix`),
+      f,
+      ...r(`additionalText.${t}.appendix`) && [r(`additionalText.${t}.appendix`)]
+    ].join(" ");
+  };
+  return S(e, a, { immediate: !0 }), S(
+    () => C(n),
+    () => a(C(e))
+  ), {
+    text: s,
+    isVisible: o
+  };
+}
+const Se = Symbol("I18nContext"), O = Te({
+  messages: {},
+  locale: "",
+  fallbackLocale: ""
+});
+function It({ messages: e = {}, locale: t = "", fallbackLocale: r = "" }) {
+  O.messages = Qe(O.messages, e), O.locale = t, O.fallbackLocale = r;
+  const n = (i, m = {}) => {
+    const v = !Ue(m), f = H(ee, q(".", i));
+    return j(() => {
+      const p = Ae(f);
+      return v ? Ze(p, m) : p;
+    }).value;
+  }, s = (i) => {
+    const m = H(ee, q(".", i));
+    return !!ae(O.locale, m, O.messages);
+  }, o = (i) => {
+    O.locale = i;
+  }, u = {
+    locale: j({
+      get() {
+        return O.locale;
+      },
+      set(i) {
+        O.locale = i;
+      }
+    }),
+    setLocale: o,
+    translate: n,
+    hasTranslation: s
+  };
+  return we(Se, u), {
+    translate: n
+  };
+}
+function Xe(e) {
+  e && (O.messages = e.messages, O.locale = e.locale, O.fallbackLocale = e.fallbackLocale);
+  const t = Ye();
+  return {
+    locale: t.locale,
+    t: t.translate,
+    setLocale: t.setLocale,
+    hasTranslation: t.hasTranslation
+  };
+}
+function Ye() {
+  const e = Ee(Se, null);
+  if (e === null)
+    throw new Error("Provider is missing a parent component.");
+  return e;
+}
+function Ae(e = []) {
+  let t = ae(O.locale, e, O.messages);
+  return !t && O.fallbackLocale && (t = ae(O.fallbackLocale, e, O.messages)), t || e.join(".");
+}
+function ae(e, t, r) {
+  return Ke([e, ...t], r);
+}
+function Ze(e, t) {
+  return e.replace(/\{(\w+)\}/g, (r, n) => t[n]);
+}
+const St = De({
+  props: {
+    tag: {
+      type: String,
+      default: "div"
+    },
+    path: {
+      type: String,
+      defult: ""
+    }
+  },
+  setup(e, { slots: t }) {
+    const r = H(ee, q(".", e.path)), n = Ae(r), s = q(/\{|\}/, n), o = Object.keys(t).map((a) => {
+      const u = s.indexOf(a);
+      return u > -1 && (s[u] = t[a]()[0]), s;
+    });
+    return () => Le(e.tag, o);
+  }
+});
+function At(e, t = "", r = {}) {
+  const n = R(""), { t: s } = Xe(), o = j(() => {
+    if (C(t))
+      try {
+        const i = et(C(e), C(t));
+        return He(i, C(e));
+      } catch (i) {
+        n.value = i;
+      }
+    return C(e);
+  }), a = (i) => ({
+    ...i,
+    ...i.label && { label: s(i.label ?? "", C(r)) },
+    ...i.tooltip && { tooltip: s(i.tooltip ?? "") }
+  });
+  return {
+    columns: j(() => H(a, o.value)),
+    error: n
+  };
+}
+function et(e, t = "") {
+  const r = H(ee, q(",", t)), n = qe(e);
+  if (r[0] === "")
+    return [];
+  const s = r.findIndex((o) => !n.includes(o));
+  if (s > -1)
+    throw r[s];
+  return r;
+}
+const Ce = Symbol("ErrorProviderContext");
+function Ct() {
+  const e = R(""), t = R({}), r = (o) => {
+    console.error({ error: o }), e.value = o.message || o.error.message, t.value = {
+      message: o.message,
+      key: o.key || Je(o.message),
+      cause: o.cause
+    };
+  }, n = () => {
+    e.value = "", t.value = {};
+  };
+  return we(Ce, {
+    onError: r,
+    reset: n
+  }), window.onerror = (o) => {
+    console.error("WINDOW_ONERROR:", o);
+  }, _e((o, a, u) => {
+    console.error("onErrorCaptured:", o, a, u);
+  }), {
+    hasError: j(() => e.value.length > 0),
+    message: e,
+    error: t,
+    reset: n,
+    onError: r
+  };
+}
+function Rt() {
+  const e = tt();
+  return {
+    onError: e.onError,
+    reset: e.reset
+  };
+}
+function tt() {
+  const e = Ee(Ce, null);
+  if (e === null)
+    throw new Error("Provider is missing a parent component.");
+  return e;
+}
+function J(e) {
+  return Me() ? (je(e), !0) : !1;
+}
+const D = typeof window < "u" && typeof document < "u", me = typeof WorkerGlobalScope < "u" && globalThis instanceof WorkerGlobalScope, nt = Object.prototype.toString, rt = (e) => nt.call(e) === "[object Object]", N = () => {
+}, ot = /* @__PURE__ */ it();
+function it() {
+  var e, t;
+  return D && ((e = window?.navigator) == null ? void 0 : e.userAgent) && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || ((t = window?.navigator) == null ? void 0 : t.maxTouchPoints) > 2 && /iPad|Macintosh/.test(window?.navigator.userAgent));
+}
+function Re(...e) {
+  if (e.length !== 1)
+    return We(...e);
+  const t = e[0];
+  return typeof t == "function" ? Oe(Fe(() => ({ get: t, set: N }))) : R(t);
+}
+function st(e, t) {
+  function r(...n) {
+    return new Promise((s, o) => {
+      Promise.resolve(e(() => t.apply(this, n), { fn: t, thisArg: this, args: n })).then(s).catch(o);
+    });
+  }
+  return r;
+}
+const Pe = (e) => e();
+function at(e = Pe, t = {}) {
+  const {
+    initialState: r = "active"
+  } = t, n = Re(r === "active");
+  function s() {
+    n.value = !1;
+  }
+  function o() {
+    n.value = !0;
+  }
+  const a = (...u) => {
+    n.value && e(...u);
+  };
+  return { isActive: Oe(n), pause: s, resume: o, eventFilter: a };
+}
+function ue(e, t = !1, r = "Timeout") {
+  return new Promise((n, s) => {
+    setTimeout(t ? () => s(r) : n, e);
+  });
+}
+function re(e) {
+  return Array.isArray(e) ? e : [e];
+}
+function ut(e, t, r = {}) {
+  const {
+    eventFilter: n = Pe,
+    ...s
+  } = r;
+  return S(
+    e,
+    st(
+      n,
+      t
+    ),
+    s
+  );
+}
+function Pt(e, t, r = {}) {
+  const {
+    eventFilter: n,
+    initialState: s = "active",
+    ...o
+  } = r, { eventFilter: a, pause: u, resume: i, isActive: m } = at(n, { initialState: s });
+  return { stop: ut(
+    e,
+    t,
+    {
+      ...o,
+      eventFilter: a
+    }
+  ), pause: u, resume: i, isActive: m };
+}
+function le(e, t = !1) {
+  function r(f, { flush: d = "sync", deep: p = !1, timeout: y, throwOnTimeout: T } = {}) {
+    let l = null;
+    const h = [new Promise((w) => {
+      l = S(
+        e,
+        (g) => {
+          f(g) !== t && (l ? l() : se(() => l?.()), w(g));
+        },
+        {
+          flush: d,
+          deep: p,
+          immediate: !0
+        }
+      );
+    })];
+    return y != null && h.push(
+      ue(y, T).then(() => x(e)).finally(() => l?.())
+    ), Promise.race(h);
+  }
+  function n(f, d) {
+    if (!Ie(f))
+      return r((g) => g === f, d);
+    const { flush: p = "sync", deep: y = !1, timeout: T, throwOnTimeout: l } = d ?? {};
+    let c = null;
+    const w = [new Promise((g) => {
+      c = S(
+        [e, f],
+        ([L, B]) => {
+          t !== (L === B) && (c ? c() : se(() => c?.()), g(L));
+        },
+        {
+          flush: p,
+          deep: y,
+          immediate: !0
+        }
+      );
+    })];
+    return T != null && w.push(
+      ue(T, l).then(() => x(e)).finally(() => (c?.(), x(e)))
+    ), Promise.race(w);
+  }
+  function s(f) {
+    return r((d) => !!d, f);
+  }
+  function o(f) {
+    return n(null, f);
+  }
+  function a(f) {
+    return n(void 0, f);
+  }
+  function u(f) {
+    return r(Number.isNaN, f);
+  }
+  function i(f, d) {
+    return r((p) => {
+      const y = Array.from(p);
+      return y.includes(f) || y.includes(x(f));
+    }, d);
+  }
+  function m(f) {
+    return v(1, f);
+  }
+  function v(f = 1, d) {
+    let p = -1;
+    return r(() => (p += 1, p >= f), d);
+  }
+  return Array.isArray(x(e)) ? {
+    toMatch: r,
+    toContains: i,
+    changed: m,
+    changedTimes: v,
+    get not() {
+      return le(e, !t);
+    }
+  } : {
+    toMatch: r,
+    toBe: n,
+    toBeTruthy: s,
+    toBeNull: o,
+    toBeNaN: u,
+    toBeUndefined: a,
+    changed: m,
+    changedTimes: v,
+    get not() {
+      return le(e, !t);
+    }
+  };
+}
+function lt(e) {
+  return le(e);
+}
+function ct(e, t = 1e3, r = {}) {
+  const {
+    immediate: n = !0,
+    immediateCallback: s = !1
+  } = r;
+  let o = null;
+  const a = k(!1);
+  function u() {
+    o && (clearInterval(o), o = null);
+  }
+  function i() {
+    a.value = !1, u();
+  }
+  function m() {
+    const v = x(t);
+    v <= 0 || (a.value = !0, s && e(), u(), a.value && (o = setInterval(e, v)));
+  }
+  if (n && D && m(), Ie(t) || typeof t == "function") {
+    const v = S(t, () => {
+      a.value && D && m();
+    });
+    J(v);
+  }
+  return J(i), {
+    isActive: xe(a),
+    pause: i,
+    resume: m
+  };
+}
+function ft(e, t, r = {}) {
+  const {
+    immediate: n = !0,
+    immediateCallback: s = !1
+  } = r, o = k(!1);
+  let a;
+  function u() {
+    a && (clearTimeout(a), a = void 0);
+  }
+  function i() {
+    o.value = !1, u();
+  }
+  function m(...v) {
+    s && e(), u(), o.value = !0, a = setTimeout(() => {
+      o.value = !1, a = void 0, e(...v);
+    }, x(t));
+  }
+  return n && (o.value = !0, D && m()), J(i), {
+    isPending: xe(o),
+    start: m,
+    stop: i
+  };
+}
+function dt(e, t, r) {
+  return S(
+    e,
+    t,
+    {
+      ...r,
+      immediate: !0
+    }
+  );
+}
+function Nt(e, t, r) {
+  return S(
+    e,
+    t,
+    {
+      ...r,
+      once: !0
+    }
+  );
+}
+function kt(e, t, r) {
+  const n = S(
+    e,
+    (s, o, a) => {
+      s && (r?.once && se(() => n()), t(s, o, a));
+    },
+    {
+      ...r,
+      once: !1
+    }
+  );
+  return n;
+}
+const Ne = D ? window : void 0, mt = D ? window.document : void 0;
+function K(e) {
+  var t;
+  const r = x(e);
+  return (t = r?.$el) != null ? t : r;
+}
+function U(...e) {
+  const t = [], r = () => {
+    t.forEach((u) => u()), t.length = 0;
+  }, n = (u, i, m, v) => (u.addEventListener(i, m, v), () => u.removeEventListener(i, m, v)), s = j(() => {
+    const u = re(x(e[0])).filter((i) => i != null);
+    return u.every((i) => typeof i != "string") ? u : void 0;
+  }), o = dt(
+    () => {
+      var u, i;
+      return [
+        (i = (u = s.value) == null ? void 0 : u.map((m) => K(m))) != null ? i : [Ne].filter((m) => m != null),
+        re(x(s.value ? e[1] : e[0])),
+        re(C(s.value ? e[2] : e[1])),
+        // @ts-expect-error - TypeScript gets the correct types, but somehow still complains
+        x(s.value ? e[3] : e[2])
+      ];
+    },
+    ([u, i, m, v]) => {
+      if (r(), !u?.length || !i?.length || !m?.length)
+        return;
+      const f = rt(v) ? { ...v } : v;
+      t.push(
+        ...u.flatMap(
+          (d) => i.flatMap(
+            (p) => m.map((y) => n(d, p, y, f))
+          )
+        )
+      );
+    },
+    { flush: "post" }
+  ), a = () => {
+    o(), r();
+  };
+  return J(r), a;
+}
+let ve = !1;
+function Dt(e, t, r = {}) {
+  const { window: n = Ne, ignore: s = [], capture: o = !0, detectIframe: a = !1, controls: u = !1 } = r;
+  if (!n)
+    return u ? { stop: N, cancel: N, trigger: N } : N;
+  if (ot && !ve) {
+    ve = !0;
+    const l = { passive: !0 };
+    Array.from(n.document.body.children).forEach((c) => c.addEventListener("click", N, l)), n.document.documentElement.addEventListener("click", N, l);
+  }
+  let i = !0;
+  const m = (l) => x(s).some((c) => {
+    if (typeof c == "string")
+      return Array.from(n.document.querySelectorAll(c)).some((h) => h === l.target || l.composedPath().includes(h));
+    {
+      const h = K(c);
+      return h && (l.target === h || l.composedPath().includes(h));
+    }
+  });
+  function v(l) {
+    const c = x(l);
+    return c && c.$.subTree.shapeFlag === 16;
+  }
+  function f(l, c) {
+    const h = x(l), w = h.$.subTree && h.$.subTree.children;
+    return w == null || !Array.isArray(w) ? !1 : w.some((g) => g.el === c.target || c.composedPath().includes(g.el));
+  }
+  const d = (l) => {
+    const c = K(e);
+    if (l.target != null && !(!(c instanceof Element) && v(e) && f(e, l)) && !(!c || c === l.target || l.composedPath().includes(c))) {
+      if ("detail" in l && l.detail === 0 && (i = !m(l)), !i) {
+        i = !0;
+        return;
+      }
+      t(l);
+    }
+  };
+  let p = !1;
+  const y = [
+    U(n, "click", (l) => {
+      p || (p = !0, setTimeout(() => {
+        p = !1;
+      }, 0), d(l));
+    }, { passive: !0, capture: o }),
+    U(n, "pointerdown", (l) => {
+      const c = K(e);
+      i = !m(l) && !!(c && !l.composedPath().includes(c));
+    }, { passive: !0 }),
+    a && U(n, "blur", (l) => {
+      setTimeout(() => {
+        var c;
+        const h = K(e);
+        ((c = n.document.activeElement) == null ? void 0 : c.tagName) === "IFRAME" && !h?.contains(n.document.activeElement) && t(l);
+      }, 0);
+    }, { passive: !0 })
+  ].filter(Boolean), T = () => y.forEach((l) => l());
+  return u ? {
+    stop: T,
+    cancel: () => {
+      i = !1;
+    },
+    trigger: (l) => {
+      i = !0, d(l), i = !1;
+    }
+  } : T;
+}
+function vt(e, t, r) {
+  const {
+    immediate: n = !0,
+    delay: s = 0,
+    onError: o = N,
+    onSuccess: a = N,
+    resetOnExecute: u = !0,
+    shallow: i = !0,
+    throwError: m
+  } = r ?? {}, v = i ? k(t) : R(t), f = k(!1), d = k(!1), p = k(void 0);
+  async function y(c = 0, ...h) {
+    u && (v.value = t), p.value = void 0, f.value = !1, d.value = !0, c > 0 && await ue(c);
+    const w = typeof e == "function" ? e(...h) : e;
+    try {
+      const g = await w;
+      v.value = g, f.value = !0, a(g);
+    } catch (g) {
+      if (p.value = g, o(g), m)
+        throw g;
+    } finally {
+      d.value = !1;
+    }
+    return v.value;
+  }
+  n && y(s);
+  const T = {
+    state: v,
+    isReady: f,
+    isLoading: d,
+    error: p,
+    execute: y,
+    executeImmediate: (...c) => y(0, ...c)
+  };
+  function l() {
+    return new Promise((c, h) => {
+      lt(d).toBe(!1).then(() => c(T)).catch(h);
+    });
+  }
+  return {
+    ...T,
+    then(c, h) {
+      return l().then(c, h);
+    }
+  };
+}
+function Lt(e = {}) {
+  const { document: t = mt } = e;
+  if (!t)
+    return k("visible");
+  const r = k(t.visibilityState);
+  return U(t, "visibilitychange", () => {
+    r.value = t.visibilityState;
+  }, { passive: !0 }), r;
+}
+async function pt(e) {
+  return new Promise((t, r) => {
+    const n = new Image(), { src: s, srcset: o, sizes: a, class: u, loading: i, crossorigin: m, referrerPolicy: v, width: f, height: d, decoding: p, fetchPriority: y, ismap: T, usemap: l } = e;
+    n.src = s, o != null && (n.srcset = o), a != null && (n.sizes = a), u != null && (n.className = u), i != null && (n.loading = i), m != null && (n.crossOrigin = m), v != null && (n.referrerPolicy = v), f != null && (n.width = f), d != null && (n.height = d), p != null && (n.decoding = p), y != null && (n.fetchPriority = y), T != null && (n.isMap = T), l != null && (n.useMap = l), n.onload = () => t(n), n.onerror = r;
+  });
+}
+function _t(e, t = {}) {
+  const r = vt(
+    () => pt(x(e)),
+    void 0,
+    {
+      resetOnExecute: !0,
+      ...t
+    }
+  );
+  return S(
+    () => x(e),
+    () => r.execute(t.delay),
+    { deep: !0 }
+  ), r;
+}
+const pe = "ping";
+function oe(e) {
+  return e === !0 ? {} : e;
+}
+function Wt(e, t = {}) {
+  const {
+    onConnected: r,
+    onDisconnected: n,
+    onError: s,
+    onMessage: o,
+    immediate: a = !0,
+    autoConnect: u = !0,
+    autoClose: i = !0,
+    protocols: m = []
+  } = t, v = R(null), f = k("CLOSED"), d = R(), p = Re(e);
+  let y, T, l = !1, c = 0, h = [], w, g;
+  const L = () => {
+    if (h.length && d.value && f.value === "OPEN") {
+      for (const b of h)
+        d.value.send(b);
+      h = [];
+    }
+  }, B = () => {
+    w != null && (clearTimeout(w), w = void 0);
+  }, $ = () => {
+    clearTimeout(g), g = void 0;
+  }, W = (b = 1e3, I) => {
+    B(), !(!D && !me || !d.value) && (l = !0, $(), y?.(), d.value.close(b, I), d.value = void 0);
+  }, V = (b, I = !0) => !d.value || f.value !== "OPEN" ? (I && h.push(b), !1) : (L(), d.value.send(b), !0), Q = () => {
+    if (l || typeof p.value > "u")
+      return;
+    const b = new WebSocket(p.value, m);
+    d.value = b, f.value = "CONNECTING", b.onopen = () => {
+      f.value = "OPEN", c = 0, r?.(b), T?.(), L();
+    }, b.onclose = (I) => {
+      if (f.value = "CLOSED", $(), y?.(), n?.(b, I), !l && t.autoReconnect && (d.value == null || b === d.value)) {
+        const {
+          retries: A = -1,
+          delay: F = 1e3,
+          onFailed: M
+        } = oe(t.autoReconnect);
+        (typeof A == "function" ? A : () => typeof A == "number" && (A < 0 || c < A))(c) ? (c += 1, w = setTimeout(Q, F)) : M?.();
+      }
+    }, b.onerror = (I) => {
+      s?.(b, I);
+    }, b.onmessage = (I) => {
+      if (t.heartbeat) {
+        $();
+        const {
+          message: A = pe,
+          responseMessage: F = A
+        } = oe(t.heartbeat);
+        if (I.data === x(F))
+          return;
+      }
+      v.value = I.data, o?.(b, I);
+    };
+  };
+  if (t.heartbeat) {
+    const {
+      message: b = pe,
+      interval: I = 1e3,
+      pongTimeout: A = 1e3
+    } = oe(t.heartbeat), { pause: F, resume: M } = ct(
+      () => {
+        V(x(b), !1), g == null && (g = setTimeout(() => {
+          W(), l = !1;
+        }, A));
+      },
+      I,
+      { immediate: !1 }
+    );
+    y = F, T = M;
+  }
+  i && (D && U("beforeunload", () => W(), { passive: !0 }), J(W));
+  const z = () => {
+    !D && !me || (W(), l = !1, c = 0, Q());
+  };
+  return a && z(), u && S(p, z), {
+    data: v,
+    status: f,
+    close: W,
+    send: V,
+    open: z,
+    ws: d
+  };
+}
+function Ft(e = [], t = {}) {
+  const { delay: r = 0 } = t, n = R(!1), s = j(() => {
+    const u = C(e);
+    return Array.isArray(u) ? u.map((i) => C(i)).some(Boolean) : u;
+  }), { start: o, stop: a } = ft(() => {
+    n.value = !0;
+  }, r);
+  return S(
+    s,
+    (u) => {
+      if (u)
+        return o();
+      a(), n.value = !1;
+    },
+    { immediate: !0, deep: !0 }
+  ), n;
+}
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+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.
+***************************************************************************** */
+function ie(e, t) {
+  var r = typeof Symbol == "function" && e[Symbol.iterator];
+  if (!r) return e;
+  var n, s, o = r.call(e), a = [];
+  try {
+    for (; (t === void 0 || t-- > 0) && !(n = o.next()).done; ) a.push(n.value);
+  } catch (u) {
+    s = { error: u };
+  } finally {
+    try {
+      n && !n.done && (r = o.return) && r.call(o);
+    } finally {
+      if (s) throw s.error;
+    }
+  }
+  return a;
+}
+var he;
+(function(e) {
+  e[e.NotStarted = 0] = "NotStarted", e[e.Running = 1] = "Running", e[e.Stopped = 2] = "Stopped";
+})(he || (he = {}));
+var ht = { type: "xstate.init" };
+function Y(e) {
+  return e === void 0 ? [] : [].concat(e);
+}
+function ye(e, t) {
+  return typeof (e = typeof e == "string" && t && t[e] ? t[e] : e) == "string" ? { type: e } : typeof e == "function" ? { type: e.name, exec: e } : e;
+}
+function ce(e) {
+  return function(t) {
+    return e === t;
+  };
+}
+function yt(e) {
+  return typeof e == "string" ? { type: e } : e;
+}
+function ge(e, t) {
+  return { value: e, context: t, actions: [], changed: !1, matches: ce(e) };
+}
+function be(e, t, r) {
+  var n = t, s = !1;
+  return [e.filter(function(o) {
+    if (o.type === "xstate.assign") {
+      s = !0;
+      var a = Object.assign({}, n);
+      return typeof o.assignment == "function" ? a = o.assignment(n, r) : Object.keys(o.assignment).forEach(function(u) {
+        a[u] = typeof o.assignment[u] == "function" ? o.assignment[u](n, r) : o.assignment[u];
+      }), n = a, !1;
+    }
+    return !0;
+  }), n, s];
+}
+function gt(e, t) {
+  t === void 0 && (t = {});
+  var r = ie(be(Y(e.states[e.initial].entry).map(function(a) {
+    return ye(a, t.actions);
+  }), e.context, ht), 2), n = r[0], s = r[1], o = { config: e, _options: t, initialState: { value: e.initial, actions: n, context: s, matches: ce(e.initial) }, transition: function(a, u) {
+    var i, m, v = typeof a == "string" ? { value: a, context: e.context } : a, f = v.value, d = v.context, p = yt(u), y = e.states[f];
+    if (y.on) {
+      var T = Y(y.on[p.type]);
+      "*" in y.on && T.push.apply(T, function(E, P, te) {
+        if (arguments.length === 2) for (var _, G = 0, ke = P.length; G < ke; G++) !_ && G in P || (_ || (_ = Array.prototype.slice.call(P, 0, G)), _[G] = P[G]);
+        return E.concat(_ || Array.prototype.slice.call(P));
+      }([], ie(Y(y.on["*"])), !1));
+      try {
+        for (var l = function(E) {
+          var P = typeof Symbol == "function" && Symbol.iterator, te = P && E[P], _ = 0;
+          if (te) return te.call(E);
+          if (E && typeof E.length == "number") return { next: function() {
+            return E && _ >= E.length && (E = void 0), { value: E && E[_++], done: !E };
+          } };
+          throw new TypeError(P ? "Object is not iterable." : "Symbol.iterator is not defined.");
+        }(T), c = l.next(); !c.done; c = l.next()) {
+          var h = c.value;
+          if (h === void 0) return ge(f, d);
+          var w = typeof h == "string" ? { target: h } : h, g = w.target, L = w.actions, B = L === void 0 ? [] : L, $ = w.cond, W = $ === void 0 ? function() {
+            return !0;
+          } : $, V = g === void 0, Q = g ?? f, z = e.states[Q];
+          if (W(d, p)) {
+            var b = ie(be((V ? Y(B) : [].concat(y.exit, B, z.entry).filter(function(E) {
+              return E;
+            })).map(function(E) {
+              return ye(E, o._options.actions);
+            }), d, p), 3), I = b[0], A = b[1], F = b[2], M = g ?? f;
+            return { value: M, context: A, actions: I, changed: g !== f || I.length > 0 || F, matches: ce(M) };
+          }
+        }
+      } catch (E) {
+        i = { error: E };
+      } finally {
+        try {
+          c && !c.done && (m = l.return) && m.call(l);
+        } finally {
+          if (i) throw i.error;
+        }
+      }
+    }
+    return ge(f, d);
+  } };
+  return o;
+}
+const bt = gt({
+  id: "sort",
+  initial: X,
+  states: {
+    [X]: {
+      on: {
+        DIRECTION1: ne,
+        DIRECTION2: Z
+      }
+    },
+    [ne]: {
+      on: {
+        DIRECTION1: Z,
+        DIRECTION2: X
+      }
+    },
+    [Z]: {
+      on: {
+        DIRECTION1: X,
+        DIRECTION2: ne
+      }
+    }
+  }
+});
+function Tt(e, t) {
+  const r = t === Z ? "DIRECTION2" : "DIRECTION1";
+  return bt.transition(e, r).value;
+}
+function Mt(e = {}) {
+  const { sortTarget: t = null, orders: r = [] } = e, n = Te({ sortTarget: t, orders: r });
+  return {
+    sort: n,
+    change: ({ target: o, orders: a }) => {
+      if (n.sortTarget !== o) {
+        n.sortTarget = o, n.orders = a;
+        return;
+      }
+      const u = a.map((i, m) => ({
+        ...i,
+        direction: Tt(n.orders[m].direction, i.direction)
+      }));
+      n.sortTarget = o, n.orders = u;
+    }
+  };
+}
+export {
+  At as a,
+  Ct as b,
+  Rt as c,
+  It as d,
+  Xe as e,
+  Ft as f,
+  Mt as g,
+  _t as h,
+  St as i,
+  Wt as j,
+  Nt as k,
+  Pt as l,
+  Qe as m,
+  N as n,
+  Dt as o,
+  K as p,
+  vt as q,
+  Lt as r,
+  Ot as u,
+  et as v,
+  kt as w
+};