@hortiview/default-components 1.4.1 → 1.4.2

package/dist/slicedToArray-BWk2gTCn-Cfzj7tjm.js

@@ -0,0 +1,432 @@
+import { d as O, P as it, O as Rr, D as ot, I as Zr, E as ft, K as tr, M as _r, Q as ct, R as I, T as rt, S as tt, U as vt, V as nr, W as nt, _ as er, $ as st, a0 as lt, a1 as ht, a2 as et, a3 as yt, a4 as pt, a5 as dt, a6 as gt, a7 as at, a8 as ut, a9 as mt, aa as wt, ab as ar, ac as At, ad as $t, ae as bt, af as Ot } from "./useTranslation-CVaIJbcK.js";
+var x, ir;
+function jt() {
+  if (ir) return x;
+  ir = 1;
+  var r = /* @__PURE__ */ ft();
+  return x = r, x;
+}
+var E, or;
+function Tt() {
+  if (or) return E;
+  or = 1;
+  var r = /* @__PURE__ */ jt();
+  return E = r, E;
+}
+var fr, cr;
+function It() {
+  return cr || (cr = 1, fr = /* @__PURE__ */ Tt()), fr;
+}
+var xt = /* @__PURE__ */ It();
+const Et = /* @__PURE__ */ O(xt);
+function Pt(r) {
+  if (Et(r)) return r;
+}
+var P, vr;
+function ur() {
+  if (vr) return P;
+  vr = 1;
+  var r = /* @__PURE__ */ mt(), e = /* @__PURE__ */ at(), t = /* @__PURE__ */ gt(), n = /* @__PURE__ */ ut(), a = /* @__PURE__ */ I(), i = a("iterator");
+  return P = function(u) {
+    if (!t(u)) return e(u, i) || e(u, "@@iterator") || n[r(u)];
+  }, P;
+}
+var S, sr;
+function St() {
+  if (sr) return S;
+  sr = 1, dt(), Rr();
+  var r = /* @__PURE__ */ ur();
+  return S = r, S;
+}
+var C, lr;
+function Ct() {
+  if (lr) return C;
+  lr = 1;
+  var r = /* @__PURE__ */ St();
+  return ct(), C = r, C;
+}
+var F, hr;
+function Ft() {
+  if (hr) return F;
+  hr = 1;
+  var r = /* @__PURE__ */ Ct();
+  return F = r, F;
+}
+var M, yr;
+function Mt() {
+  if (yr) return M;
+  yr = 1;
+  var r = /* @__PURE__ */ Ft();
+  return M = r, M;
+}
+var pr, dr;
+function qt() {
+  return dr || (dr = 1, pr = /* @__PURE__ */ Mt()), pr;
+}
+var Dt = /* @__PURE__ */ qt();
+const Kt = /* @__PURE__ */ O(Dt);
+var gr = {}, q, mr;
+function Lt() {
+  if (mr) return q;
+  mr = 1;
+  var r = /* @__PURE__ */ $t(), e = /* @__PURE__ */ et(), t = TypeError, n = Object.getOwnPropertyDescriptor, a = r && !function() {
+    if (this !== void 0) return !0;
+    try {
+      Object.defineProperty([], "length", { writable: !1 }).length = 1;
+    } catch (i) {
+      return i instanceof TypeError;
+    }
+  }();
+  return q = a ? function(i, u) {
+    if (e(i) && !n(i, "length").writable)
+      throw new t("Cannot set read only .length");
+    return i.length = u;
+  } : function(i, u) {
+    return i.length = u;
+  }, q;
+}
+var wr;
+function Ut() {
+  if (wr) return gr;
+  wr = 1;
+  var r = /* @__PURE__ */ tr(), e = /* @__PURE__ */ rt(), t = /* @__PURE__ */ er(), n = /* @__PURE__ */ Lt(), a = /* @__PURE__ */ Ot(), i = /* @__PURE__ */ bt(), u = i(function() {
+    return [].push.call({ length: 4294967296 }, 1) !== 4294967297;
+  }), o = function() {
+    try {
+      Object.defineProperty([], "length", { writable: !1 }).push();
+    } catch (g) {
+      return g instanceof TypeError;
+    }
+  }, f = u || !o();
+  return r({ target: "Array", proto: !0, arity: 1, forced: f }, {
+    // eslint-disable-next-line no-unused-vars -- required for `.length`
+    push: function(g) {
+      var l = e(this), m = t(l), h = arguments.length;
+      a(m + h);
+      for (var y = 0; y < h; y++)
+        l[m] = arguments[y], m++;
+      return n(l, m), m;
+    }
+  }), gr;
+}
+var D, Ar;
+function Wt() {
+  if (Ar) return D;
+  Ar = 1, Ut();
+  var r = /* @__PURE__ */ _r();
+  return D = r("Array", "push"), D;
+}
+var K, $r;
+function Ht() {
+  if ($r) return K;
+  $r = 1;
+  var r = /* @__PURE__ */ Zr(), e = /* @__PURE__ */ Wt(), t = Array.prototype;
+  return K = function(n) {
+    var a = n.push;
+    return n === t || r(t, n) && a === t.push ? e : a;
+  }, K;
+}
+var L, br;
+function Qt() {
+  if (br) return L;
+  br = 1;
+  var r = /* @__PURE__ */ Ht();
+  return L = r, L;
+}
+var U, Or;
+function Vt() {
+  if (Or) return U;
+  Or = 1;
+  var r = /* @__PURE__ */ Qt();
+  return U = r, U;
+}
+var W, jr;
+function Xt() {
+  if (jr) return W;
+  jr = 1;
+  var r = /* @__PURE__ */ Vt();
+  return W = r, W;
+}
+var Tr, Ir;
+function Yt() {
+  return Ir || (Ir = 1, Tr = /* @__PURE__ */ Xt()), Tr;
+}
+var kt = /* @__PURE__ */ Yt();
+const zt = /* @__PURE__ */ O(kt);
+function Bt(r, e) {
+  var t = r == null ? null : typeof it < "u" && Kt(r) || r["@@iterator"];
+  if (t != null) {
+    var n, a, i, u, o = [], f = !0, g = !1;
+    try {
+      if (i = (t = t.call(r)).next, e === 0) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (n = i.call(t)).done) && (zt(o).call(o, n.value), o.length !== e); f = !0) ;
+    } catch (l) {
+      g = !0, a = l;
+    } finally {
+      try {
+        if (!f && t.return != null && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (g) throw a;
+      }
+    }
+    return o;
+  }
+}
+var xr = {}, Er;
+function Gt() {
+  if (Er) return xr;
+  Er = 1;
+  var r = /* @__PURE__ */ tr(), e = /* @__PURE__ */ et(), t = /* @__PURE__ */ tt(), n = /* @__PURE__ */ yt(), a = /* @__PURE__ */ ht(), i = /* @__PURE__ */ er(), u = /* @__PURE__ */ lt(), o = /* @__PURE__ */ nt(), f = /* @__PURE__ */ I(), g = /* @__PURE__ */ st(), l = /* @__PURE__ */ pt(), m = g("slice"), h = f("species"), y = Array, j = Math.max;
+  return r({ target: "Array", proto: !0, forced: !m }, {
+    slice: function(A, b) {
+      var p = u(this), v = i(p), s = a(A, v), d = a(b === void 0 ? v : b, v), c, w, $;
+      if (e(p) && (c = p.constructor, t(c) && (c === y || e(c.prototype)) ? c = void 0 : n(c) && (c = c[h], c === null && (c = void 0)), c === y || c === void 0))
+        return l(p, s, d);
+      for (w = new (c === void 0 ? y : c)(j(d - s, 0)), $ = 0; s < d; s++, $++) s in p && o(w, $, p[s]);
+      return w.length = $, w;
+    }
+  }), xr;
+}
+var H, Pr;
+function Jt() {
+  if (Pr) return H;
+  Pr = 1, Gt();
+  var r = /* @__PURE__ */ _r();
+  return H = r("Array", "slice"), H;
+}
+var Q, Sr;
+function Nt() {
+  if (Sr) return Q;
+  Sr = 1;
+  var r = /* @__PURE__ */ Zr(), e = /* @__PURE__ */ Jt(), t = Array.prototype;
+  return Q = function(n) {
+    var a = n.slice;
+    return n === t || r(t, n) && a === t.slice ? e : a;
+  }, Q;
+}
+var V, Cr;
+function Rt() {
+  if (Cr) return V;
+  Cr = 1;
+  var r = /* @__PURE__ */ Nt();
+  return V = r, V;
+}
+var X, Fr;
+function Zt() {
+  if (Fr) return X;
+  Fr = 1;
+  var r = /* @__PURE__ */ Rt();
+  return X = r, X;
+}
+var Y, Mr;
+function _t() {
+  if (Mr) return Y;
+  Mr = 1;
+  var r = /* @__PURE__ */ Zt();
+  return Y = r, Y;
+}
+var qr, Dr;
+function rn() {
+  return Dr || (Dr = 1, qr = /* @__PURE__ */ _t()), qr;
+}
+var tn = /* @__PURE__ */ rn();
+const nn = /* @__PURE__ */ O(tn);
+var Kr = {}, k, Lr;
+function en() {
+  if (Lr) return k;
+  Lr = 1;
+  var r = /* @__PURE__ */ nr(), e = /* @__PURE__ */ ar(), t = /* @__PURE__ */ at();
+  return k = function(n, a, i) {
+    var u, o;
+    e(n);
+    try {
+      if (u = t(n, "return"), !u) {
+        if (a === "throw") throw i;
+        return i;
+      }
+      u = r(u, n);
+    } catch (f) {
+      o = !0, u = f;
+    }
+    if (a === "throw") throw i;
+    if (o) throw u;
+    return e(u), i;
+  }, k;
+}
+var z, Ur;
+function an() {
+  if (Ur) return z;
+  Ur = 1;
+  var r = /* @__PURE__ */ ar(), e = /* @__PURE__ */ en();
+  return z = function(t, n, a, i) {
+    try {
+      return i ? n(r(a)[0], a[1]) : n(a);
+    } catch (u) {
+      e(t, "throw", u);
+    }
+  }, z;
+}
+var B, Wr;
+function un() {
+  if (Wr) return B;
+  Wr = 1;
+  var r = /* @__PURE__ */ I(), e = /* @__PURE__ */ ut(), t = r("iterator"), n = Array.prototype;
+  return B = function(a) {
+    return a !== void 0 && (e.Array === a || n[t] === a);
+  }, B;
+}
+var G, Hr;
+function on() {
+  if (Hr) return G;
+  Hr = 1;
+  var r = /* @__PURE__ */ nr(), e = /* @__PURE__ */ wt(), t = /* @__PURE__ */ ar(), n = /* @__PURE__ */ At(), a = /* @__PURE__ */ ur(), i = TypeError;
+  return G = function(u, o) {
+    var f = arguments.length < 2 ? a(u) : o;
+    if (e(f)) return t(r(f, u));
+    throw new i(n(u) + " is not iterable");
+  }, G;
+}
+var J, Qr;
+function fn() {
+  if (Qr) return J;
+  Qr = 1;
+  var r = /* @__PURE__ */ vt(), e = /* @__PURE__ */ nr(), t = /* @__PURE__ */ rt(), n = /* @__PURE__ */ an(), a = /* @__PURE__ */ un(), i = /* @__PURE__ */ tt(), u = /* @__PURE__ */ er(), o = /* @__PURE__ */ nt(), f = /* @__PURE__ */ on(), g = /* @__PURE__ */ ur(), l = Array;
+  return J = function(m) {
+    var h = t(m), y = i(this), j = arguments.length, A = j > 1 ? arguments[1] : void 0, b = A !== void 0;
+    b && (A = r(A, j > 2 ? arguments[2] : void 0));
+    var p = g(h), v = 0, s, d, c, w, $, T;
+    if (p && !(this === l && a(p)))
+      for (d = y ? new this() : [], w = f(h, p), $ = w.next; !(c = e($, w)).done; v++)
+        T = b ? n(w, A, [c.value, v], !0) : c.value, o(d, v, T);
+    else
+      for (s = u(h), d = y ? new this(s) : l(s); s > v; v++)
+        T = b ? A(h[v], v) : h[v], o(d, v, T);
+    return d.length = v, d;
+  }, J;
+}
+var N, Vr;
+function cn() {
+  if (Vr) return N;
+  Vr = 1;
+  var r = /* @__PURE__ */ I(), e = r("iterator"), t = !1;
+  try {
+    var n = 0, a = {
+      next: function() {
+        return { done: !!n++ };
+      },
+      return: function() {
+        t = !0;
+      }
+    };
+    a[e] = function() {
+      return this;
+    }, Array.from(a, function() {
+      throw 2;
+    });
+  } catch {
+  }
+  return N = function(i, u) {
+    try {
+      if (!u && !t) return !1;
+    } catch {
+      return !1;
+    }
+    var o = !1;
+    try {
+      var f = {};
+      f[e] = function() {
+        return {
+          next: function() {
+            return { done: o = !0 };
+          }
+        };
+      }, i(f);
+    } catch {
+    }
+    return o;
+  }, N;
+}
+var Xr;
+function vn() {
+  if (Xr) return Kr;
+  Xr = 1;
+  var r = /* @__PURE__ */ tr(), e = /* @__PURE__ */ fn(), t = /* @__PURE__ */ cn(), n = !t(function(a) {
+    Array.from(a);
+  });
+  return r({ target: "Array", stat: !0, forced: n }, {
+    from: e
+  }), Kr;
+}
+var R, Yr;
+function sn() {
+  if (Yr) return R;
+  Yr = 1, Rr(), vn();
+  var r = /* @__PURE__ */ ot();
+  return R = r.Array.from, R;
+}
+var Z, kr;
+function ln() {
+  if (kr) return Z;
+  kr = 1;
+  var r = /* @__PURE__ */ sn();
+  return Z = r, Z;
+}
+var _, zr;
+function hn() {
+  if (zr) return _;
+  zr = 1;
+  var r = /* @__PURE__ */ ln();
+  return _ = r, _;
+}
+var rr, Br;
+function yn() {
+  if (Br) return rr;
+  Br = 1;
+  var r = /* @__PURE__ */ hn();
+  return rr = r, rr;
+}
+var Gr, Jr;
+function pn() {
+  return Jr || (Jr = 1, Gr = /* @__PURE__ */ yn()), Gr;
+}
+var dn = /* @__PURE__ */ pn();
+const gn = /* @__PURE__ */ O(dn);
+function Nr(r, e) {
+  (e == null || e > r.length) && (e = r.length);
+  for (var t = 0, n = Array(e); t < e; t++) n[t] = r[t];
+  return n;
+}
+function mn(r, e) {
+  if (r) {
+    var t;
+    if (typeof r == "string") return Nr(r, e);
+    var n = nn(t = {}.toString.call(r)).call(t, 8, -1);
+    return n === "Object" && r.constructor && (n = r.constructor.name), n === "Map" || n === "Set" ? gn(r) : n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n) ? Nr(r, e) : void 0;
+  }
+}
+function wn() {
+  throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function $n(r, e) {
+  return Pt(r) || Bt(r, e) || mn(r, e) || wn();
+}
+export {
+  wn as $,
+  Et as C,
+  Kt as F,
+  mn as I,
+  Lt as L,
+  $n as S,
+  Pt as T,
+  Nr as X,
+  Rt as Y,
+  ur as c,
+  ln as h,
+  un as i,
+  en as n,
+  gn as q,
+  on as u
+};