@konstructio/ui 0.1.2-alpha.109 → 0.1.2-alpha.110

package/dist/FlagSelectorList-ClKGwDpS.js

@@ -0,0 +1,918 @@
+import { t as W } from "./utils-DnIJruo0.js";
+import { Typography as N } from "./components/Typography/Typography.js";
+import { usePhoneNumberContext as B } from "./components/PhoneNumberInput/contexts/phone-number.hook.js";
+import { TruncateText as H } from "./components/PhoneNumberInput/components/TruncateText/TruncateText.js";
+import * as z from "react";
+import { useEffect as J, useMemo as q, useRef as U } from "react";
+import { flushSync as G } from "react-dom";
+import { jsx as y, jsxs as Q } from "react/jsx-runtime";
+function X(r) {
+  return typeof r == "object" ? r.key : r;
+}
+function Y(r, e) {
+  const s = r.length;
+  return new Proxy(r, { get(t, n, i) {
+    if (typeof n == "string") {
+      const l = n.charCodeAt(0);
+      if (l >= 48 && l <= 57) {
+        const o = +n;
+        if (Number.isInteger(o) && o >= 0 && o < s) {
+          let a = t[o];
+          if (typeof a != "object") {
+            const f = e[o * 2];
+            a = t[o] = {
+              index: o,
+              key: a,
+              start: f,
+              size: e[o * 2 + 1],
+              end: f + e[o * 2 + 1],
+              lane: 0
+            };
+          }
+          return a;
+        }
+      }
+      if (n === "length") return s;
+    }
+    return Reflect.get(t, n, i);
+  } });
+}
+function w(r, e, s) {
+  let t = s.initialDeps ?? [], n, i = !0;
+  function l() {
+    var o;
+    const a = process.env.NODE_ENV !== "production" && !!s.key && !!((o = s.debug) != null && o.call(s));
+    let f = 0;
+    a && (f = Date.now());
+    const u = r();
+    if (!(u.length !== t.length || u.some((d, m) => t[m] !== d))) return n;
+    t = u;
+    let h = 0;
+    if (a && (h = Date.now()), n = e(...u), a) {
+      const d = Math.round((Date.now() - f) * 100) / 100, m = Math.round((Date.now() - h) * 100) / 100, g = m / 16, v = (p, c) => {
+        for (p = String(p); p.length < c; ) p = " " + p;
+        return p;
+      };
+      console.info(`%c⏱ ${v(m, 5)} /${v(d, 5)} ms`, `
+            font-size: .6rem;
+            font-weight: bold;
+            color: hsl(${Math.max(0, Math.min(120 - 120 * g, 120))}deg 100% 31%);`, s?.key);
+    }
+    return s?.onChange && !(i && s.skipInitialOnChange) && s.onChange(n), i = !1, n;
+  }
+  return l.updateDeps = (o) => {
+    t = o;
+  }, l;
+}
+function V(r, e) {
+  if (r === void 0) throw new Error(`Unexpected undefined${e ? `: ${e}` : ""}`);
+  return r;
+}
+var K = (r, e) => Math.abs(r - e) < 1.01, Z = (r, e, s) => {
+  let t;
+  return Object.assign(function(...n) {
+    r.clearTimeout(t), t = r.setTimeout(() => e.apply(this, n), s);
+  }, { cancel: () => {
+    r.clearTimeout(t);
+  } });
+}, R, F = () => {
+  if (R !== void 0) return R;
+  if (typeof navigator > "u") return R = !1;
+  if (/iP(hone|od|ad)/.test(navigator.userAgent)) return R = !0;
+  const r = navigator.maxTouchPoints;
+  return R = navigator.platform === "MacIntel" && r !== void 0 && r > 0;
+}, P = (r) => {
+  const { offsetWidth: e, offsetHeight: s } = r;
+  return {
+    width: e,
+    height: s
+  };
+}, tt = (r) => r, et = (r) => {
+  const e = Math.max(r.startIndex - r.overscan, 0), s = Math.min(r.endIndex + r.overscan, r.count - 1) - e + 1, t = new Array(s);
+  for (let n = 0; n < s; n++) t[n] = e + n;
+  return t;
+}, st = (r, e) => {
+  const s = r.scrollElement;
+  if (!s) return;
+  const t = r.targetWindow;
+  if (!t) return;
+  const n = (l) => {
+    const { width: o, height: a } = l;
+    e({
+      width: Math.round(o),
+      height: Math.round(a)
+    });
+  };
+  if (n(P(s)), !t.ResizeObserver) return () => {
+  };
+  const i = new t.ResizeObserver((l) => {
+    const o = () => {
+      const a = l[0];
+      if (a?.borderBoxSize) {
+        const f = a.borderBoxSize[0];
+        if (f) {
+          n({
+            width: f.inlineSize,
+            height: f.blockSize
+          });
+          return;
+        }
+      }
+      n(P(s));
+    };
+    r.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(o) : o();
+  });
+  return i.observe(s, { box: "border-box" }), () => {
+    i.unobserve(s);
+  };
+}, j = { passive: !0 }, nt = typeof window > "u" ? !0 : "onscrollend" in window, it = (r, e, s) => {
+  const t = r.scrollElement;
+  if (!t) return;
+  const n = r.targetWindow;
+  if (!n) return;
+  const i = r.options.useScrollendEvent && nt;
+  let l = 0;
+  const o = i ? null : Z(n, () => e(s(t), !1), r.options.isScrollingResetDelay), a = (h) => () => {
+    l = s(t), o?.(), e(l, h);
+  }, f = a(!0), u = a(!1);
+  return t.addEventListener("scroll", f, j), i && t.addEventListener("scrollend", u, j), () => {
+    t.removeEventListener("scroll", f), i && t.removeEventListener("scrollend", u), o?.cancel();
+  };
+}, lt = (r, e) => it(r, e, (s) => {
+  const { horizontal: t, isRtl: n } = r.options;
+  return t ? s.scrollLeft * (n && -1 || 1) : s.scrollTop;
+}), ot = (r, e, s) => {
+  if (s.options.useCachedMeasurements) {
+    const t = s.indexFromElement(r), n = s.options.getItemKey(t);
+    return s.itemSizeCache.get(n) ?? s.options.estimateSize(t);
+  }
+  if (e?.borderBoxSize) {
+    const t = e.borderBoxSize[0];
+    if (t) return Math.round(t[s.options.horizontal ? "inlineSize" : "blockSize"]);
+  }
+  if (!e) {
+    const t = s.indexFromElement(r), n = s.options.getItemKey(t), i = s.itemSizeCache.get(n);
+    if (i !== void 0) return i;
+  }
+  return r[s.options.horizontal ? "offsetWidth" : "offsetHeight"];
+}, rt = (r, { adjustments: e = 0, behavior: s }, t) => {
+  var n, i;
+  (i = (n = t.scrollElement) == null ? void 0 : n.scrollTo) == null || i.call(n, {
+    [t.options.horizontal ? "left" : "top"]: r + e,
+    behavior: s
+  });
+}, at = rt;
+function ht(r, e, s, t) {
+  if (e === 0) return !1;
+  const n = t(0), i = /* @__PURE__ */ new Set();
+  let l = 0;
+  for (; l < r; ) {
+    const a = s(l);
+    if (a === n) break;
+    i.add(a), l++;
+  }
+  const o = r - l;
+  if (o === 0 || o >= e) return !1;
+  for (let a = 0; a < o; a++) if (t(a) !== s(l + a)) return !1;
+  for (let a = o; a < e; a++) if (i.has(t(a))) return !1;
+  return !0;
+}
+var ct = class {
+  constructor(r) {
+    this.unsubs = [], this.scrollElement = null, this.targetWindow = null, this.isScrolling = !1, this.scrollState = null, this.measurementsCache = [], this._singleLaneMeasurements = null, this.itemSizeCache = /* @__PURE__ */ new Map(), this.itemSizeCacheVersion = 0, this.laneAssignments = /* @__PURE__ */ new Map(), this.pendingMin = null, this.prevLanes = void 0, this.lanesChangedFlag = !1, this.lanesSettling = !1, this.pendingScrollAnchor = null, this.scrollRect = null, this.scrollOffset = null, this.scrollDirection = null, this.scrollAdjustments = 0, this._iosDeferredAdjustment = 0, this._iosTouching = !1, this._iosJustTouchEnded = !1, this._iosTouchEndTimerId = null, this._intendedScrollOffset = null, this._clampedAdjustment = null, this.elementsCache = /* @__PURE__ */ new Map(), this.now = () => {
+      var e, s, t;
+      return ((t = (s = (e = this.targetWindow) == null ? void 0 : e.performance) == null ? void 0 : s.now) == null ? void 0 : t.call(s)) ?? Date.now();
+    }, this.observer = /* @__PURE__ */ (() => {
+      let e = null;
+      const s = () => e || (!this.targetWindow || !this.targetWindow.ResizeObserver ? null : e = new this.targetWindow.ResizeObserver((t) => {
+        t.forEach((n) => {
+          const i = () => {
+            const l = n.target, o = this.indexFromElement(l);
+            if (!l.isConnected) {
+              this.observer.unobserve(l);
+              for (const [a, f] of this.elementsCache) if (f === l) {
+                this.elementsCache.delete(a);
+                break;
+              }
+              return;
+            }
+            this.isIndexInRange(o) && this.shouldMeasureDuringScroll(o) && this.resizeItem(o, this.options.measureElement(l, n, this));
+          };
+          this.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(i) : i();
+        });
+      }));
+      return {
+        disconnect: () => {
+          var t;
+          (t = s()) == null || t.disconnect(), e = null;
+        },
+        observe: (t) => {
+          var n;
+          return (n = s()) == null ? void 0 : n.observe(t, { box: "border-box" });
+        },
+        unobserve: (t) => {
+          var n;
+          return (n = s()) == null ? void 0 : n.unobserve(t);
+        }
+      };
+    })(), this.range = null, this.setOptions = (e) => {
+      var s;
+      const t = {
+        debug: !1,
+        initialOffset: 0,
+        overscan: 1,
+        paddingStart: 0,
+        paddingEnd: 0,
+        scrollPaddingStart: 0,
+        scrollPaddingEnd: 0,
+        horizontal: !1,
+        getItemKey: tt,
+        rangeExtractor: et,
+        onChange: () => {
+        },
+        measureElement: ot,
+        initialRect: {
+          width: 0,
+          height: 0
+        },
+        scrollMargin: 0,
+        gap: 0,
+        indexAttribute: "data-index",
+        initialMeasurementsCache: [],
+        lanes: 1,
+        anchorTo: "start",
+        followOnAppend: !1,
+        scrollEndThreshold: 1,
+        isScrollingResetDelay: 150,
+        enabled: !0,
+        isRtl: !1,
+        useScrollendEvent: !1,
+        useAnimationFrameWithResizeObserver: !1,
+        laneAssignmentMode: "estimate",
+        useCachedMeasurements: !1
+      };
+      for (const u in e) {
+        const h = e[u];
+        h !== void 0 && (t[u] = h);
+      }
+      const n = this.options;
+      let i = null, l = null, o = !1;
+      if (n !== void 0 && n.enabled && t.enabled && t.anchorTo === "end" && this.scrollElement !== null) {
+        const u = n.count, h = t.count, d = this.getMeasurements(), m = ((s = this._singleLaneMeasurements) == null ? void 0 : s.items) ?? d, g = (c) => X(m[c]), v = u > 0 ? g(0) : null, p = u > 0 ? g(u - 1) : null;
+        if (h !== u || u > 0 && h > 0 && (t.getItemKey(0) !== v || t.getItemKey(h - 1) !== p)) {
+          o = !0;
+          const c = u > 0 ? this.getVirtualItemForOffset(this.getScrollOffset()) ?? d[0] : null;
+          c && (i = [c.key, this.getScrollOffset() - c.start]);
+          const S = t.followOnAppend === !0 ? "auto" : t.followOnAppend || null;
+          S && h > 0 && this.isAtEnd(n.scrollEndThreshold) && (u === 0 || t.getItemKey(h - 1) !== p) && (h > u || ht(u, h, g, t.getItemKey)) && (l = S);
+        }
+      }
+      this.options = t, o && (this.pendingMin = 0, this.itemSizeCacheVersion++);
+      let a = !1, f = 0;
+      if (i && this.scrollOffset !== null) {
+        const [u, h] = i, d = this.getMeasurements(), { count: m, getItemKey: g } = this.options;
+        let v = 0;
+        for (; v < m && g(v) !== u; ) v++;
+        if (v < m) {
+          const p = d[v];
+          if (p) {
+            const c = Math.max(0, p.start + h);
+            !l && c !== this.scrollOffset && (f = c - this.scrollOffset, this.scrollOffset = c, a = !0);
+          }
+        }
+      }
+      (a || l) && (this.pendingScrollAnchor = [
+        a ? i[0] : null,
+        a ? i[1] : 0,
+        l,
+        f
+      ]);
+    }, this.notify = (e) => {
+      var s, t;
+      (t = (s = this.options).onChange) == null || t.call(s, this, e);
+    }, this.maybeNotify = w(() => (this.calculateRange(), [
+      this.isScrolling,
+      this.range ? this.range.startIndex : null,
+      this.range ? this.range.endIndex : null
+    ]), (e) => {
+      this.notify(e);
+    }, {
+      key: process.env.NODE_ENV !== "production" && "maybeNotify",
+      debug: () => this.options.debug,
+      initialDeps: [
+        this.isScrolling,
+        this.range ? this.range.startIndex : null,
+        this.range ? this.range.endIndex : null
+      ]
+    }), this.cleanup = () => {
+      this.unsubs.filter(Boolean).forEach((e) => e()), this.unsubs = [], this.observer.disconnect(), this.rafId != null && this.targetWindow && (this.targetWindow.cancelAnimationFrame(this.rafId), this.rafId = null), this.scrollState = null, this.isScrolling = !1, this.scrollDirection = null, this._iosDeferredAdjustment = 0, this._iosTouching = !1, this._iosJustTouchEnded = !1, this._clampedAdjustment = null, this.scrollElement = null, this.targetWindow = null;
+    }, this._didMount = () => () => {
+      this.cleanup();
+    }, this._willUpdate = () => {
+      var e, s;
+      const t = this.options.enabled ? this.options.getScrollElement() : null;
+      if (this.scrollElement !== t) {
+        if (this.cleanup(), !t) {
+          this.maybeNotify();
+          return;
+        }
+        if (this.scrollElement = t, this.scrollElement && "ownerDocument" in this.scrollElement ? this.targetWindow = this.scrollElement.ownerDocument.defaultView : this.targetWindow = ((e = this.scrollElement) == null ? void 0 : e.window) ?? null, this.elementsCache.forEach((i) => {
+          this.observer.observe(i);
+        }), this.unsubs.push(this.options.observeElementRect(this, (i) => {
+          this.scrollRect = i, this.maybeNotify();
+        })), this.unsubs.push(this.options.observeElementOffset(this, (i, l) => {
+          if (l && this._intendedScrollOffset === null && i === this.scrollOffset) return;
+          this._intendedScrollOffset !== null && Math.abs(i - this._intendedScrollOffset) < 1.5 && (i = this._intendedScrollOffset), this._intendedScrollOffset = null, this._clampedAdjustment !== null && Math.abs(i - this._clampedAdjustment.maxAtWrite) >= 1.5 && (this._clampedAdjustment = null), this.scrollAdjustments = 0;
+          const o = this.getScrollOffset();
+          this.scrollDirection = l ? o === i ? this.scrollDirection : o < i ? "forward" : "backward" : null, this.scrollOffset = i, this.isScrolling = l, this._flushIosDeferredIfReady(), this.scrollState && this.scheduleScrollReconcile(), this.maybeNotify();
+        })), "addEventListener" in this.scrollElement) {
+          const i = this.scrollElement, l = () => {
+            this._iosTouching = !0, this._iosJustTouchEnded = !1, this._iosTouchEndTimerId !== null && this.targetWindow != null && (this.targetWindow.clearTimeout(this._iosTouchEndTimerId), this._iosTouchEndTimerId = null);
+          }, o = () => {
+            this._iosTouching = !1, !(!F() || this.targetWindow == null) && (this._iosJustTouchEnded = !0, this._iosTouchEndTimerId = this.targetWindow.setTimeout(() => {
+              this._iosJustTouchEnded = !1, this._iosTouchEndTimerId = null, this._flushIosDeferredIfReady();
+            }, 150));
+          };
+          i.addEventListener("touchstart", l, j), i.addEventListener("touchend", o, j), this.unsubs.push(() => {
+            i.removeEventListener("touchstart", l), i.removeEventListener("touchend", o), this._iosTouchEndTimerId !== null && this.targetWindow != null && (this.targetWindow.clearTimeout(this._iosTouchEndTimerId), this._iosTouchEndTimerId = null);
+          });
+        }
+        this._scrollToOffset(this.getScrollOffset(), {
+          adjustments: void 0,
+          behavior: void 0
+        });
+      }
+      const n = this.pendingScrollAnchor;
+      if (this.pendingScrollAnchor = null, n && this.scrollElement && this.options.enabled) {
+        const [i, l, o, a] = n;
+        i !== null && !o && (F() && (this.isScrolling || this._iosTouching || this._iosJustTouchEnded) ? a !== 0 && (this._iosDeferredAdjustment += a) : ((s = this.scrollState) == null ? void 0 : s.behavior) === "smooth" && !K(this.getScrollOffset() - a, this.scrollState.lastTargetOffset) || this._scrollToOffset(this.getScrollOffset(), {
+          adjustments: void 0,
+          behavior: void 0
+        })), o && this.scrollToEnd({ behavior: o });
+      }
+      this._retryClampedAdjustment();
+    }, this._retryClampedAdjustment = () => {
+      if (this._clampedAdjustment === null || !this.scrollElement || !this.options.enabled) return;
+      const { target: e, maxAtWrite: s } = this._clampedAdjustment, t = this.getMaxScrollOffset();
+      t > s + 0.5 && (this._clampedAdjustment = e > t + 0.5 ? {
+        target: e,
+        maxAtWrite: t
+      } : null, this._scrollToOffset(e, {
+        adjustments: void 0,
+        behavior: void 0
+      }));
+    }, this._flushIosDeferredIfReady = () => {
+      if (this._iosDeferredAdjustment === 0 || this.isScrolling || this._iosTouching || this._iosJustTouchEnded) return;
+      const e = this.getScrollOffset(), s = this.getMaxScrollOffset();
+      if (e < 0 || e > s) return;
+      if (this._iosDeferredAdjustment < 0 && e >= s - 1) {
+        this._iosDeferredAdjustment = 0;
+        return;
+      }
+      const t = this._iosDeferredAdjustment;
+      this._iosDeferredAdjustment = 0, this._scrollToOffset(e, {
+        adjustments: this.scrollAdjustments += t,
+        behavior: void 0
+      });
+    }, this.rafId = null, this.getSize = () => this.options.enabled ? (this.scrollRect = this.scrollRect ?? this.options.initialRect, this.scrollRect[this.options.horizontal ? "width" : "height"]) : (this.scrollRect = null, 0), this.getScrollOffset = () => this.options.enabled ? (this.scrollOffset = this.scrollOffset ?? (typeof this.options.initialOffset == "function" ? this.options.initialOffset() : this.options.initialOffset), this.scrollOffset) : (this.scrollOffset = null, 0), this.getMeasurementOptions = w(() => [
+      this.options.count,
+      this.options.paddingStart,
+      this.options.scrollMargin,
+      this.options.getItemKey,
+      this.options.enabled,
+      this.options.lanes,
+      this.options.laneAssignmentMode,
+      this.options.gap
+    ], (e, s, t, n, i, l, o, a) => (this.prevLanes !== void 0 && this.prevLanes !== l && (this.lanesChangedFlag = !0), this.prevLanes = l, this.pendingMin = null, {
+      count: e,
+      paddingStart: s,
+      scrollMargin: t,
+      getItemKey: n,
+      enabled: i,
+      lanes: l,
+      laneAssignmentMode: o,
+      gap: a
+    }), { key: !1 }), this.isIndexInRange = (e) => e >= 0 && e < this.options.count, this.getMeasurements = w(() => [this.getMeasurementOptions(), this.itemSizeCacheVersion], ({ count: e, paddingStart: s, scrollMargin: t, getItemKey: n, enabled: i, lanes: l, laneAssignmentMode: o, gap: a }, f) => {
+      var u;
+      const h = this.itemSizeCache;
+      if (!i)
+        return this.measurementsCache = [], this._singleLaneMeasurements = null, this.itemSizeCache.clear(), this.laneAssignments.clear(), [];
+      if (this.laneAssignments.size > e)
+        for (const c of this.laneAssignments.keys()) c >= e && this.laneAssignments.delete(c);
+      this.lanesChangedFlag && (this.lanesChangedFlag = !1, this.lanesSettling = !0, this.measurementsCache = [], this._singleLaneMeasurements = null, this.itemSizeCache.clear(), this.laneAssignments.clear(), this.pendingMin = null), this.measurementsCache.length === 0 && !this.lanesSettling && (this.measurementsCache = this.options.initialMeasurementsCache, this.measurementsCache.forEach((c) => {
+        this.itemSizeCache.set(c.key, c.size);
+      }));
+      const d = this.lanesSettling ? 0 : this.pendingMin ?? 0;
+      if (this.pendingMin = null, this.lanesSettling && this.measurementsCache.length === e && (this.lanesSettling = !1), l === 1) {
+        const c = e * 2;
+        let S = (u = this._singleLaneMeasurements) == null ? void 0 : u.flat;
+        if (!S || S.length < c) {
+          const E = new Float64Array(c);
+          S && d > 0 && E.set(S.subarray(0, d * 2)), S = E;
+        }
+        const x = d === 0 ? new Array(e) : this._singleLaneMeasurements.items.slice();
+        let b;
+        if (d === 0) b = s + t;
+        else {
+          const E = d - 1;
+          b = S[E * 2] + S[E * 2 + 1] + a;
+        }
+        for (let E = d; E < e; E++) {
+          const A = n(E);
+          x[E] = A;
+          const T = h.get(A), M = typeof T == "number" ? T : this.options.estimateSize(E);
+          S[E * 2] = b, S[E * 2 + 1] = M, b += M + a;
+        }
+        this._singleLaneMeasurements = {
+          flat: S,
+          items: x
+        };
+        const O = Y(x, S);
+        return this.measurementsCache = O, O;
+      }
+      const m = this.measurementsCache.slice(0, d), g = new Array(l).fill(void 0), v = new Float64Array(l);
+      let p = 0;
+      for (let c = 0; c < d; c++) {
+        const S = m[c];
+        S && (g[S.lane] === void 0 && p++, g[S.lane] = c, v[S.lane] = S.end);
+      }
+      for (let c = d; c < e; c++) {
+        const S = n(c), x = this.laneAssignments.get(c);
+        let b, O;
+        const E = o === "estimate" || h.has(S);
+        if (x !== void 0 && this.options.lanes > 1) {
+          b = x;
+          const C = g[b], _ = C !== void 0 ? m[C] : void 0;
+          O = _ ? _.end + a : s + t;
+        } else if (p === l) {
+          let C = 0, _ = v[0], k = g[0];
+          for (let I = 1; I < l; I++) {
+            const D = v[I];
+            (D < _ || D === _ && g[I] < k) && (C = I, _ = D, k = g[I]);
+          }
+          b = C, O = _ + a, E && this.laneAssignments.set(c, b);
+        } else
+          b = c % this.options.lanes, O = s + t, E && this.laneAssignments.set(c, b);
+        const A = h.get(S), T = typeof A == "number" ? A : this.options.estimateSize(c), M = O + T;
+        m[c] = {
+          index: c,
+          start: O,
+          size: T,
+          end: M,
+          key: S,
+          lane: b
+        }, g[b] === void 0 && p++, g[b] = c, v[b] = M;
+      }
+      return this.measurementsCache = m, m;
+    }, {
+      key: process.env.NODE_ENV !== "production" && "getMeasurements",
+      debug: () => this.options.debug
+    }), this.calculateRange = w(() => [
+      this.getMeasurements(),
+      this.getSize(),
+      this.getScrollOffset(),
+      this.options.lanes
+    ], (e, s, t, n) => e.length === 0 || s === 0 ? (this.range = null, null) : (this.range = dt(e, s, t, n, n === 1 && this._singleLaneMeasurements !== null ? this._singleLaneMeasurements.flat : null), this.range), {
+      key: process.env.NODE_ENV !== "production" && "calculateRange",
+      debug: () => this.options.debug
+    }), this.getVirtualIndexes = w(() => {
+      let e = null, s = null;
+      const t = this.calculateRange();
+      return t && (e = t.startIndex, s = t.endIndex), this.maybeNotify.updateDeps([
+        this.isScrolling,
+        e,
+        s
+      ]), [
+        this.options.rangeExtractor,
+        this.options.overscan,
+        this.options.count,
+        e,
+        s
+      ];
+    }, (e, s, t, n, i) => n === null || i === null ? [] : e({
+      startIndex: n,
+      endIndex: i,
+      overscan: s,
+      count: t
+    }), {
+      key: process.env.NODE_ENV !== "production" && "getVirtualIndexes",
+      debug: () => this.options.debug
+    }), this.indexFromElement = (e) => {
+      const s = this.options.indexAttribute, t = e.getAttribute(s);
+      return t ? parseInt(t, 10) : (console.warn(`Missing attribute name '${s}={index}' on measured element.`), -1);
+    }, this.shouldMeasureDuringScroll = (e) => {
+      var s;
+      if (!this.scrollState || this.scrollState.behavior !== "smooth") return !0;
+      const t = this.scrollState.index ?? ((s = this.getVirtualItemForOffset(this.scrollState.lastTargetOffset)) == null ? void 0 : s.index);
+      if (t !== void 0 && this.range) {
+        const n = Math.max(this.options.overscan, Math.ceil((this.range.endIndex - this.range.startIndex) / 2)), i = Math.max(0, t - n), l = Math.min(this.options.count - 1, t + n);
+        return e >= i && e <= l;
+      }
+      return !0;
+    }, this.measureElement = (e) => {
+      if (!e) {
+        this.elementsCache.forEach((i, l) => {
+          i.isConnected || (this.observer.unobserve(i), this.elementsCache.delete(l));
+        });
+        return;
+      }
+      const s = this.indexFromElement(e);
+      if (!this.isIndexInRange(s)) return;
+      const t = this.options.getItemKey(s), n = this.elementsCache.get(t);
+      n !== e && (n && this.observer.unobserve(n), this.observer.observe(e), this.elementsCache.set(t, e)), (!this.isScrolling || this.scrollState) && this.shouldMeasureDuringScroll(s) && this.resizeItem(s, this.options.measureElement(e, void 0, this));
+    }, this.resizeItem = (e, s) => {
+      var t, n, i;
+      if (!this.isIndexInRange(e)) return;
+      let l, o, a;
+      const f = (t = this._singleLaneMeasurements) == null ? void 0 : t.flat;
+      if (this.options.lanes === 1 && f != null)
+        a = this.options.getItemKey(e), o = f[e * 2], l = f[e * 2 + 1];
+      else {
+        const d = this.measurementsCache[e];
+        if (!d) return;
+        a = d.key, o = d.start, l = d.size;
+      }
+      const u = this.itemSizeCache.get(a) ?? l, h = s - u;
+      if (h !== 0) {
+        const d = this.options.anchorTo === "end" && ((n = this.scrollState) == null ? void 0 : n.behavior) !== "smooth" && this.getVirtualDistanceFromEnd() <= this.options.scrollEndThreshold, m = d ? this.getTotalSize() : 0, g = this.getScrollOffset() + this.scrollAdjustments, v = this.itemSizeCache.has(a) ? o + u <= g && this.scrollDirection !== "backward" : o < g, p = ((i = this.scrollState) == null ? void 0 : i.behavior) !== "smooth" && (this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(this.measurementsCache[e] ?? {
+          index: e,
+          key: a,
+          start: o,
+          size: l,
+          end: o + l,
+          lane: 0
+        }, h, this) : v);
+        (this.pendingMin === null || e < this.pendingMin) && (this.pendingMin = e), this.itemSizeCache.set(a, s), this.itemSizeCacheVersion++;
+        let c = !1;
+        d ? c = this.applyScrollAdjustment(this.getTotalSize() - m) : p && (c = this.applyScrollAdjustment(h)), this.notify(c), this._retryClampedAdjustment();
+      }
+    }, this.getVirtualItems = w(() => [this.getVirtualIndexes(), this.getMeasurements()], (e, s) => {
+      const t = [];
+      for (let n = 0, i = e.length; n < i; n++) {
+        const l = s[e[n]];
+        t.push(l);
+      }
+      return t;
+    }, {
+      key: process.env.NODE_ENV !== "production" && "getVirtualItems",
+      debug: () => this.options.debug
+    }), this.getVirtualItemForOffset = (e) => {
+      var s;
+      const t = this.getMeasurements();
+      if (t.length === 0) return;
+      const n = (s = this._singleLaneMeasurements) == null ? void 0 : s.flat, i = this.options.lanes === 1 && n != null, l = $(0, t.length - 1, i ? (o) => n[o * 2] : (o) => V(t[o]).start, e);
+      return V(t[l]);
+    }, this.getMaxScrollOffset = () => {
+      if (!this.scrollElement) return 0;
+      if ("scrollHeight" in this.scrollElement) return this.options.horizontal ? this.scrollElement.scrollWidth - this.scrollElement.clientWidth : this.scrollElement.scrollHeight - this.scrollElement.clientHeight;
+      {
+        const e = this.scrollElement.document.documentElement;
+        return this.options.horizontal ? e.scrollWidth - this.scrollElement.innerWidth : e.scrollHeight - this.scrollElement.innerHeight;
+      }
+    }, this.getVirtualDistanceFromEnd = () => Math.max(this.getTotalSize() - this.getSize() - this.getScrollOffset(), 0), this.getDistanceFromEnd = () => Math.max(this.getMaxScrollOffset() - this.getScrollOffset(), 0), this.isAtEnd = (e = this.options.scrollEndThreshold) => this.getDistanceFromEnd() <= e, this.getOffsetForAlignment = (e, s, t = 0) => {
+      if (!this.scrollElement) return 0;
+      const n = this.getSize(), i = this.getScrollOffset();
+      s === "auto" && (s = e >= i + n ? "end" : "start"), s === "center" ? e += (t - n) / 2 : s === "end" && (e -= n);
+      const l = this.getMaxScrollOffset();
+      return Math.max(Math.min(l, e), 0);
+    }, this.getOffsetForIndex = (e, s = "auto") => {
+      e = Math.max(0, Math.min(e, this.options.count - 1));
+      const t = this.getSize(), n = this.getScrollOffset(), i = this.measurementsCache[e];
+      if (!i) return;
+      if (s === "auto")
+        if (i.end >= n + t - this.options.scrollPaddingEnd) s = "end";
+        else if (i.start <= n + this.options.scrollPaddingStart) s = "start";
+        else return [n, s];
+      if (s === "end" && e === this.options.count - 1) return [this.getMaxScrollOffset(), s];
+      const l = s === "end" ? i.end + this.options.scrollPaddingEnd : i.start - this.options.scrollPaddingStart;
+      return [this.getOffsetForAlignment(l, s, i.size), s];
+    }, this.scrollToOffset = (e, { align: s = "start", behavior: t = "auto" } = {}) => {
+      this._iosDeferredAdjustment = 0;
+      const n = this.getOffsetForAlignment(e, s), i = this.now();
+      this.scrollState = {
+        index: null,
+        align: s,
+        behavior: t,
+        startedAt: i,
+        lastTargetOffset: n,
+        stableFrames: 0
+      }, this._scrollToOffset(n, {
+        adjustments: void 0,
+        behavior: t
+      }), this.scheduleScrollReconcile();
+    }, this.scrollToIndex = (e, { align: s = "auto", behavior: t = "auto" } = {}) => {
+      this._iosDeferredAdjustment = 0, e = Math.max(0, Math.min(e, this.options.count - 1));
+      const n = this.getOffsetForIndex(e, s);
+      if (!n) return;
+      const [i, l] = n, o = this.now();
+      this.scrollState = {
+        index: e,
+        align: l,
+        behavior: t,
+        startedAt: o,
+        lastTargetOffset: i,
+        stableFrames: 0
+      }, this._scrollToOffset(i, {
+        adjustments: void 0,
+        behavior: t
+      }), this.scheduleScrollReconcile();
+    }, this.scrollBy = (e, { behavior: s = "auto" } = {}) => {
+      const t = this.getScrollOffset() + e, n = this.now();
+      this.scrollState = {
+        index: null,
+        align: "start",
+        behavior: s,
+        startedAt: n,
+        lastTargetOffset: t,
+        stableFrames: 0
+      }, this._scrollToOffset(t, {
+        adjustments: void 0,
+        behavior: s
+      }), this.scheduleScrollReconcile();
+    }, this.scrollToEnd = ({ behavior: e = "auto" } = {}) => {
+      if (this.options.count > 0) {
+        this.scrollToIndex(this.options.count - 1, {
+          align: "end",
+          behavior: e
+        });
+        return;
+      }
+      this.scrollToOffset(Math.max(this.getTotalSize() - this.getSize(), 0), { behavior: e });
+    }, this.getTotalSize = () => {
+      var e, s;
+      const t = this.getMeasurements();
+      let n;
+      if (t.length === 0) n = this.options.paddingStart;
+      else if (this.options.lanes === 1) {
+        const i = t.length - 1, l = (e = this._singleLaneMeasurements) == null ? void 0 : e.flat;
+        l != null ? n = l[i * 2] + l[i * 2 + 1] : n = ((s = t[i]) == null ? void 0 : s.end) ?? 0;
+      } else {
+        const i = Array(this.options.lanes).fill(null);
+        let l = t.length - 1;
+        for (; l >= 0 && i.some((o) => o === null); ) {
+          const o = t[l];
+          i[o.lane] === null && (i[o.lane] = o.end), l--;
+        }
+        n = Math.max(...i.filter((o) => o !== null));
+      }
+      return Math.max(n - this.options.scrollMargin + this.options.paddingEnd, 0);
+    }, this.takeSnapshot = () => {
+      const e = [];
+      if (this.itemSizeCache.size === 0) return e;
+      const s = this.getMeasurements();
+      for (const t of s) t && this.itemSizeCache.has(t.key) && e.push({
+        index: t.index,
+        key: t.key,
+        start: t.start,
+        size: t.size,
+        end: t.end,
+        lane: t.lane
+      });
+      return e;
+    }, this._scrollToOffset = (e, { adjustments: s, behavior: t }) => {
+      this._intendedScrollOffset = e + (s ?? 0), this.options.scrollToFn(e, {
+        behavior: t,
+        adjustments: s
+      }, this);
+    }, this.measure = () => {
+      this.pendingMin = null, this.itemSizeCache.clear(), this.laneAssignments.clear(), this.itemSizeCacheVersion++, this.notify(!1);
+    }, this.setOptions(r);
+  }
+  applyScrollAdjustment(r, e) {
+    if (r === 0) return !1;
+    if (process.env.NODE_ENV !== "production" && this.options.debug && console.info("correction", r), F() && (this.isScrolling || this._iosTouching || this._iosJustTouchEnded))
+      return this._iosDeferredAdjustment += r, !1;
+    {
+      const s = this.getScrollOffset() + this.scrollAdjustments + r, t = this.scrollElement, n = t !== null && ("scrollHeight" in t || "document" in t) ? this.getMaxScrollOffset() : null;
+      return this._clampedAdjustment = n !== null && s > n + 0.5 ? {
+        target: s,
+        maxAtWrite: n
+      } : null, this._scrollToOffset(this.getScrollOffset(), {
+        adjustments: this.scrollAdjustments += r,
+        behavior: e
+      }), this.scrollOffset !== null && (this.scrollOffset += this.scrollAdjustments, this.scrollOffset < 0 && (this.scrollOffset = 0), this.scrollAdjustments = 0), !0;
+    }
+  }
+  scheduleScrollReconcile() {
+    if (!this.targetWindow) {
+      this.scrollState = null;
+      return;
+    }
+    this.rafId == null && (this.rafId = this.targetWindow.requestAnimationFrame(() => {
+      this.rafId = null, this.reconcileScroll();
+    }));
+  }
+  reconcileScroll() {
+    if (!this.scrollState || !this.scrollElement) return;
+    if (this.now() - this.scrollState.startedAt > 5e3) {
+      this.scrollState = null;
+      return;
+    }
+    const r = this.scrollState.index != null ? this.getOffsetForIndex(this.scrollState.index, this.scrollState.align) : void 0, e = r ? r[0] : this.scrollState.lastTargetOffset, s = 1, t = e !== this.scrollState.lastTargetOffset;
+    if (!t && K(e, this.getScrollOffset())) {
+      if (this.scrollState.stableFrames++, this.scrollState.stableFrames >= s) {
+        this.getScrollOffset() !== e && this._scrollToOffset(e, {
+          adjustments: void 0,
+          behavior: "auto"
+        }), this.scrollState = null;
+        return;
+      }
+    } else if (this.scrollState.stableFrames = 0, t) {
+      const n = this.getSize() || 600, i = Math.abs(e - this.getScrollOffset()), l = this.scrollState.behavior === "smooth" && i > n;
+      this.scrollState.lastTargetOffset = e, l || (this.scrollState.behavior = "auto"), this._scrollToOffset(e, {
+        adjustments: void 0,
+        behavior: l ? "smooth" : "auto"
+      });
+    }
+    this.scheduleScrollReconcile();
+  }
+}, $ = (r, e, s, t) => {
+  for (; r <= e; ) {
+    const n = (r + e) / 2 | 0, i = s(n);
+    if (i < t) r = n + 1;
+    else if (i > t) e = n - 1;
+    else return n;
+  }
+  return r > 0 ? r - 1 : 0;
+};
+function ut(r, e, s) {
+  let t = 0;
+  for (; t <= e; ) {
+    const n = (t + e) / 2 | 0, i = r[n * 2];
+    if (i < s) t = n + 1;
+    else if (i > s) e = n - 1;
+    else return n;
+  }
+  return t > 0 ? t - 1 : 0;
+}
+function dt(r, e, s, t, n) {
+  const i = r.length - 1;
+  if (r.length <= t) return {
+    startIndex: 0,
+    endIndex: i
+  };
+  if (t === 1 && n !== null) {
+    const f = ut(n, i, s);
+    let u = f;
+    const h = s + e;
+    for (; u < i && n[u * 2] + n[u * 2 + 1] < h; ) u++;
+    return {
+      startIndex: f,
+      endIndex: u
+    };
+  }
+  let o = $(0, i, (f) => r[f].start, s), a = o;
+  if (t === 1) for (; a < i && r[a].end < s + e; ) a++;
+  else if (t > 1) {
+    const f = Array(t).fill(0);
+    for (; a < i && f.some((h) => h < s + e); ) {
+      const h = r[a];
+      f[h.lane] = h.end, a++;
+    }
+    const u = Array(t).fill(s + e);
+    for (; o >= 0 && u.some((h) => h >= s); ) {
+      const h = r[o];
+      u[h.lane] = h.start, o--;
+    }
+    o = Math.max(0, o - o % t), a = Math.min(i, a + (t - 1 - a % t));
+  }
+  return {
+    startIndex: o,
+    endIndex: a
+  };
+}
+var L = typeof document < "u" ? z.useLayoutEffect : z.useEffect;
+function ft({ useFlushSync: r = !0, directDomUpdates: e = !1, directDomUpdatesMode: s = "transform", ...t }) {
+  const n = z.useReducer((h) => h + 1, 0)[1], i = z.useRef({
+    enabled: e,
+    mode: s,
+    container: null,
+    lastSize: null,
+    lastPositions: /* @__PURE__ */ new WeakMap(),
+    prevRange: null
+  });
+  i.current.enabled = e, i.current.mode = s;
+  const l = z.useRef(!1), o = (h) => {
+    const d = i.current;
+    if (!d.enabled || !d.container) return;
+    const m = h.getTotalSize();
+    if (m !== d.lastSize) {
+      d.lastSize = m;
+      const g = h.options.horizontal ? "width" : "height";
+      d.container.style[g] = `${m}px`;
+    }
+  }, a = (h) => {
+    const d = i.current;
+    if (!d.enabled || !d.container) return;
+    o(h);
+    const m = !!h.options.horizontal, g = d.mode === "transform", v = m ? "left" : "top", p = h.options.scrollMargin, c = h.getVirtualItems();
+    for (const S of c) {
+      const x = S.start - p, b = h.elementsCache.get(S.key);
+      b && d.lastPositions.get(b) !== x && (d.lastPositions.set(b, x), g ? b.style.transform = m ? `translate3d(${x}px, 0, 0)` : `translate3d(0, ${x}px, 0)` : b.style[v] = `${x}px`);
+    }
+  }, f = {
+    ...t,
+    onChange: (h, d) => {
+      var m;
+      const g = i.current;
+      let v = !0;
+      if (g.enabled) {
+        a(h);
+        const p = h.range, c = g.prevRange;
+        v = !c || c.isScrolling !== h.isScrolling || c.startIndex !== p?.startIndex || c.endIndex !== p?.endIndex, v && (g.prevRange = p ? {
+          startIndex: p.startIndex,
+          endIndex: p.endIndex,
+          isScrolling: h.isScrolling
+        } : null);
+      }
+      v && (r && d && !l.current ? G(n) : n()), (m = t.onChange) == null || m.call(t, h, d);
+    }
+  }, [u] = z.useState(() => {
+    const h = new ct(f), d = h.measureElement;
+    return h.measureElement = (m) => {
+      l.current = !0;
+      try {
+        d(m);
+      } finally {
+        l.current = !1;
+      }
+    }, Object.assign(h, { containerRef: (m) => {
+      const g = i.current;
+      if (g.container = m, g.lastSize = null, m && g.enabled) {
+        const v = h.getTotalSize();
+        g.lastSize = v;
+        const p = h.options.horizontal ? "width" : "height";
+        m.style[p] = `${v}px`;
+      }
+    } });
+  });
+  return u.setOptions(f), L(() => u._didMount(), []), L(() => (o(u), u._willUpdate())), L(() => {
+    a(u);
+  }), u;
+}
+function mt(r) {
+  return ft({
+    observeElementRect: st,
+    observeElementOffset: lt,
+    scrollToFn: at,
+    ...r
+  });
+}
+var yt = ({ showFlagOnSearch: r, showNameOnSearch: e }) => {
+  const s = U(null), { termOfSearch: t, countries: n, handleSelectCountry: i } = B(), l = q(() => n.filter((a) => a.name.toLocaleLowerCase().includes(t.toLowerCase())), [t]), o = mt({
+    count: l.length,
+    overscan: 5,
+    getScrollElement: () => s.current,
+    estimateSize: () => 40
+  });
+  return J(() => {
+    l.length > 0 && o.scrollToIndex(0);
+  }, [t, o]), l.length === 0 ? /* @__PURE__ */ y("div", {
+    className: "overflow-y-auto max-h-60 snap-y snap-mandatory",
+    children: /* @__PURE__ */ y("ul", {
+      className: "relative",
+      children: /* @__PURE__ */ y("li", {
+        className: "w-full flex items-center h-10 select-none px-6",
+        children: /* @__PURE__ */ y(N, {
+          variant: "body2",
+          component: "span",
+          className: "flex gap-2 items-center text-left",
+          children: "No options"
+        })
+      })
+    })
+  }) : /* @__PURE__ */ y("div", {
+    ref: s,
+    className: "overflow-y-auto max-h-60 snap-y snap-mandatory scrollbar",
+    children: /* @__PURE__ */ y("ul", {
+      className: "relative",
+      style: { height: o.getTotalSize() },
+      children: o.getVirtualItems().map((a) => {
+        const f = l[a.index], { flag: u, name: h, prefix: d } = f;
+        return /* @__PURE__ */ y("li", {
+          className: W("absolute", "w-full", "snap-start", "snap-always", "scroll-m-0", "flex", "items-center", "h-10"),
+          style: {
+            top: a.start,
+            height: a.size
+          },
+          children: /* @__PURE__ */ y("button", {
+            className: W("w-full", "h-full", "cursor-pointer", "px-6", "hover:bg-gray-50", "transition-colors", "duration-150", "focus-visible:outline-0", "hover:outline-gray-100", "focus:bg-gray-50", "dark:hover:bg-metal-700"),
+            onClick: () => i(f),
+            children: /* @__PURE__ */ Q(N, {
+              variant: "body2",
+              component: "span",
+              className: "flex gap-2 items-center text-left",
+              children: [r && /* @__PURE__ */ y(u, {}), e && /* @__PURE__ */ y(H, {
+                text: h,
+                prefix: d
+              })]
+            })
+          })
+        }, a.key);
+      })
+    })
+  });
+};
+export {
+  yt as t
+};