@fluidattacks/design 8.0.0 → 8.2.0

package/dist/node_modules/@cloudinary/url-gen/sdkAnalytics/getSDKAnalyticsSignature.js

@@ -0,0 +1,45 @@
+import { encodeVersion as r } from "./encodeVersion.js";
+import { getAnalyticsOptions as l } from "./getAnalyticsOptions.js";
+import { packageVersion as u } from "../internal/utils/packageVersion.js";
+import { encodeOSVersion as V } from "./encodeOSVersion.js";
+function m() {
+  const e = "0.0.0";
+  if (typeof window < "u")
+    return e;
+  try {
+    return process.versions.node || e;
+  } catch {
+    return e;
+  }
+}
+function y(e) {
+  const o = {
+    techVersion: m(),
+    sdkCode: "T",
+    sdkSemver: u.split("-")[0],
+    product: "A",
+    osType: "Z",
+    osVersion: "0.0",
+    responsive: !1,
+    placeholder: !1,
+    lazyload: !1,
+    accessibility: !1
+  };
+  return e ? Object.assign(Object.assign({}, o), e) : o;
+}
+function v(e) {
+  const o = y(e), s = l(o);
+  try {
+    const n = S(s.techVersion), t = r(s.sdkSemver), i = r(n), c = V(s.osVersion), a = s.feature, d = s.sdkCode, { product: f, osType: p } = s;
+    return `D${f}${d}${t}${i}${p}${c}${a}`;
+  } catch {
+    return "E";
+  }
+}
+function S(e) {
+  const o = e.split(".");
+  return `${o[0]}.${o[1]}`;
+}
+export {
+  v as getSDKAnalyticsSignature
+};

package/dist/node_modules/@cloudinary/url-gen/sdkAnalytics/padVersion.js

@@ -0,0 +1,14 @@
+import { stringPad as n } from "./stringPad.js";
+function e(r) {
+  if (r.split(".").length < 2)
+    throw new Error("invalid semVer, must have at least two segments");
+  return r.split(".").map((t) => {
+    const i = +t;
+    if (isNaN(i) || i < 0)
+      throw "Invalid version number provided";
+    return n(t, 2, "0");
+  }).join(".");
+}
+export {
+  e as padVersion
+};

package/dist/node_modules/@cloudinary/url-gen/sdkAnalytics/reverseVersion.js

@@ -0,0 +1,8 @@
+function r(e) {
+  if (e.split(".").length < 2)
+    throw new Error("invalid semVer, must have at least two segments");
+  return e.split(".").reverse().join(".");
+}
+export {
+  r as reverseVersion
+};

package/dist/node_modules/@cloudinary/url-gen/sdkAnalytics/stringPad.js

@@ -0,0 +1,13 @@
+function l(e, i, r) {
+  let t = i >> 0, n = String(r);
+  return e.length > t ? String(e) : (t = t - e.length, t > n.length && (n += g(n, t / n.length)), n.slice(0, t) + String(e));
+}
+function g(e, i) {
+  let r = i, t = "";
+  for (; r > 0; )
+    t += e, r--;
+  return t;
+}
+export {
+  l as stringPad
+};

package/dist/node_modules/@fastify/deepmerge/index.js

