@konstructio/ui 0.1.2-alpha.1 → 0.1.2-alpha.101

package/dist/FlagSelectorList-BARhzfj2.js

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