@mjsz-vbr-elements/core 2.1.8 → 2.1.9

package/dist/useSort-f443338c.js

@@ -0,0 +1,745 @@
+/**
+ * name: @mjsz-vbr-elements/core
+ * version: v2.1.9 - 01/01/2024, 23:01:44
+ * (c) 2024
+ * description: Data visualization for MJSZ VBR
+ * author: Ákos Stegner <akos.stegner@gmail.com>
+ */
+import { ref as O, readonly as vt, watch as A, nextTick as xt, getCurrentScope as Rt, onScopeDispose as Lt, unref as I, isRef as Nt, shallowRef as et, computed as S, reactive as mt, defineComponent as Dt, h as Ft, provide as yt, inject as gt, onErrorCaptured as kt } from "vue";
+import { _ as F, j as Bt, k as Ut, l as Wt, m as zt, n as Mt, p as Vt, q as C, s as x, r as qt, t as Gt, u as Ht } from "./datetime-2fb02df2.js";
+import { SORT_STATE_ORIGINAL as L, SORT_STATE_DESCEND as V, SORT_STATE_ASCEND as N } from "./constants.js";
+const Ge = (t) => ({}.VITE_CSS_CLASS_PREFIX || "mjsz-vbr-") + t;
+function ht(t) {
+  return Rt() ? (Lt(t), !0) : !1;
+}
+function P(t) {
+  return typeof t == "function" ? t() : I(t);
+}
+const W = typeof window < "u", k = () => {
+}, Kt = /* @__PURE__ */ Xt();
+function Xt() {
+  var t;
+  return W && ((t = window == null ? void 0 : window.navigator) == null ? void 0 : t.userAgent) && /* @__PURE__ */ /iP(ad|hone|od)/.test(window.navigator.userAgent);
+}
+function Jt(t, e) {
+  function r(...n) {
+    return new Promise((a, o) => {
+      Promise.resolve(t(() => e.apply(this, n), { fn: e, thisArg: this, args: n })).then(a).catch(o);
+    });
+  }
+  return r;
+}
+const _t = (t) => t();
+function Qt(t = _t) {
+  const e = O(!0);
+  function r() {
+    e.value = !1;
+  }
+  function n() {
+    e.value = !0;
+  }
+  const a = (...o) => {
+    e.value && t(...o);
+  };
+  return { isActive: vt(e), pause: r, resume: n, eventFilter: a };
+}
+function G(t, e = !1, r = "Timeout") {
+  return new Promise((n, a) => {
+    setTimeout(e ? () => a(r) : n, t);
+  });
+}
+function H(t, e = !1) {
+  function r(l, { flush: s = "sync", deep: f = !1, timeout: v, throwOnTimeout: E } = {}) {
+    let _ = null;
+    const w = [new Promise((b) => {
+      _ = A(
+        t,
+        (m) => {
+          l(m) !== e && (_ == null || _(), b(m));
+        },
+        {
+          flush: s,
+          deep: f,
+          immediate: !0
+        }
+      );
+    })];
+    return v != null && w.push(
+      G(v, E).then(() => P(t)).finally(() => _ == null ? void 0 : _())
+    ), Promise.race(w);
+  }
+  function n(l, s) {
+    if (!Nt(l))
+      return r((m) => m === l, s);
+    const { flush: f = "sync", deep: v = !1, timeout: E, throwOnTimeout: _ } = s ?? {};
+    let y = null;
+    const b = [new Promise((m) => {
+      y = A(
+        [t, l],
+        ([T, R]) => {
+          e !== (T === R) && (y == null || y(), m(T));
+        },
+        {
+          flush: f,
+          deep: v,
+          immediate: !0
+        }
+      );
+    })];
+    return E != null && b.push(
+      G(E, _).then(() => P(t)).finally(() => (y == null || y(), P(t)))
+    ), Promise.race(b);
+  }
+  function a(l) {
+    return r((s) => !!s, l);
+  }
+  function o(l) {
+    return n(null, l);
+  }
+  function c(l) {
+    return n(void 0, l);
+  }
+  function i(l) {
+    return r(Number.isNaN, l);
+  }
+  function u(l, s) {
+    return r((f) => {
+      const v = Array.from(f);
+      return v.includes(l) || v.includes(P(l));
+    }, s);
+  }
+  function p(l) {
+    return d(1, l);
+  }
+  function d(l = 1, s) {
+    let f = -1;
+    return r(() => (f += 1, f >= l), s);
+  }
+  return Array.isArray(P(t)) ? {
+    toMatch: r,
+    toContains: u,
+    changed: p,
+    changedTimes: d,
+    get not() {
+      return H(t, !e);
+    }
+  } : {
+    toMatch: r,
+    toBe: n,
+    toBeTruthy: a,
+    toBeNull: o,
+    toBeNaN: i,
+    toBeUndefined: c,
+    changed: p,
+    changedTimes: d,
+    get not() {
+      return H(t, !e);
+    }
+  };
+}
+function Yt(t) {
+  return H(t);
+}
+function Zt(t, e, r = {}) {
+  const {
+    immediate: n = !0
+  } = r, a = O(!1);
+  let o = null;
+  function c() {
+    o && (clearTimeout(o), o = null);
+  }
+  function i() {
+    a.value = !1, c();
+  }
+  function u(...p) {
+    c(), a.value = !0, o = setTimeout(() => {
+      a.value = !1, o = null, t(...p);
+    }, P(e));
+  }
+  return n && (a.value = !0, W && u()), ht(i), {
+    isPending: vt(a),
+    start: u,
+    stop: i
+  };
+}
+var rt = Object.getOwnPropertySymbols, te = Object.prototype.hasOwnProperty, ee = Object.prototype.propertyIsEnumerable, re = (t, e) => {
+  var r = {};
+  for (var n in t)
+    te.call(t, n) && e.indexOf(n) < 0 && (r[n] = t[n]);
+  if (t != null && rt)
+    for (var n of rt(t))
+      e.indexOf(n) < 0 && ee.call(t, n) && (r[n] = t[n]);
+  return r;
+};
+function ne(t, e, r = {}) {
+  const n = r, {
+    eventFilter: a = _t
+  } = n, o = re(n, [
+    "eventFilter"
+  ]);
+  return A(
+    t,
+    Jt(
+      a,
+      e
+    ),
+    o
+  );
+}
+function He(t, e, r) {
+  const n = A(t, (...a) => (xt(() => n()), e(...a)), r);
+}
+var oe = Object.defineProperty, ae = Object.defineProperties, ie = Object.getOwnPropertyDescriptors, B = Object.getOwnPropertySymbols, wt = Object.prototype.hasOwnProperty, Ot = Object.prototype.propertyIsEnumerable, nt = (t, e, r) => e in t ? oe(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, se = (t, e) => {
+  for (var r in e || (e = {}))
+    wt.call(e, r) && nt(t, r, e[r]);
+  if (B)
+    for (var r of B(e))
+      Ot.call(e, r) && nt(t, r, e[r]);
+  return t;
+}, ce = (t, e) => ae(t, ie(e)), ue = (t, e) => {
+  var r = {};
+  for (var n in t)
+    wt.call(t, n) && e.indexOf(n) < 0 && (r[n] = t[n]);
+  if (t != null && B)
+    for (var n of B(t))
+      e.indexOf(n) < 0 && Ot.call(t, n) && (r[n] = t[n]);
+  return r;
+};
+function Ke(t, e, r = {}) {
+  const n = r, {
+    eventFilter: a
+  } = n, o = ue(n, [
+    "eventFilter"
+  ]), { eventFilter: c, pause: i, resume: u, isActive: p } = Qt(a);
+  return { stop: ne(
+    t,
+    e,
+    ce(se({}, o), {
+      eventFilter: c
+    })
+  ), pause: i, resume: u, isActive: p };
+}
+function Xe(t, e, r) {
+  return A(
+    t,
+    (n, a, o) => {
+      n && e(n, a, o);
+    },
+    r
+  );
+}
+function j(t) {
+  var e;
+  const r = P(t);
+  return (e = r == null ? void 0 : r.$el) != null ? e : r;
+}
+const bt = W ? window : void 0, le = W ? window.document : void 0;
+function D(...t) {
+  let e, r, n, a;
+  if (typeof t[0] == "string" || Array.isArray(t[0]) ? ([r, n, a] = t, e = bt) : [e, r, n, a] = t, !e)
+    return k;
+  Array.isArray(r) || (r = [r]), Array.isArray(n) || (n = [n]);
+  const o = [], c = () => {
+    o.forEach((d) => d()), o.length = 0;
+  }, i = (d, l, s, f) => (d.addEventListener(l, s, f), () => d.removeEventListener(l, s, f)), u = A(
+    () => [j(e), P(a)],
+    ([d, l]) => {
+      c(), d && o.push(
+        ...r.flatMap((s) => n.map((f) => i(d, s, f, l)))
+      );
+    },
+    { immediate: !0, flush: "post" }
+  ), p = () => {
+    u(), c();
+  };
+  return ht(p), p;
+}
+let ot = !1;
+function Je(t, e, r = {}) {
+  const { window: n = bt, ignore: a = [], capture: o = !0, detectIframe: c = !1 } = r;
+  if (!n)
+    return;
+  Kt && !ot && (ot = !0, Array.from(n.document.body.children).forEach((s) => s.addEventListener("click", k)));
+  let i = !0;
+  const u = (s) => a.some((f) => {
+    if (typeof f == "string")
+      return Array.from(n.document.querySelectorAll(f)).some((v) => v === s.target || s.composedPath().includes(v));
+    {
+      const v = j(f);
+      return v && (s.target === v || s.composedPath().includes(v));
+    }
+  }), d = [
+    D(n, "click", (s) => {
+      const f = j(t);
+      if (!(!f || f === s.target || s.composedPath().includes(f))) {
+        if (s.detail === 0 && (i = !u(s)), !i) {
+          i = !0;
+          return;
+        }
+        e(s);
+      }
+    }, { passive: !0, capture: o }),
+    D(n, "pointerdown", (s) => {
+      const f = j(t);
+      f && (i = !s.composedPath().includes(f) && !u(s));
+    }, { passive: !0 }),
+    c && D(n, "blur", (s) => {
+      var f;
+      const v = j(t);
+      ((f = n.document.activeElement) == null ? void 0 : f.tagName) === "IFRAME" && !(v != null && v.contains(n.document.activeElement)) && e(s);
+    })
+  ].filter(Boolean);
+  return () => d.forEach((s) => s());
+}
+var fe = Object.defineProperty, pe = Object.defineProperties, de = Object.getOwnPropertyDescriptors, at = Object.getOwnPropertySymbols, ve = Object.prototype.hasOwnProperty, me = Object.prototype.propertyIsEnumerable, it = (t, e, r) => e in t ? fe(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, ye = (t, e) => {
+  for (var r in e || (e = {}))
+    ve.call(e, r) && it(t, r, e[r]);
+  if (at)
+    for (var r of at(e))
+      me.call(e, r) && it(t, r, e[r]);
+  return t;
+}, ge = (t, e) => pe(t, de(e));
+function he(t, e, r) {
+  const {
+    immediate: n = !0,
+    delay: a = 0,
+    onError: o = k,
+    onSuccess: c = k,
+    resetOnExecute: i = !0,
+    shallow: u = !0,
+    throwError: p
+  } = r ?? {}, d = u ? et(e) : O(e), l = O(!1), s = O(!1), f = et(void 0);
+  async function v(y = 0, ...w) {
+    i && (d.value = e), f.value = void 0, l.value = !1, s.value = !0, y > 0 && await G(y);
+    const b = typeof t == "function" ? t(...w) : t;
+    try {
+      const m = await b;
+      d.value = m, l.value = !0, c(m);
+    } catch (m) {
+      if (f.value = m, o(m), p)
+        throw m;
+    } finally {
+      s.value = !1;
+    }
+    return d.value;
+  }
+  n && v(a);
+  const E = {
+    state: d,
+    isReady: l,
+    isLoading: s,
+    error: f,
+    execute: v
+  };
+  function _() {
+    return new Promise((y, w) => {
+      Yt(s).toBe(!1).then(() => y(E)).catch(w);
+    });
+  }
+  return ge(ye({}, E), {
+    then(y, w) {
+      return _().then(y, w);
+    }
+  });
+}
+function Qe({ document: t = le } = {}) {
+  if (!t)
+    return O("visible");
+  const e = O(t.visibilityState);
+  return D(t, "visibilitychange", () => {
+    e.value = t.visibilityState;
+  }), e;
+}
+var _e = Object.defineProperty, st = Object.getOwnPropertySymbols, we = Object.prototype.hasOwnProperty, Oe = Object.prototype.propertyIsEnumerable, ct = (t, e, r) => e in t ? _e(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, be = (t, e) => {
+  for (var r in e || (e = {}))
+    we.call(e, r) && ct(t, r, e[r]);
+  if (st)
+    for (var r of st(e))
+      Oe.call(e, r) && ct(t, r, e[r]);
+  return t;
+};
+async function Pe(t) {
+  return new Promise((e, r) => {
+    const n = new Image(), { src: a, srcset: o, sizes: c, class: i, loading: u, crossorigin: p } = t;
+    n.src = a, o && (n.srcset = o), c && (n.sizes = c), i && (n.className = i), u && (n.loading = u), p && (n.crossOrigin = p), n.onload = () => e(n), n.onerror = r;
+  });
+}
+function Ye(t, e = {}) {
+  const r = he(
+    () => Pe(P(t)),
+    void 0,
+    be({
+      resetOnExecute: !0
+    }, e)
+  );
+  return A(
+    () => P(t),
+    () => r.execute(e.delay),
+    { deep: !0 }
+  ), r;
+}
+function Ze(t = [], e = {}) {
+  const { delay: r = 0 } = e, n = O(!1), a = S(() => {
+    const i = I(t);
+    return Array.isArray(i) ? i.map((u) => I(u)).some(Boolean) : i;
+  }), { start: o, stop: c } = Zt(() => {
+    n.value = !0;
+  }, r);
+  return A(
+    a,
+    (i) => {
+      if (i)
+        return o();
+      c(), n.value = !1;
+    },
+    { immediate: !0, deep: !0 }
+  ), n;
+}
+function Ee(t) {
+  var e = Object.prototype.toString.call(t);
+  return e === "[object Uint8ClampedArray]" || e === "[object Int8Array]" || e === "[object Uint8Array]" || e === "[object Int16Array]" || e === "[object Uint16Array]" || e === "[object Int32Array]" || e === "[object Uint32Array]" || e === "[object Float32Array]" || e === "[object Float64Array]" || e === "[object BigInt64Array]" || e === "[object BigUint64Array]";
+}
+var Ie = /* @__PURE__ */ F(function(e) {
+  return e != null && typeof e["fantasy-land/empty"] == "function" ? e["fantasy-land/empty"]() : e != null && e.constructor != null && typeof e.constructor["fantasy-land/empty"] == "function" ? e.constructor["fantasy-land/empty"]() : e != null && typeof e.empty == "function" ? e.empty() : e != null && e.constructor != null && typeof e.constructor.empty == "function" ? e.constructor.empty() : Bt(e) ? [] : Ut(e) ? "" : Wt(e) ? {} : zt(e) ? function() {
+    return arguments;
+  }() : Ee(e) ? e.constructor.from("") : void 0;
+}), Ae = /* @__PURE__ */ F(function(e) {
+  return e != null && Mt(e, Ie(e));
+});
+const Se = Ae;
+var Te = /* @__PURE__ */ Vt(function(e, r) {
+  for (var n = {}, a = {}, o = 0, c = e.length; o < c; )
+    a[e[o]] = 1, o += 1;
+  for (var i in r)
+    a.hasOwnProperty(i) || (n[i] = r[i]);
+  return n;
+});
+const $e = Te;
+var $ = `	
+\v\f\r                　\u2028\u2029\uFEFF`, je = "​", Ce = typeof String.prototype.trim == "function", xe = !Ce || /* @__PURE__ */ $.trim() || !/* @__PURE__ */ je.trim() ? /* @__PURE__ */ F(function(e) {
+  var r = new RegExp("^[" + $ + "][" + $ + "]*"), n = new RegExp("[" + $ + "][" + $ + "]*$");
+  return e.replace(r, "").replace(n, "");
+}) : /* @__PURE__ */ F(function(e) {
+  return e.trim();
+});
+const U = xe, Pt = Symbol("I18nContext"), h = mt({
+  messages: {},
+  locale: "",
+  fallbackLocale: ""
+}), tr = ({ messages: t = {}, locale: e = "", fallbackLocale: r = "" }) => {
+  h.messages = t, h.locale = e, h.fallbackLocale = r;
+  const n = (u, p = {}) => {
+    const d = !Se(p), l = C(U, x(".", u));
+    return S(() => {
+      const f = Et(l);
+      return d ? Ne(f, p) : f;
+    }).value;
+  }, a = (u) => {
+    const p = C(U, x(".", u));
+    return !!K(h.locale, p, h.messages);
+  }, o = (u) => {
+    h.locale = u;
+  }, i = {
+    locale: S({
+      get() {
+        return h.locale;
+      },
+      set(u) {
+        h.locale = u;
+      }
+    }),
+    setLocale: o,
+    translate: n,
+    hasTranlation: a
+  };
+  return yt(Pt, i), {
+    translate: n
+  };
+}, Re = (t) => {
+  t && (h.messages = t.messages, h.locale = t.locale, h.fallbackLocale = t.fallbackLocale);
+  const e = Le();
+  return {
+    locale: e.locale,
+    t: e.translate,
+    setLocale: e.setLocale,
+    hasTranlation: e.hasTranlation
+  };
+}, Le = () => {
+  const t = gt(Pt, null);
+  if (t === null)
+    throw new Error("Privider is missing a parent component.");
+  return t;
+}, Et = (t = []) => {
+  let e = K(h.locale, t, h.messages);
+  return !e && h.fallbackLocale && (e = K(h.fallbackLocale, t, h.messages)), e || t.join(".");
+};
+function K(t, e, r) {
+  return qt([t, ...e], r);
+}
+const Ne = function(t, e) {
+  return t.replace(/\{(\w+)\}/g, function(r, n) {
+    return e[n];
+  });
+}, er = Dt({
+  props: {
+    tag: {
+      type: String,
+      default: "div"
+    },
+    path: {
+      type: String,
+      defult: ""
+    }
+  },
+  setup(t, { slots: e }) {
+    const r = C(U, x(".", t.path)), n = Et(r), a = x(/{|}/, n), o = Object.keys(e).map((c) => {
+      const i = a.indexOf(c);
+      return i > -1 && (a[i] = e[c]()[0]), a;
+    });
+    return () => Ft(t.tag, o);
+  }
+}), It = Symbol("ErrorProviderContext"), rr = () => {
+  const t = O(""), e = O({}), r = (o) => {
+    console.error({ error: o }), t.value = o.message || o.error.message, e.value = {
+      message: o.message,
+      key: o.key || Gt(o.message),
+      cause: o.cause
+    };
+  };
+  return yt(It, {
+    onError: r,
+    reset: () => {
+      t.value = "", e.value = {};
+    }
+  }), window.onerror = (o) => {
+    console.error("WINDOW_ONERROR:", o);
+  }, kt((o, c, i) => {
+    console.error("onErrorCaptured:", o, c, i);
+  }), {
+    hasError: S(() => t.value.length > 0),
+    message: t,
+    error: e,
+    onError: r
+  };
+}, nr = () => {
+  const t = De();
+  return {
+    onError: t.onError,
+    reset: t.reset
+  };
+}, De = () => {
+  const t = gt(It, null);
+  if (t === null)
+    throw new Error("Privider is missing a parent component.");
+  return t;
+}, or = (t, e = "", r = {}) => {
+  const n = O(""), { t: a } = Re(), o = S(() => {
+    if (I(e))
+      try {
+        const u = Fe(I(t), I(e));
+        return $e(u, I(t));
+      } catch (u) {
+        n.value = u;
+      }
+    return I(t);
+  }), c = (u) => ({
+    ...u,
+    ...u.label && { label: a(u.label ?? "", I(r)) },
+    ...u.tooltip && { tooltip: a(u.tooltip ?? "") }
+  });
+  return {
+    columns: S(() => C(c, o.value)),
+    error: n
+  };
+}, Fe = (t, e = "") => {
+  const r = C(U, x(",", e)), n = Ht(t);
+  if (r[0] === "")
+    return resolve([]);
+  const a = r.findIndex((o) => !n.includes(o));
+  if (a > -1)
+    throw r[a];
+  return r;
+};
+/*! *****************************************************************************
+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 ut(t, e) {
+  var r = typeof Symbol == "function" && t[Symbol.iterator];
+  if (!r)
+    return t;
+  var n, a, o = r.call(t), c = [];
+  try {
+    for (; (e === void 0 || e-- > 0) && !(n = o.next()).done; )
+      c.push(n.value);
+  } catch (i) {
+    a = { error: i };
+  } finally {
+    try {
+      n && !n.done && (r = o.return) && r.call(o);
+    } finally {
+      if (a)
+        throw a.error;
+    }
+  }
+  return c;
+}
+var lt;
+(function(t) {
+  t[t.NotStarted = 0] = "NotStarted", t[t.Running = 1] = "Running", t[t.Stopped = 2] = "Stopped";
+})(lt || (lt = {}));
+var ke = { type: "xstate.init" };
+function q(t) {
+  return t === void 0 ? [] : [].concat(t);
+}
+function ft(t, e) {
+  return typeof (t = typeof t == "string" && e && e[t] ? e[t] : t) == "string" ? { type: t } : typeof t == "function" ? { type: t.name, exec: t } : t;
+}
+function X(t) {
+  return function(e) {
+    return t === e;
+  };
+}
+function Be(t) {
+  return typeof t == "string" ? { type: t } : t;
+}
+function pt(t, e) {
+  return { value: t, context: e, actions: [], changed: !1, matches: X(t) };
+}
+function dt(t, e, r) {
+  var n = e, a = !1;
+  return [t.filter(function(o) {
+    if (o.type === "xstate.assign") {
+      a = !0;
+      var c = Object.assign({}, n);
+      return typeof o.assignment == "function" ? c = o.assignment(n, r) : Object.keys(o.assignment).forEach(function(i) {
+        c[i] = typeof o.assignment[i] == "function" ? o.assignment[i](n, r) : o.assignment[i];
+      }), n = c, !1;
+    }
+    return !0;
+  }), n, a];
+}
+function Ue(t, e) {
+  e === void 0 && (e = {});
+  var r = ut(dt(q(t.states[t.initial].entry).map(function(c) {
+    return ft(c, e.actions);
+  }), t.context, ke), 2), n = r[0], a = r[1], o = { config: t, _options: e, initialState: { value: t.initial, actions: n, context: a, matches: X(t.initial) }, transition: function(c, i) {
+    var u, p, d = typeof c == "string" ? { value: c, context: t.context } : c, l = d.value, s = d.context, f = Be(i), v = t.states[l];
+    if (v.on) {
+      var E = q(v.on[f.type]);
+      try {
+        for (var _ = function(g) {
+          var M = typeof Symbol == "function" && Symbol.iterator, Z = M && g[M], tt = 0;
+          if (Z)
+            return Z.call(g);
+          if (g && typeof g.length == "number")
+            return { next: function() {
+              return g && tt >= g.length && (g = void 0), { value: g && g[tt++], done: !g };
+            } };
+          throw new TypeError(M ? "Object is not iterable." : "Symbol.iterator is not defined.");
+        }(E), y = _.next(); !y.done; y = _.next()) {
+          var w = y.value;
+          if (w === void 0)
+            return pt(l, s);
+          var b = typeof w == "string" ? { target: w } : w, m = b.target, T = b.actions, R = T === void 0 ? [] : T, J = b.cond, At = J === void 0 ? function() {
+            return !0;
+          } : J, St = m === void 0, Tt = m ?? l, $t = t.states[Tt];
+          if (At(s, f)) {
+            var z = ut(dt((St ? q(R) : [].concat(v.exit, R, $t.entry).filter(function(g) {
+              return g;
+            })).map(function(g) {
+              return ft(g, o._options.actions);
+            }), s, f), 3), Q = z[0], jt = z[1], Ct = z[2], Y = m ?? l;
+            return { value: Y, context: jt, actions: Q, changed: m !== l || Q.length > 0 || Ct, matches: X(Y) };
+          }
+        }
+      } catch (g) {
+        u = { error: g };
+      } finally {
+        try {
+          y && !y.done && (p = _.return) && p.call(_);
+        } finally {
+          if (u)
+            throw u.error;
+        }
+      }
+    }
+    return pt(l, s);
+  } };
+  return o;
+}
+const We = Ue({
+  id: "sort",
+  initial: L,
+  states: {
+    [L]: {
+      on: {
+        DIRECTION1: V,
+        DIRECTION2: N
+      }
+    },
+    [V]: {
+      on: {
+        DIRECTION1: N,
+        DIRECTION2: L
+      }
+    },
+    [N]: {
+      on: {
+        DIRECTION1: L,
+        DIRECTION2: V
+      }
+    }
+  }
+}), ze = (t, e) => {
+  const r = e === N ? "DIRECTION2" : "DIRECTION1";
+  return We.transition(t, r).value;
+};
+function ar(t = {}) {
+  const { sortTarget: e = null, orders: r = [] } = t, n = mt({ sortTarget: e, orders: r });
+  return {
+    sort: n,
+    change: ({ target: o, orders: c }) => {
+      if (n.sortTarget !== o) {
+        n.sortTarget = o, n.orders = c;
+        return;
+      }
+      const i = c.map((u, p) => ({
+        ...u,
+        direction: ze(n.orders[p].direction, u.direction)
+      }));
+      n.sortTarget = o, n.orders = i;
+    }
+  };
+}
+export {
+  rr as a,
+  nr as b,
+  tr as c,
+  Re as d,
+  Ze as e,
+  Ge as f,
+  ar as g,
+  Ye as h,
+  er as i,
+  He as j,
+  he as k,
+  Qe as l,
+  Ke as m,
+  k as n,
+  Je as o,
+  j as p,
+  or as u,
+  Fe as v,
+  Xe as w
+};