@@ -0,0 +1,102 @@
+import { __module as m } from "../../../_virtual/index6.js";
+var P;
+function E() {
+  return P ? m.exports : (P = 1, (function(y) {
+    const j = Object.getPrototypeOf({});
+    function d() {
+      return function(l) {
+        return typeof l == "object" && l !== null && !(l instanceof RegExp) && !(l instanceof Date);
+      };
+    }
+    function O(i) {
+      function l(e) {
+        return e !== "constructor" && e !== "prototype" && e !== "__proto__";
+      }
+      function h(e) {
+        let t = 0;
+        const r = e.length, n = new Array(r);
+        for (t; t < r; ++t)
+          n[t] = f(e[t]);
+        return n;
+      }
+      function _(e) {
+        const t = {};
+        if (p && Object.getPrototypeOf(e) !== j)
+          return p(e);
+        const r = g(e);
+        let n, o, s;
+        for (n = 0, o = r.length; n < o; ++n)
+          l(s = r[n]) && (t[s] = f(e[s]));
+        return t;
+      }
+      function x(e, t) {
+        const r = e.length, n = t.length;
+        let o = 0;
+        const s = new Array(r + n);
+        for (o; o < r; ++o)
+          s[o] = f(e[o]);
+        for (o = 0; o < n; ++o)
+          s[o + r] = f(t[o]);
+        return s;
+      }
+      const I = Object.prototype.propertyIsEnumerable;
+      function K(e) {
+        const t = Object.keys(e), r = Object.getOwnPropertySymbols(e);
+        for (let n = 0, o = r.length; n < o; ++n)
+          I.call(e, r[n]) && t.push(r[n]);
+        return t;
+      }
+      const g = i?.symbols ? K : Object.keys, p = typeof i?.cloneProtoObject == "function" ? i.cloneProtoObject : void 0, b = typeof i?.isMergeableObject == "function" ? i.isMergeableObject : d(), A = i?.onlyDefinedProperties === !0;
+      function M(e) {
+        return typeof e != "object" || e === null;
+      }
+      const k = i && typeof i.mergeArray == "function" ? i.mergeArray({ clone: f, deepmerge: u, getKeys: g, isMergeableObject: b }) : x;
+      function f(e) {
+        return b(e) ? Array.isArray(e) ? h(e) : _(e) : e;
+      }
+      function D(e, t) {
+        const r = {}, n = g(e), o = g(t);
+        let s, a, c;
+        for (s = 0, a = n.length; s < a; ++s)
+          l(c = n[s]) && o.indexOf(c) === -1 && (r[c] = f(e[c]));
+        for (s = 0, a = o.length; s < a; ++s)
+          if (l(c = o[s]))
+            if (c in e)
+              n.indexOf(c) !== -1 && (p && b(t[c]) && Object.getPrototypeOf(t[c]) !== j ? r[c] = p(t[c]) : r[c] = u(e[c], t[c]));
+            else {
+              if (A && typeof t[c] > "u")
+                continue;
+              r[c] = f(t[c]);
+            }
+        return r;
+      }
+      function u(e, t) {
+        if (A && typeof t > "u")
+          return f(e);
+        const r = Array.isArray(t), n = Array.isArray(e);
+        return M(t) ? t : b(e) ? r && n ? k(e, t) : r !== n ? f(t) : D(e, t) : f(t);
+      }
+      function w() {
+        switch (arguments.length) {
+          case 0:
+            return {};
+          case 1:
+            return f(arguments[0]);
+          case 2:
+            return u(arguments[0], arguments[1]);
+        }
+        let e;
+        for (let t = 0, r = arguments.length; t < r; ++t)
+          e = u(e, arguments[t]);
+        return e;
+      }
+      return i?.all ? w : u;
+    }
+    y.exports = O, y.exports.default = O, y.exports.deepmerge = O, Object.defineProperty(y.exports, "isMergeableObject", {
+      get: d
+    });
+  })(m), m.exports);
+}
+export {
+  E as __require
+};

package/dist/node_modules/@floating-ui/core/dist/floating-ui.core.js

