npm - laif-ds - Versions diffs - 0.2.5 → 0.2.6 - Mend

laif-ds 0.2.5 → 0.2.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1696) hide show

package/dist/dist/node_modules/@floating-ui/dom/dist/floating-ui.dom.js ADDED Viewed

@@ -0,0 +1,400 @@
+"use client";
+import { offset as it, shift as ot, flip as rt, size as st, hide as lt, limitShift as ct, computePosition as ft, arrow as at } from "../../core/dist/floating-ui.core.js";
+import { createCoords as x, round as z, max as F, min as P, rectToClientRect as K, floor as $ } from "../../utils/dist/floating-ui.utils.js";
+import { isElement as v, getDocumentElement as T, getOverflowAncestors as S, getComputedStyle as b, isHTMLElement as L, getWindow as C, isTopLayer as V, getParentNode as W, isLastTraversableNode as A, isTableElement as ut, getContainingBlock as ht, isContainingBlock as U, getNodeName as I, isOverflowElement as M, getNodeScroll as D, getFrameElement as _, isWebKit as X } from "../../utils/dist/floating-ui.utils.dom.js";
+function Z(t) {
+  const e = b(t);
+  let n = parseFloat(e.width) || 0, i = parseFloat(e.height) || 0;
+  const o = L(t), s = o ? t.offsetWidth : n, r = o ? t.offsetHeight : i, l = z(n) !== s || z(i) !== r;
+  return l && (n = s, i = r), {
+    width: n,
+    height: i,
+    $: l
+  };
+}
+function k(t) {
+  return v(t) ? t : t.contextElement;
+}
+function O(t) {
+  const e = k(t);
+  if (!L(e))
+    return x(1);
+  const n = e.getBoundingClientRect(), {
+    width: i,
+    height: o,
+    $: s
+  } = Z(e);
+  let r = (s ? z(n.width) : n.width) / i, l = (s ? z(n.height) : n.height) / o;
+  return (!r || !Number.isFinite(r)) && (r = 1), (!l || !Number.isFinite(l)) && (l = 1), {
+    x: r,
+    y: l
+  };
+}
+const dt = /* @__PURE__ */ x(0);
+function J(t) {
+  const e = C(t);
+  return !X() || !e.visualViewport ? dt : {
+    x: e.visualViewport.offsetLeft,
+    y: e.visualViewport.offsetTop
+  };
+}
+function gt(t, e, n) {
+  return e === void 0 && (e = !1), !n || e && n !== C(t) ? !1 : e;
+}
+function E(t, e, n, i) {
+  e === void 0 && (e = !1), n === void 0 && (n = !1);
+  const o = t.getBoundingClientRect(), s = k(t);
+  let r = x(1);
+  e && (i ? v(i) && (r = O(i)) : r = O(t));
+  const l = gt(s, n, i) ? J(s) : x(0);
+  let c = (o.left + l.x) / r.x, f = (o.top + l.y) / r.y, a = o.width / r.x, g = o.height / r.y;
+  if (s) {
+    const p = C(s), u = i && v(i) ? C(i) : i;
+    let w = p, d = _(w);
+    for (; d && i && u !== w; ) {
+      const m = O(d), h = d.getBoundingClientRect(), y = b(d), R = h.left + (d.clientLeft + parseFloat(y.paddingLeft)) * m.x, B = h.top + (d.clientTop + parseFloat(y.paddingTop)) * m.y;
+      c *= m.x, f *= m.y, a *= m.x, g *= m.y, c += R, f += B, w = C(d), d = _(w);
+    }
+  }
+  return K({
+    width: a,
+    height: g,
+    x: c,
+    y: f
+  });
+}
+function q(t, e) {
+  const n = D(t).scrollLeft;
+  return e ? e.left + n : E(T(t)).left + n;
+}
+function Q(t, e, n) {
+  n === void 0 && (n = !1);
+  const i = t.getBoundingClientRect(), o = i.left + e.scrollLeft - (n ? 0 : (
+    // RTL <body> scrollbar.
+    q(t, i)
+  )), s = i.top + e.scrollTop;
+  return {
+    x: o,
+    y: s
+  };
+}
+function pt(t) {
+  let {
+    elements: e,
+    rect: n,
+    offsetParent: i,
+    strategy: o
+  } = t;
+  const s = o === "fixed", r = T(i), l = e ? V(e.floating) : !1;
+  if (i === r || l && s)
+    return n;
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, f = x(1);
+  const a = x(0), g = L(i);
+  if ((g || !g && !s) && ((I(i) !== "body" || M(r)) && (c = D(i)), L(i))) {
+    const u = E(i);
+    f = O(i), a.x = u.x + i.clientLeft, a.y = u.y + i.clientTop;
+  }
+  const p = r && !g && !s ? Q(r, c, !0) : x(0);
+  return {
+    width: n.width * f.x,
+    height: n.height * f.y,
+    x: n.x * f.x - c.scrollLeft * f.x + a.x + p.x,
+    y: n.y * f.y - c.scrollTop * f.y + a.y + p.y
+  };
+}
+function mt(t) {
+  return Array.from(t.getClientRects());
+}
+function yt(t) {
+  const e = T(t), n = D(t), i = t.ownerDocument.body, o = F(e.scrollWidth, e.clientWidth, i.scrollWidth, i.clientWidth), s = F(e.scrollHeight, e.clientHeight, i.scrollHeight, i.clientHeight);
+  let r = -n.scrollLeft + q(t);
+  const l = -n.scrollTop;
+  return b(i).direction === "rtl" && (r += F(e.clientWidth, i.clientWidth) - o), {
+    width: o,
+    height: s,
+    x: r,
+    y: l
+  };
+}
+function xt(t, e) {
+  const n = C(t), i = T(t), o = n.visualViewport;
+  let s = i.clientWidth, r = i.clientHeight, l = 0, c = 0;
+  if (o) {
+    s = o.width, r = o.height;
+    const f = X();
+    (!f || f && e === "fixed") && (l = o.offsetLeft, c = o.offsetTop);
+  }
+  return {
+    width: s,
+    height: r,
+    x: l,
+    y: c
+  };
+}
+function wt(t, e) {
+  const n = E(t, !0, e === "fixed"), i = n.top + t.clientTop, o = n.left + t.clientLeft, s = L(t) ? O(t) : x(1), r = t.clientWidth * s.x, l = t.clientHeight * s.y, c = o * s.x, f = i * s.y;
+  return {
+    width: r,
+    height: l,
+    x: c,
+    y: f
+  };
+}
+function j(t, e, n) {
+  let i;
+  if (e === "viewport")
+    i = xt(t, n);
+  else if (e === "document")
+    i = yt(T(t));
+  else if (v(e))
+    i = wt(e, n);
+  else {
+    const o = J(t);
+    i = {
+      x: e.x - o.x,
+      y: e.y - o.y,
+      width: e.width,
+      height: e.height
+    };
+  }
+  return K(i);
+}
+function Y(t, e) {
+  const n = W(t);
+  return n === e || !v(n) || A(n) ? !1 : b(n).position === "fixed" || Y(n, e);
+}
+function vt(t, e) {
+  const n = e.get(t);
+  if (n)
+    return n;
+  let i = S(t, [], !1).filter((l) => v(l) && I(l) !== "body"), o = null;
+  const s = b(t).position === "fixed";
+  let r = s ? W(t) : t;
+  for (; v(r) && !A(r); ) {
+    const l = b(r), c = U(r);
+    !c && l.position === "fixed" && (o = null), (s ? !c && !o : !c && l.position === "static" && o && ["absolute", "fixed"].includes(o.position) || M(r) && !c && Y(t, r)) ? i = i.filter((f) => f !== r) : o = l, r = W(r);
+  }
+  return e.set(t, i), i;
+}
+function bt(t) {
+  let {
+    element: e,
+    boundary: n,
+    rootBoundary: i,
+    strategy: o
+  } = t;
+  const s = [...n === "clippingAncestors" ? V(e) ? [] : vt(e, this._c) : [].concat(n), i], r = s[0], l = s.reduce((c, f) => {
+    const a = j(e, f, o);
+    return c.top = F(a.top, c.top), c.right = P(a.right, c.right), c.bottom = P(a.bottom, c.bottom), c.left = F(a.left, c.left), c;
+  }, j(e, r, o));
+  return {
+    width: l.right - l.left,
+    height: l.bottom - l.top,
+    x: l.left,
+    y: l.top
+  };
+}
+function Tt(t) {
+  const {
+    width: e,
+    height: n
+  } = Z(t);
+  return {
+    width: e,
+    height: n
+  };
+}
+function Lt(t, e, n) {
+  const i = L(e), o = T(e), s = n === "fixed", r = E(t, !0, s, e);
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const c = x(0);
+  function f() {
+    c.x = q(o);
+  }
+  if (i || !i && !s)
+    if ((I(e) !== "body" || M(o)) && (l = D(e)), i) {
+      const u = E(e, !0, s, e);
+      c.x = u.x + e.clientLeft, c.y = u.y + e.clientTop;
+    } else o && f();
+  s && !i && o && f();
+  const a = o && !i && !s ? Q(o, l) : x(0), g = r.left + l.scrollLeft - c.x - a.x, p = r.top + l.scrollTop - c.y - a.y;
+  return {
+    x: g,
+    y: p,
+    width: r.width,
+    height: r.height
+  };
+}
+function N(t) {
+  return b(t).position === "static";
+}
+function G(t, e) {
+  if (!L(t) || b(t).position === "fixed")
+    return null;
+  if (e)
+    return e(t);
+  let n = t.offsetParent;
+  return T(t) === n && (n = n.ownerDocument.body), n;
+}
+function tt(t, e) {
+  const n = C(t);
+  if (V(t))
+    return n;
+  if (!L(t)) {
+    let o = W(t);
+    for (; o && !A(o); ) {
+      if (v(o) && !N(o))
+        return o;
+      o = W(o);
+    }
+    return n;
+  }
+  let i = G(t, e);
+  for (; i && ut(i) && N(i); )
+    i = G(i, e);
+  return i && A(i) && N(i) && !U(i) ? n : i || ht(t) || n;
+}
+const Rt = async function(t) {
+  const e = this.getOffsetParent || tt, n = this.getDimensions, i = await n(t.floating);
+  return {
+    reference: Lt(t.reference, await e(t.floating), t.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: i.width,
+      height: i.height
+    }
+  };
+};
+function Ct(t) {
+  return b(t).direction === "rtl";
+}
+const Et = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: pt,
+  getDocumentElement: T,
+  getClippingRect: bt,
+  getOffsetParent: tt,
+  getElementRects: Rt,
+  getClientRects: mt,
+  getDimensions: Tt,
+  getScale: O,
+  isElement: v,
+  isRTL: Ct
+};
+function et(t, e) {
+  return t.x === e.x && t.y === e.y && t.width === e.width && t.height === e.height;
+}
+function Ft(t, e) {
+  let n = null, i;
+  const o = T(t);
+  function s() {
+    var l;
+    clearTimeout(i), (l = n) == null || l.disconnect(), n = null;
+  }
+  function r(l, c) {
+    l === void 0 && (l = !1), c === void 0 && (c = 1), s();
+    const f = t.getBoundingClientRect(), {
+      left: a,
+      top: g,
+      width: p,
+      height: u
+    } = f;
+    if (l || e(), !p || !u)
+      return;
+    const w = $(g), d = $(o.clientWidth - (a + p)), m = $(o.clientHeight - (g + u)), h = $(a), y = {
+      rootMargin: -w + "px " + -d + "px " + -m + "px " + -h + "px",
+      threshold: F(0, P(1, c)) || 1
+    };
+    let R = !0;
+    function B(nt) {
+      const H = nt[0].intersectionRatio;
+      if (H !== c) {
+        if (!R)
+          return r();
+        H ? r(!1, H) : i = setTimeout(() => {
+          r(!1, 1e-7);
+        }, 1e3);
+      }
+      H === 1 && !et(f, t.getBoundingClientRect()) && r(), R = !1;
+    }
+    try {
+      n = new IntersectionObserver(B, {
+        ...y,
+        // Handle <iframe>s
+        root: o.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(B, y);
+    }
+    n.observe(t);
+  }
+  return r(!0), s;
+}
+function Ht(t, e, n, i) {
+  i === void 0 && (i = {});
+  const {
+    ancestorScroll: o = !0,
+    ancestorResize: s = !0,
+    elementResize: r = typeof ResizeObserver == "function",
+    layoutShift: l = typeof IntersectionObserver == "function",
+    animationFrame: c = !1
+  } = i, f = k(t), a = o || s ? [...f ? S(f) : [], ...S(e)] : [];
+  a.forEach((h) => {
+    o && h.addEventListener("scroll", n, {
+      passive: !0
+    }), s && h.addEventListener("resize", n);
+  });
+  const g = f && l ? Ft(f, n) : null;
+  let p = -1, u = null;
+  r && (u = new ResizeObserver((h) => {
+    let [y] = h;
+    y && y.target === f && u && (u.unobserve(e), cancelAnimationFrame(p), p = requestAnimationFrame(() => {
+      var R;
+      (R = u) == null || R.observe(e);
+    })), n();
+  }), f && !c && u.observe(f), u.observe(e));
+  let w, d = c ? E(t) : null;
+  c && m();
+  function m() {
+    const h = E(t);
+    d && !et(d, h) && n(), d = h, w = requestAnimationFrame(m);
+  }
+  return n(), () => {
+    var h;
+    a.forEach((y) => {
+      o && y.removeEventListener("scroll", n), s && y.removeEventListener("resize", n);
+    }), g?.(), (h = u) == null || h.disconnect(), u = null, c && cancelAnimationFrame(w);
+  };
+}
+const $t = it, zt = ot, At = rt, Dt = st, Nt = lt, Pt = at, St = ct, Vt = (t, e, n) => {
+  const i = /* @__PURE__ */ new Map(), o = {
+    platform: Et,
+    ...n
+  }, s = {
+    ...o.platform,
+    _c: i
+  };
+  return ft(t, e, {
+    ...o,
+    platform: s
+  });
+};
+export {
+  Pt as arrow,
+  Ht as autoUpdate,
+  Vt as computePosition,
+  At as flip,
+  S as getOverflowAncestors,
+  Nt as hide,
+  St as limitShift,
+  $t as offset,
+  Et as platform,
+  zt as shift,
+  Dt as size
+};

package/dist/dist/node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.js ADDED Viewed

@@ -0,0 +1,208 @@
+"use client";
+import { computePosition as L, offset as N, shift as W, flip as J, size as K, hide as Q, limitShift as T, arrow as z } from "../../dom/dist/floating-ui.dom.js";
+import { autoUpdate as mt, platform as dt } from "../../dom/dist/floating-ui.dom.js";
+import * as o from "react";
+import { useLayoutEffect as X, useEffect as Y } from "react";
+import * as Z from "react-dom";
+var w = typeof document < "u" ? X : Y;
+function S(t, e) {
+  if (t === e)
+    return !0;
+  if (typeof t != typeof e)
+    return !1;
+  if (typeof t == "function" && t.toString() === e.toString())
+    return !0;
+  let r, n, u;
+  if (t && e && typeof t == "object") {
+    if (Array.isArray(t)) {
+      if (r = t.length, r !== e.length) return !1;
+      for (n = r; n-- !== 0; )
+        if (!S(t[n], e[n]))
+          return !1;
+      return !0;
+    }
+    if (u = Object.keys(t), r = u.length, r !== Object.keys(e).length)
+      return !1;
+    for (n = r; n-- !== 0; )
+      if (!{}.hasOwnProperty.call(e, u[n]))
+        return !1;
+    for (n = r; n-- !== 0; ) {
+      const d = u[n];
+      if (!(d === "_owner" && t.$$typeof) && !S(t[d], e[d]))
+        return !1;
+    }
+    return !0;
+  }
+  return t !== t && e !== e;
+}
+function V(t) {
+  return typeof window > "u" ? 1 : (t.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function F(t, e) {
+  const r = V(t);
+  return Math.round(e * r) / r;
+}
+function k(t) {
+  const e = o.useRef(t);
+  return w(() => {
+    e.current = t;
+  }), e;
+}
+function nt(t) {
+  t === void 0 && (t = {});
+  const {
+    placement: e = "bottom",
+    strategy: r = "absolute",
+    middleware: n = [],
+    platform: u,
+    elements: {
+      reference: d,
+      floating: H
+    } = {},
+    transform: O = !0,
+    whileElementsMounted: C,
+    open: P
+  } = t, [i, j] = o.useState({
+    x: 0,
+    y: 0,
+    strategy: r,
+    placement: e,
+    middlewareData: {},
+    isPositioned: !1
+  }), [R, U] = o.useState(n);
+  S(R, n) || U(n);
+  const [_, q] = o.useState(null), [B, G] = o.useState(null), v = o.useCallback((s) => {
+    s !== c.current && (c.current = s, q(s));
+  }, []), A = o.useCallback((s) => {
+    s !== p.current && (p.current = s, G(s));
+  }, []), a = d || _, f = H || B, c = o.useRef(null), p = o.useRef(null), y = o.useRef(i), I = C != null, x = k(C), M = k(u), D = k(P), g = o.useCallback(() => {
+    if (!c.current || !p.current)
+      return;
+    const s = {
+      placement: e,
+      strategy: r,
+      middleware: R
+    };
+    M.current && (s.platform = M.current), L(c.current, p.current, s).then((h) => {
+      const m = {
+        ...h,
+        // The floating element's position may be recomputed while it's closed
+        // but still mounted (such as when transitioning out). To ensure
+        // `isPositioned` will be `false` initially on the next open, avoid
+        // setting it to `true` when `open === false` (must be specified).
+        isPositioned: D.current !== !1
+      };
+      b.current && !S(y.current, m) && (y.current = m, Z.flushSync(() => {
+        j(m);
+      }));
+    });
+  }, [R, e, r, M, D]);
+  w(() => {
+    P === !1 && y.current.isPositioned && (y.current.isPositioned = !1, j((s) => ({
+      ...s,
+      isPositioned: !1
+    })));
+  }, [P]);
+  const b = o.useRef(!1);
+  w(() => (b.current = !0, () => {
+    b.current = !1;
+  }), []), w(() => {
+    if (a && (c.current = a), f && (p.current = f), a && f) {
+      if (x.current)
+        return x.current(a, f, g);
+      g();
+    }
+  }, [a, f, g, x, I]);
+  const E = o.useMemo(() => ({
+    reference: c,
+    floating: p,
+    setReference: v,
+    setFloating: A
+  }), [v, A]), l = o.useMemo(() => ({
+    reference: a,
+    floating: f
+  }), [a, f]), $ = o.useMemo(() => {
+    const s = {
+      position: r,
+      left: 0,
+      top: 0
+    };
+    if (!l.floating)
+      return s;
+    const h = F(l.floating, i.x), m = F(l.floating, i.y);
+    return O ? {
+      ...s,
+      transform: "translate(" + h + "px, " + m + "px)",
+      ...V(l.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: r,
+      left: h,
+      top: m
+    };
+  }, [r, O, l.floating, i.x, i.y]);
+  return o.useMemo(() => ({
+    ...i,
+    update: g,
+    refs: E,
+    elements: l,
+    floatingStyles: $
+  }), [i, g, E, l, $]);
+}
+const tt = (t) => {
+  function e(r) {
+    return {}.hasOwnProperty.call(r, "current");
+  }
+  return {
+    name: "arrow",
+    options: t,
+    fn(r) {
+      const {
+        element: n,
+        padding: u
+      } = typeof t == "function" ? t(r) : t;
+      return n && e(n) ? n.current != null ? z({
+        element: n.current,
+        padding: u
+      }).fn(r) : {} : n ? z({
+        element: n,
+        padding: u
+      }).fn(r) : {};
+    }
+  };
+}, ot = (t, e) => ({
+  ...N(t),
+  options: [t, e]
+}), st = (t, e) => ({
+  ...W(t),
+  options: [t, e]
+}), ut = (t, e) => ({
+  ...T(t),
+  options: [t, e]
+}), it = (t, e) => ({
+  ...J(t),
+  options: [t, e]
+}), at = (t, e) => ({
+  ...K(t),
+  options: [t, e]
+}), ft = (t, e) => ({
+  ...Q(t),
+  options: [t, e]
+}), lt = (t, e) => ({
+  ...tt(t),
+  options: [t, e]
+});
+export {
+  lt as arrow,
+  mt as autoUpdate,
+  L as computePosition,
+  it as flip,
+  ft as hide,
+  ut as limitShift,
+  ot as offset,
+  dt as platform,
+  st as shift,
+  at as size,
+  nt as useFloating
+};