@@ -0,0 +1,507 @@
+import { getSideAxis as F, getAlignmentAxis as N, getSide as B, getAlignment as _, evaluate as W, getPaddingObject as U, rectToClientRect as z, getOppositePlacement as K, getExpandedPlacements as Q, getOppositeAxisPlacements as Z, getAlignmentSides as q, clamp as Y, getAxisLength as G, getOppositeAxis as ee, min as H, max as j, placements as X, getOppositeAlignmentPlacement as te } from "../../utils/dist/floating-ui.utils.js";
+function I(e, t, d) {
+  let {
+    reference: i,
+    floating: n
+  } = e;
+  const o = F(t), s = N(t), f = G(s), u = B(t), p = o === "y", c = i.x + i.width / 2 - n.width / 2, r = i.y + i.height / 2 - n.height / 2, m = i[f] / 2 - n[f] / 2;
+  let l;
+  switch (u) {
+    case "top":
+      l = {
+        x: c,
+        y: i.y - n.height
+      };
+      break;
+    case "bottom":
+      l = {
+        x: c,
+        y: i.y + i.height
+      };
+      break;
+    case "right":
+      l = {
+        x: i.x + i.width,
+        y: r
+      };
+      break;
+    case "left":
+      l = {
+        x: i.x - n.width,
+        y: r
+      };
+      break;
+    default:
+      l = {
+        x: i.x,
+        y: i.y
+      };
+  }
+  switch (_(t)) {
+    case "start":
+      l[s] -= m * (d && p ? -1 : 1);
+      break;
+    case "end":
+      l[s] += m * (d && p ? -1 : 1);
+      break;
+  }
+  return l;
+}
+async function ne(e, t) {
+  var d;
+  t === void 0 && (t = {});
+  const {
+    x: i,
+    y: n,
+    platform: o,
+    rects: s,
+    elements: f,
+    strategy: u
+  } = e, {
+    boundary: p = "clippingAncestors",
+    rootBoundary: c = "viewport",
+    elementContext: r = "floating",
+    altBoundary: m = !1,
+    padding: l = 0
+  } = W(t, e), a = U(l), v = f[m ? r === "floating" ? "reference" : "floating" : r], w = z(await o.getClippingRect({
+    element: (d = await (o.isElement == null ? void 0 : o.isElement(v))) == null || d ? v : v.contextElement || await (o.getDocumentElement == null ? void 0 : o.getDocumentElement(f.floating)),
+    boundary: p,
+    rootBoundary: c,
+    strategy: u
+  })), x = r === "floating" ? {
+    x: i,
+    y: n,
+    width: s.floating.width,
+    height: s.floating.height
+  } : s.reference, h = await (o.getOffsetParent == null ? void 0 : o.getOffsetParent(f.floating)), A = await (o.isElement == null ? void 0 : o.isElement(h)) ? await (o.getScale == null ? void 0 : o.getScale(h)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, P = z(o.convertOffsetParentRelativeRectToViewportRelativeRect ? await o.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: f,
+    rect: x,
+    offsetParent: h,
+    strategy: u
+  }) : x);
+  return {
+    top: (w.top - P.top + a.top) / A.y,
+    bottom: (P.bottom - w.bottom + a.bottom) / A.y,
+    left: (w.left - P.left + a.left) / A.x,
+    right: (P.right - w.right + a.right) / A.x
+  };
+}
+const ie = 50, ce = async (e, t, d) => {
+  const {
+    placement: i = "bottom",
+    strategy: n = "absolute",
+    middleware: o = [],
+    platform: s
+  } = d, f = s.detectOverflow ? s : {
+    ...s,
+    detectOverflow: ne
+  }, u = await (s.isRTL == null ? void 0 : s.isRTL(t));
+  let p = await s.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: n
+  }), {
+    x: c,
+    y: r
+  } = I(p, i, u), m = i, l = 0;
+  const a = {};
+  for (let g = 0; g < o.length; g++) {
+    const v = o[g];
+    if (!v)
+      continue;
+    const {
+      name: w,
+      fn: x
+    } = v, {
+      x: h,
+      y: A,
+      data: P,
+      reset: b
+    } = await x({
+      x: c,
+      y: r,
+      initialPlacement: i,
+      placement: m,
+      strategy: n,
+      middlewareData: a,
+      rects: p,
+      platform: f,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    c = h ?? c, r = A ?? r, a[w] = {
+      ...a[w],
+      ...P
+    }, b && l < ie && (l++, typeof b == "object" && (b.placement && (m = b.placement), b.rects && (p = b.rects === !0 ? await s.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: n
+    }) : b.rects), {
+      x: c,
+      y: r
+    } = I(p, m, u)), g = -1);
+  }
+  return {
+    x: c,
+    y: r,
+    placement: m,
+    strategy: n,
+    middlewareData: a
+  };
+}, re = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(t) {
+    const {
+      x: d,
+      y: i,
+      placement: n,
+      rects: o,
+      platform: s,
+      elements: f,
+      middlewareData: u
+    } = t, {
+      element: p,
+      padding: c = 0
+    } = W(e, t) || {};
+    if (p == null)
+      return {};
+    const r = U(c), m = {
+      x: d,
+      y: i
+    }, l = N(n), a = G(l), g = await s.getDimensions(p), v = l === "y", w = v ? "top" : "left", x = v ? "bottom" : "right", h = v ? "clientHeight" : "clientWidth", A = o.reference[a] + o.reference[l] - m[l] - o.floating[a], P = m[l] - o.reference[l], b = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(p));
+    let S = b ? b[h] : 0;
+    (!S || !await (s.isElement == null ? void 0 : s.isElement(b))) && (S = f.floating[h] || o.floating[a]);
+    const E = A / 2 - P / 2, D = S / 2 - g[a] / 2 - 1, y = H(r[w], D), R = H(r[x], D), C = y, L = S - g[a] - R, O = S / 2 - g[a] / 2 + E, V = Y(C, O, L), M = !u.arrow && _(n) != null && O !== V && o.reference[a] / 2 - (O < C ? y : R) - g[a] / 2 < 0, T = M ? O < C ? O - C : O - L : 0;
+    return {
+      [l]: m[l] + T,
+      data: {
+        [l]: V,
+        centerOffset: O - V - T,
+        ...M && {
+          alignmentOffset: T
+        }
+      },
+      reset: M
+    };
+  }
+});
+function oe(e, t, d) {
+  return (e ? [...d.filter((n) => _(n) === e), ...d.filter((n) => _(n) !== e)] : d.filter((n) => B(n) === n)).filter((n) => e ? _(n) === e || (t ? te(n) !== n : !1) : !0);
+}
+const fe = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "autoPlacement",
+    options: e,
+    async fn(t) {
+      var d, i, n;
+      const {
+        rects: o,
+        middlewareData: s,
+        placement: f,
+        platform: u,
+        elements: p
+      } = t, {
+        crossAxis: c = !1,
+        alignment: r,
+        allowedPlacements: m = X,
+        autoAlignment: l = !0,
+        ...a
+      } = W(e, t), g = r !== void 0 || m === X ? oe(r || null, l, m) : m, v = await u.detectOverflow(t, a), w = ((d = s.autoPlacement) == null ? void 0 : d.index) || 0, x = g[w];
+      if (x == null)
+        return {};
+      const h = q(x, o, await (u.isRTL == null ? void 0 : u.isRTL(p.floating)));
+      if (f !== x)
+        return {
+          reset: {
+            placement: g[0]
+          }
+        };
+      const A = [v[B(x)], v[h[0]], v[h[1]]], P = [...((i = s.autoPlacement) == null ? void 0 : i.overflows) || [], {
+        placement: x,
+        overflows: A
+      }], b = g[w + 1];
+      if (b)
+        return {
+          data: {
+            index: w + 1,
+            overflows: P
+          },
+          reset: {
+            placement: b
+          }
+        };
+      const S = P.map((y) => {
+        const R = _(y.placement);
+        return [y.placement, R && c ? (
+          // Check along the mainAxis and main crossAxis side.
+          y.overflows.slice(0, 2).reduce((C, L) => C + L, 0)
+        ) : (
+          // Check only the mainAxis.
+          y.overflows[0]
+        ), y.overflows];
+      }).sort((y, R) => y[1] - R[1]), D = ((n = S.filter((y) => y[2].slice(
+        0,
+        // Aligned placements should not check their opposite crossAxis
+        // side.
+        _(y[0]) ? 2 : 3
+      ).every((R) => R <= 0))[0]) == null ? void 0 : n[0]) || S[0][0];
+      return D !== f ? {
+        data: {
+          index: w + 1,
+          overflows: P
+        },
+        reset: {
+          placement: D
+        }
+      } : {};
+    }
+  };
+}, me = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var d, i;
+      const {
+        placement: n,
+        middlewareData: o,
+        rects: s,
+        initialPlacement: f,
+        platform: u,
+        elements: p
+      } = t, {
+        mainAxis: c = !0,
+        crossAxis: r = !0,
+        fallbackPlacements: m,
+        fallbackStrategy: l = "bestFit",
+        fallbackAxisSideDirection: a = "none",
+        flipAlignment: g = !0,
+        ...v
+      } = W(e, t);
+      if ((d = o.arrow) != null && d.alignmentOffset)
+        return {};
+      const w = B(n), x = F(f), h = B(f) === f, A = await (u.isRTL == null ? void 0 : u.isRTL(p.floating)), P = m || (h || !g ? [K(f)] : Q(f)), b = a !== "none";
+      !m && b && P.push(...Z(f, g, a, A));
+      const S = [f, ...P], E = await u.detectOverflow(t, v), D = [];
+      let y = ((i = o.flip) == null ? void 0 : i.overflows) || [];
+      if (c && D.push(E[w]), r) {
+        const O = q(n, s, A);
+        D.push(E[O[0]], E[O[1]]);
+      }
+      if (y = [...y, {
+        placement: n,
+        overflows: D
+      }], !D.every((O) => O <= 0)) {
+        var R, C;
+        const O = (((R = o.flip) == null ? void 0 : R.index) || 0) + 1, V = S[O];
+        if (V && (!(r === "alignment" ? x !== F(V) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        y.every((k) => F(k.placement) === x ? k.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: O,
+              overflows: y
+            },
+            reset: {
+              placement: V
+            }
+          };
+        let M = (C = y.filter((T) => T.overflows[0] <= 0).sort((T, k) => T.overflows[1] - k.overflows[1])[0]) == null ? void 0 : C.placement;
+        if (!M)
+          switch (l) {
+            case "bestFit": {
+              var L;
+              const T = (L = y.filter((k) => {
+                if (b) {
+                  const $ = F(k.placement);
+                  return $ === x || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  $ === "y";
+                }
+                return !0;
+              }).map((k) => [k.placement, k.overflows.filter(($) => $ > 0).reduce(($, J) => $ + J, 0)]).sort((k, $) => k[1] - $[1])[0]) == null ? void 0 : L[0];
+              T && (M = T);
+              break;
+            }
+            case "initialPlacement":
+              M = f;
+              break;
+          }
+        if (n !== M)
+          return {
+            reset: {
+              placement: M
+            }
+          };
+      }
+      return {};
+    }
+  };
+}, se = /* @__PURE__ */ new Set(["left", "top"]);
+async function le(e, t) {
+  const {
+    placement: d,
+    platform: i,
+    elements: n
+  } = e, o = await (i.isRTL == null ? void 0 : i.isRTL(n.floating)), s = B(d), f = _(d), u = F(d) === "y", p = se.has(s) ? -1 : 1, c = o && u ? -1 : 1, r = W(t, e);
+  let {
+    mainAxis: m,
+    crossAxis: l,
+    alignmentAxis: a
+  } = typeof r == "number" ? {
+    mainAxis: r,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: r.mainAxis || 0,
+    crossAxis: r.crossAxis || 0,
+    alignmentAxis: r.alignmentAxis
+  };
+  return f && typeof a == "number" && (l = f === "end" ? a * -1 : a), u ? {
+    x: l * c,
+    y: m * p
+  } : {
+    x: m * p,
+    y: l * c
+  };
+}
+const de = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var d, i;
+      const {
+        x: n,
+        y: o,
+        placement: s,
+        middlewareData: f
+      } = t, u = await le(t, e);
+      return s === ((d = f.offset) == null ? void 0 : d.placement) && (i = f.arrow) != null && i.alignmentOffset ? {} : {
+        x: n + u.x,
+        y: o + u.y,
+        data: {
+          ...u,
+          placement: s
+        }
+      };
+    }
+  };
+}, ue = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: d,
+        y: i,
+        placement: n,
+        platform: o
+      } = t, {
+        mainAxis: s = !0,
+        crossAxis: f = !1,
+        limiter: u = {
+          fn: (w) => {
+            let {
+              x,
+              y: h
+            } = w;
+            return {
+              x,
+              y: h
+            };
+          }
+        },
+        ...p
+      } = W(e, t), c = {
+        x: d,
+        y: i
+      }, r = await o.detectOverflow(t, p), m = F(B(n)), l = ee(m);
+      let a = c[l], g = c[m];
+      if (s) {
+        const w = l === "y" ? "top" : "left", x = l === "y" ? "bottom" : "right", h = a + r[w], A = a - r[x];
+        a = Y(h, a, A);
+      }
+      if (f) {
+        const w = m === "y" ? "top" : "left", x = m === "y" ? "bottom" : "right", h = g + r[w], A = g - r[x];
+        g = Y(h, g, A);
+      }
+      const v = u.fn({
+        ...t,
+        [l]: a,
+        [m]: g
+      });
+      return {
+        ...v,
+        data: {
+          x: v.x - d,
+          y: v.y - i,
+          enabled: {
+            [l]: s,
+            [m]: f
+          }
+        }
+      };
+    }
+  };
+}, ge = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "size",
+    options: e,
+    async fn(t) {
+      var d, i;
+      const {
+        placement: n,
+        rects: o,
+        platform: s,
+        elements: f
+      } = t, {
+        apply: u = () => {
+        },
+        ...p
+      } = W(e, t), c = await s.detectOverflow(t, p), r = B(n), m = _(n), l = F(n) === "y", {
+        width: a,
+        height: g
+      } = o.floating;
+      let v, w;
+      r === "top" || r === "bottom" ? (v = r, w = m === (await (s.isRTL == null ? void 0 : s.isRTL(f.floating)) ? "start" : "end") ? "left" : "right") : (w = r, v = m === "end" ? "top" : "bottom");
+      const x = g - c.top - c.bottom, h = a - c.left - c.right, A = H(g - c[v], x), P = H(a - c[w], h), b = !t.middlewareData.shift;
+      let S = A, E = P;
+      if ((d = t.middlewareData.shift) != null && d.enabled.x && (E = h), (i = t.middlewareData.shift) != null && i.enabled.y && (S = x), b && !m) {
+        const y = j(c.left, 0), R = j(c.right, 0), C = j(c.top, 0), L = j(c.bottom, 0);
+        l ? E = a - 2 * (y !== 0 || R !== 0 ? y + R : j(c.left, c.right)) : S = g - 2 * (C !== 0 || L !== 0 ? C + L : j(c.top, c.bottom));
+      }
+      await u({
+        ...t,
+        availableWidth: E,
+        availableHeight: S
+      });
+      const D = await s.getDimensions(f.floating);
+      return a !== D.width || g !== D.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+export {
+  re as arrow,
+  fe as autoPlacement,
+  ce as computePosition,
+  ne as detectOverflow,
+  me as flip,
+  de as offset,
+  z as rectToClientRect,
+  ue as shift,
+  ge as size
+};