@konstructio/ui 0.1.2-alpha.12 → 0.1.2-alpha.121

package/dist/FlagSelectorList-iZ3gUVpf.js

@@ -0,0 +1,954 @@
+import { t as V } from "./utils-DnIJruo0.js";
+import { Typography as P } from "./components/Typography/Typography.js";
+import { usePhoneNumberContext as H } from "./components/PhoneNumberInput/contexts/phone-number.hook.js";
+import { TruncateText as q } from "./components/PhoneNumberInput/components/TruncateText/TruncateText.js";
+import * as A from "react";
+import { useEffect as U, useMemo as G, useRef as J } from "react";
+import { flushSync as Q } from "react-dom";
+import { jsx as E, jsxs as X } from "react/jsx-runtime";
+function Y(l) {
+  return typeof l == "object" ? l.key : l;
+}
+function Z(l, t) {
+  const s = l.length;
+  return new Proxy(l, { get(e, n, i) {
+    if (typeof n == "string") {
+      const o = n.charCodeAt(0);
+      if (o >= 48 && o <= 57) {
+        const r = +n;
+        if (Number.isInteger(r) && r >= 0 && r < s) {
+          let a = e[r];
+          if (typeof a != "object") {
+            const c = t[r * 2];
+            a = e[r] = {
+              index: r,
+              key: a,
+              start: c,
+              size: t[r * 2 + 1],
+              end: c + t[r * 2 + 1],
+              lane: 0
+            };
+          }
+          return a;
+        }
+      }
+      if (n === "length") return s;
+    }
+    return Reflect.get(e, n, i);
+  } });
+}
+function M(l, t, s) {
+  let e = s.initialDeps ?? [], n, i = !0;
+  function o() {
+    var r;
+    const a = process.env.NODE_ENV !== "production" && !!s.key && !!((r = s.debug) != null && r.call(s));
+    let c = 0;
+    a && (c = Date.now());
+    const f = l();
+    if (!(f.length !== e.length || f.some((h, g) => e[g] !== h))) return n;
+    e = f;
+    let m = 0;
+    if (a && (m = Date.now()), n = t(...f), a) {
+      const h = Math.round((Date.now() - c) * 100) / 100, g = Math.round((Date.now() - m) * 100) / 100, d = g / 16, p = (S, u) => {
+        for (S = String(S); S.length < u; ) S = " " + S;
+        return S;
+      };
+      console.info(`%c⏱ ${p(g, 5)} /${p(h, 5)} ms`, `
+            font-size: .6rem;
+            font-weight: bold;
+            color: hsl(${Math.max(0, Math.min(120 - 120 * d, 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 B(l, t) {
+  if (l === void 0) throw new Error(`Unexpected undefined${t ? `: ${t}` : ""}`);
+  return l;
+}
+var z = (l, t) => Math.abs(l - t) < 1.01, tt = (l, t, s) => {
+  let e;
+  return Object.assign(function(...n) {
+    l.clearTimeout(e), e = l.setTimeout(() => t.apply(this, n), s);
+  }, { cancel: () => {
+    l.clearTimeout(e);
+  } });
+}, R, D = () => {
+  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 l = navigator.maxTouchPoints;
+  return R = navigator.platform === "MacIntel" && l !== void 0 && l > 0;
+}, K = (l) => {
+  const { offsetWidth: t, offsetHeight: s } = l;
+  return {
+    width: t,
+    height: s
+  };
+}, et = (l) => l, st = (l) => {
+  const t = l.overscan * Math.max(l.lanes ?? 1, 1), s = Math.max(l.startIndex - t, 0), e = Math.min(l.endIndex + t, l.count - 1) - s + 1, n = new Array(e);
+  for (let i = 0; i < e; i++) n[i] = s + i;
+  return n;
+}, nt = (l, t) => {
+  const s = l.scrollElement;
+  if (!s) return;
+  const e = l.targetWindow;
+  if (!e) return;
+  const n = (o) => {
+    const { width: r, height: a } = o;
+    t({
+      width: Math.round(r),
+      height: Math.round(a)
+    });
+  };
+  if (n(K(s)), !e.ResizeObserver) return () => {
+  };
+  const i = new e.ResizeObserver((o) => {
+    const r = () => {
+      const a = o[0];
+      if (a?.borderBoxSize) {
+        const c = a.borderBoxSize[0];
+        if (c) {
+          n({
+            width: c.inlineSize,
+            height: c.blockSize
+          });
+          return;
+        }
+      }
+      n(K(s));
+    };
+    l.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(r) : r();
+  });
+  return i.observe(s, { box: "border-box" }), () => {
+    i.unobserve(s);
+  };
+}, F = { passive: !0 }, it = typeof window > "u" ? !0 : "onscrollend" in window, lt = (l, t, s) => {
+  const e = l.scrollElement;
+  if (!e) return;
+  const n = l.targetWindow;
+  if (!n) return;
+  const i = l.options.useScrollendEvent && it;
+  let o = 0;
+  const r = i ? null : tt(n, () => t(s(e), !1), l.options.isScrollingResetDelay), a = (m) => () => {
+    o = s(e), r?.(), t(o, m);
+  }, c = a(!0), f = a(!1);
+  return e.addEventListener("scroll", c, F), i && e.addEventListener("scrollend", f, F), () => {
+    e.removeEventListener("scroll", c), i && e.removeEventListener("scrollend", f), r?.cancel();
+  };
+}, ot = (l, t) => lt(l, t, (s) => {
+  const { horizontal: e, isRtl: n } = l.options;
+  return e ? s.scrollLeft * (n && -1 || 1) : s.scrollTop;
+}), rt = (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"];
+}, at = (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
+  });
+}, ht = at, ct = (l, t) => l === "smooth" ? t ? "smoothLanded" : "smooth" : "instant", W = (l) => l?.phase === "smooth" || l?.phase === "smoothLanded", ut = (l) => l.phase === "smooth" || l.phase === "smoothFinishing";
+function dt(l, t, s, e) {
+  if (t === 0) return !1;
+  const n = e(0), i = /* @__PURE__ */ new Set();
+  let o = 0;
+  for (; o < l; ) {
+    const a = s(o);
+    if (a === n) break;
+    i.add(a), o++;
+  }
+  const r = l - o;
+  if (r === 0 || r >= t) return !1;
+  for (let a = 0; a < r; a++) if (e(a) !== s(o + a)) return !1;
+  for (let a = r; a < t; a++) if (i.has(e(a))) return !1;
+  return !0;
+}
+var ft = class {
+  constructor(l) {
+    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._iosDeferredAdjustment = 0, this._iosTouch = null, this.pendingWrite = null, this._clampedAdjustment = null, this.elementsCache = /* @__PURE__ */ new Map(), this._resizeBatch = null, 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((n) => {
+        const i = () => {
+          const o = { sync: !1 };
+          this._resizeBatch = o;
+          try {
+            n.forEach(e);
+          } finally {
+            this._resizeBatch = null, o.notify && (this.notify(o.sync), this._retryClampedAdjustment());
+          }
+        };
+        this.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(i) : i();
+      })), e = (n) => {
+        const i = n.target, o = this.indexFromElement(i);
+        if (!i.isConnected) {
+          this.observer.unobserve(i);
+          for (const [r, a] of this.elementsCache) if (a === i) {
+            this.elementsCache.delete(r);
+            break;
+          }
+          return;
+        }
+        this.isIndexInRange(o) && this.shouldMeasureDuringScroll(o) && this.resizeItem(o, this.options.measureElement(i, n, this));
+      };
+      return {
+        disconnect: () => {
+          var n;
+          (n = s()) == null || n.disconnect(), t = null;
+        },
+        observe: (n) => {
+          var i;
+          return (i = s()) == null ? void 0 : i.observe(n, { box: "border-box" });
+        },
+        unobserve: (n) => {
+          var i;
+          return (i = s()) == null ? void 0 : i.unobserve(n);
+        }
+      };
+    })(), this.range = null, this.setOptions = (t) => {
+      var s;
+      const e = {
+        debug: !1,
+        initialOffset: 0,
+        overscan: 1,
+        paddingStart: 0,
+        paddingEnd: 0,
+        scrollPaddingStart: 0,
+        scrollPaddingEnd: 0,
+        horizontal: !1,
+        getItemKey: et,
+        rangeExtractor: st,
+        onChange: () => {
+        },
+        measureElement: rt,
+        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 c in t) {
+        const f = t[c];
+        f !== void 0 && (e[c] = f);
+      }
+      const n = this.options;
+      let i = null, o = null, r = !1;
+      if (n !== void 0 && n.enabled && e.enabled && e.anchorTo === "end" && this.scrollElement !== null) {
+        const c = n.count, f = e.count, m = this.getMeasurements(), h = ((s = this._singleLaneMeasurements) == null ? void 0 : s.items) ?? m, g = (S) => Y(h[S]), d = c > 0 ? g(0) : null, p = c > 0 ? g(c - 1) : null;
+        if (f !== c || c > 0 && f > 0 && (e.getItemKey(0) !== d || e.getItemKey(f - 1) !== p)) {
+          r = !0;
+          const S = c > 0 ? this.getVirtualItemForOffset(this.getScrollOffset()) ?? m[0] : null;
+          S && (i = [S.key, this.getScrollOffset() - S.start]);
+          const u = e.followOnAppend === !0 ? "auto" : e.followOnAppend || null;
+          u && f > 0 && this.isAtEnd(n.scrollEndThreshold) && (c === 0 || e.getItemKey(f - 1) !== p) && (f > c || dt(c, f, g, e.getItemKey)) && (o = u);
+        }
+      }
+      this.options = e, r && (this.pendingMin = 0, this.itemSizeCacheVersion++);
+      let a = null;
+      if (i && this.scrollOffset !== null) {
+        const [c, f] = i, m = this.getMeasurements(), { count: h, getItemKey: g } = this.options;
+        let d = 0;
+        for (; d < h && g(d) !== c; ) d++;
+        if (d < h) {
+          const p = m[d];
+          if (p) {
+            const S = Math.max(0, p.start + f);
+            !o && S !== this.scrollOffset && (a = S - this.scrollOffset, this.scrollOffset = S);
+          }
+        }
+      }
+      o ? this.pendingScrollAnchor = {
+        kind: "follow",
+        behavior: o
+      } : a !== null && (this.pendingScrollAnchor = {
+        kind: "anchor",
+        delta: a
+      });
+    }, this.notify = (t) => {
+      var s, e;
+      (e = (s = this.options).onChange) == null || e.call(s, this, t);
+    }, this.maybeNotify = M(() => (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.isScrolling = !1, this.scrollDirection = null, this._iosDeferredAdjustment = 0, this._endIosTouch(), this._clampedAdjustment = null, this.pendingWrite = 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) => {
+          var o;
+          if (i && this.pendingWrite === null && n === this.scrollOffset) return;
+          const r = this.pendingWrite;
+          r !== null && Math.abs(n - r.target) < 1.5 ? n = r.target : ((o = this.scrollState) == null ? void 0 : o.index) != null && !ut(this.scrollState) && !z(n, this.scrollState.lastTargetOffset) && !z(n, this.getScrollStateTarget(this.scrollState)) && (this._clampedAdjustment === null || Math.abs(n - this._clampedAdjustment.maxAtWrite) >= 1.5) && (this.scrollState = null), this.pendingWrite = null, this._clampedAdjustment !== null && Math.abs(n - this._clampedAdjustment.maxAtWrite) >= 1.5 && (this._clampedAdjustment = null);
+          const a = this.getScrollOffset();
+          this.scrollDirection = i ? a === n ? this.scrollDirection : a < 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._endIosTouch(), this._iosTouch = { phase: "down" };
+          }, o = () => {
+            if (this._endIosTouch(), !D() || this.targetWindow == null) return;
+            const r = {
+              phase: "tail",
+              timerId: this.targetWindow.setTimeout(() => {
+                this._iosTouch === r && (this._iosTouch = null), this._flushIosDeferredIfReady();
+              }, 150)
+            };
+            this._iosTouch = r;
+          };
+          n.addEventListener("touchstart", i, F), n.addEventListener("touchend", o, F), n.addEventListener("touchcancel", o, F), this.unsubs.push(() => {
+            n.removeEventListener("touchstart", i), n.removeEventListener("touchend", o), n.removeEventListener("touchcancel", o), this._endIosTouch();
+          });
+        }
+        this._scrollToOffset(this.getScrollOffset(), {
+          adjustments: void 0,
+          behavior: void 0
+        });
+      }
+      const e = this.pendingScrollAnchor;
+      this.pendingScrollAnchor = null, e && this.scrollElement && this.options.enabled && (e.kind === "anchor" ? D() && this._iosInMotion() ? this._iosDeferredAdjustment += e.delta : W(this.scrollState) && !z(this.getScrollOffset() - e.delta, this.scrollState.lastTargetOffset) || this._scrollToOffset(this.getScrollOffset(), {
+        adjustments: void 0,
+        behavior: void 0
+      }) : this.scrollToEnd({ behavior: e.behavior })), this._retryClampedAdjustment();
+    }, this._retryClampedAdjustment = () => {
+      if (this._clampedAdjustment === null || !this.scrollElement || !this.options.enabled) return;
+      const { target: t, maxAtWrite: s } = this._clampedAdjustment, e = this.getMaxScrollOffset();
+      e > s + 0.5 && (this._clampedAdjustment = t > e + 0.5 ? {
+        target: t,
+        maxAtWrite: e
+      } : null, this._scrollToOffset(t, {
+        adjustments: void 0,
+        behavior: void 0
+      }));
+    }, this._iosInMotion = () => this.isScrolling || this._iosTouch !== null, this._endIosTouch = () => {
+      var t;
+      ((t = this._iosTouch) == null ? void 0 : t.phase) === "tail" && this.targetWindow != null && this.targetWindow.clearTimeout(this._iosTouch.timerId), this._iosTouch = null;
+    }, this._flushIosDeferredIfReady = () => {
+      if (this._iosDeferredAdjustment === 0 || this._iosInMotion()) return;
+      const t = this.getScrollOffset(), s = this.getMaxScrollOffset();
+      if (t < 0 || t > s) return;
+      if (this._iosDeferredAdjustment < 0 && t >= s - 1) {
+        this._iosDeferredAdjustment = 0;
+        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.getMeasurementOptions = M(() => [
+      this.options.count,
+      this.options.paddingStart,
+      this.options.scrollMargin,
+      this.options.getItemKey,
+      this.options.enabled,
+      this.options.lanes,
+      this.options.laneAssignmentMode,
+      this.options.gap
+    ], (t, s, e, n, i, o, r, a) => (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,
+      gap: a
+    }), { key: !1 }), this.isIndexInRange = (t) => t >= 0 && t < this.options.count, this.getMeasurements = M(() => [this.getMeasurementOptions(), this.itemSizeCacheVersion], ({ count: t, paddingStart: s, scrollMargin: e, getItemKey: n, enabled: i, lanes: o, laneAssignmentMode: r, gap: a }, c) => {
+      var f;
+      const m = this.itemSizeCache;
+      if (!i)
+        return this.measurementsCache = [], this._singleLaneMeasurements = null, this.itemSizeCache.clear(), this.laneAssignments.clear(), [];
+      if (this.laneAssignments.size > t)
+        for (const u of this.laneAssignments.keys()) u >= t && this.laneAssignments.delete(u);
+      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((u) => {
+        this.itemSizeCache.set(u.key, u.size);
+      }));
+      const h = this.lanesSettling ? 0 : this.pendingMin ?? 0;
+      if (this.pendingMin = null, this.lanesSettling && this.measurementsCache.length === t && (this.lanesSettling = !1), o === 1) {
+        const u = t * 2;
+        let v = (f = this._singleLaneMeasurements) == null ? void 0 : f.flat;
+        if (!v || v.length < u) {
+          const b = new Float64Array(u);
+          v && h > 0 && b.set(v.subarray(0, h * 2)), v = b;
+        }
+        const y = h === 0 ? new Array(t) : this._singleLaneMeasurements.items.slice();
+        let x;
+        if (h === 0) x = s + e;
+        else {
+          const b = h - 1;
+          x = v[b * 2] + v[b * 2 + 1] + a;
+        }
+        for (let b = h; b < t; b++) {
+          const w = n(b);
+          y[b] = w;
+          const C = m.get(w), T = typeof C == "number" ? C : this.options.estimateSize(b);
+          v[b * 2] = x, v[b * 2 + 1] = T, x += T + a;
+        }
+        this._singleLaneMeasurements = {
+          flat: v,
+          items: y
+        };
+        const O = Z(y, v);
+        return this.measurementsCache = O, O;
+      }
+      const g = this.measurementsCache.slice(0, h), d = new Array(o).fill(void 0), p = new Float64Array(o);
+      let S = 0;
+      for (let u = 0; u < h; u++) {
+        const v = g[u];
+        v && (d[v.lane] === void 0 && S++, d[v.lane] = u, p[v.lane] = v.end);
+      }
+      for (let u = h; u < t; u++) {
+        const v = n(u), y = this.laneAssignments.get(u);
+        let x, O;
+        const b = r === "estimate" || m.has(v);
+        if (y !== void 0 && this.options.lanes > 1) {
+          x = y;
+          const j = d[x], _ = j !== void 0 ? g[j] : void 0;
+          O = _ ? _.end + a : s + e;
+        } else if (S === o) {
+          let j = 0, _ = p[0], N = d[0];
+          for (let I = 1; I < o; I++) {
+            const L = p[I];
+            (L < _ || L === _ && d[I] < N) && (j = I, _ = L, N = d[I]);
+          }
+          x = j, O = _ + a, b && this.laneAssignments.set(u, x);
+        } else
+          x = u % this.options.lanes, O = s + e, b && this.laneAssignments.set(u, x);
+        const w = m.get(v), C = typeof w == "number" ? w : this.options.estimateSize(u), T = O + C;
+        g[u] = {
+          index: u,
+          start: O,
+          size: C,
+          end: T,
+          key: v,
+          lane: x
+        }, d[x] === void 0 && S++, d[x] = u, p[x] = T;
+      }
+      return this.measurementsCache = g, g;
+    }, {
+      key: process.env.NODE_ENV !== "production" && "getMeasurements",
+      debug: () => this.options.debug
+    }), this.calculateRange = M(() => [
+      this.getMeasurements(),
+      this.getSize(),
+      this.getScrollOffset(),
+      this.options.lanes
+    ], (t, s, e, n) => t.length === 0 || s === 0 ? (this.range = null, null) : (this.range = gt(t, s, e, 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 = M(() => {
+      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,
+        this.options.lanes
+      ];
+    }, (t, s, e, n, i, o) => n === null || i === null ? [] : t({
+      startIndex: n,
+      endIndex: i,
+      overscan: s,
+      count: e,
+      lanes: o
+    }), {
+      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 (!W(this.scrollState)) 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);
+      if (!this.isIndexInRange(s)) return;
+      const 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)), t.isConnected && (!this.isScrolling || this.scrollState) && this.shouldMeasureDuringScroll(s) && this.resizeItem(s, this.options.measureElement(t, void 0, this));
+    }, this.resizeItem = (t, s) => {
+      var e, n, i;
+      if (!this.isIndexInRange(t)) return;
+      (e = this._resizeBatch) != null && e.sync && this.getMeasurements();
+      let o, r, a;
+      const c = (n = this._singleLaneMeasurements) == null ? void 0 : n.flat;
+      if (this.options.lanes === 1 && c != null)
+        a = this.options.getItemKey(t), r = c[t * 2], o = c[t * 2 + 1];
+      else {
+        const h = this.measurementsCache[t];
+        if (!h) return;
+        a = h.key, r = h.start, o = h.size;
+      }
+      const f = this.itemSizeCache.get(a) ?? o, m = s - f;
+      if (m !== 0) {
+        const h = this.options.anchorTo === "end" && !W(this.scrollState) && this.getVirtualDistanceFromEnd() <= this.options.scrollEndThreshold, g = h ? this.getTotalSize() : 0, d = this.getScrollOffset() + this.scrollAdjustments, p = this.itemSizeCache.has(a) ? r + f <= d && this.scrollDirection !== "backward" : r < d, S = !W(this.scrollState) && (this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(this.measurementsCache[t] ?? {
+          index: t,
+          key: a,
+          start: r,
+          size: o,
+          end: r + o,
+          lane: 0
+        }, m, this) : p);
+        (this.pendingMin === null || t < this.pendingMin) && (this.pendingMin = t), this.itemSizeCache.set(a, s), this.itemSizeCacheVersion++;
+        const u = this.getCommandWrittenOffset(), v = u !== null && !z(u, this.getScrollOffset() + this.scrollAdjustments);
+        let y = !1;
+        if (v || (h ? y = this.applyScrollAdjustment(this.getTotalSize() - g) : S && (y = this.applyScrollAdjustment(m))), this._resizeBatch) {
+          this._resizeBatch.notify = !0, (i = this._resizeBatch).sync || (i.sync = y);
+          return;
+        }
+        this.notify(y), this._retryClampedAdjustment();
+      }
+    }, this.getVirtualItems = M(() => [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) => {
+      var s;
+      const e = this.getMeasurements();
+      if (e.length === 0) return;
+      const n = (s = this._singleLaneMeasurements) == null ? void 0 : s.flat, i = this.options.lanes === 1 && n != null, o = $(0, e.length - 1, i ? (r) => n[r * 2] : (r) => B(e[r]).start, t);
+      return B(e[o]);
+    }, 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) {
+        const r = this.getMaxScrollOffset(), a = r - this.options.paddingEnd + this.options.scrollPaddingEnd;
+        return [Math.max(Math.min(a, r), 0), 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" } = {}) => {
+      this._startScroll({
+        index: null,
+        align: s
+      }, this.getOffsetForAlignment(t, s), e, "absolute");
+    }, 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) {
+        this._iosDeferredAdjustment = 0;
+        return;
+      }
+      const [i, o] = n;
+      this._startScroll({
+        index: t,
+        align: o
+      }, i, e, "absolute");
+    }, this.scrollBy = (t, { behavior: s = "auto" } = {}) => {
+      const e = this.getOffsetForAlignment((this.getCommandWrittenOffset() ?? this.getScrollOffset()) + t, "start");
+      this._startScroll({
+        index: null,
+        align: "start"
+      }, e, s, "relative");
+    }, this.scrollToEnd = ({ behavior: t = "auto" } = {}) => {
+      if (this.options.count > 0) {
+        this._startScroll({
+          index: this.options.count - 1,
+          align: "end",
+          toEnd: !0
+        }, Math.max(this.getMaxScrollOffset(), 0), t, "absolute");
+        return;
+      }
+      this.scrollToOffset(Math.max(this.getTotalSize() - this.getSize(), 0), { behavior: t });
+    }, this.cancelScroll = () => {
+      this.rafId != null && this.targetWindow && (this.targetWindow.cancelAnimationFrame(this.rafId), this.rafId = null), this.scrollState = null;
+    }, this.getTotalSize = () => {
+      var t, s;
+      const e = this.getMeasurements();
+      let n;
+      if (e.length === 0) n = this.options.paddingStart;
+      else if (this.options.lanes === 1) {
+        const i = e.length - 1, o = (t = this._singleLaneMeasurements) == null ? void 0 : t.flat;
+        o != null ? n = o[i * 2] + o[i * 2 + 1] : n = ((s = e[i]) == null ? void 0 : s.end) ?? 0;
+      } else {
+        const i = Array(this.options.lanes).fill(null);
+        let o = e.length - 1;
+        for (; o >= 0 && i.some((r) => r === null); ) {
+          const r = e[o];
+          i[r.lane] === null && (i[r.lane] = r.end), o--;
+        }
+        n = Math.max(...i.filter((r) => r !== null));
+      }
+      return Math.max(n - 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.pendingWrite = {
+        target: t + (s ?? 0),
+        smooth: e === "smooth",
+        adjustments: s ?? this.scrollAdjustments
+      }, this.options.scrollToFn(t, {
+        behavior: e,
+        adjustments: s
+      }, this);
+    }, this.getCommandWrittenOffset = () => this.scrollState !== null && this.pendingWrite !== null && !this.pendingWrite.smooth ? this.pendingWrite.target : null, this.measure = () => {
+      this.pendingMin = null, this.itemSizeCache.clear(), this.laneAssignments.clear(), this.itemSizeCacheVersion++, this.notify(!1);
+    }, this.setOptions(l);
+  }
+  get scrollAdjustments() {
+    var l;
+    return ((l = this.pendingWrite) == null ? void 0 : l.adjustments) ?? 0;
+  }
+  applyScrollAdjustment(l, t) {
+    var s;
+    if (l === 0) return !1;
+    if (process.env.NODE_ENV !== "production" && this.options.debug && console.info("correction", l), D() && this._iosInMotion())
+      return ((s = this.scrollState) == null ? void 0 : s.index) == null && (this._iosDeferredAdjustment += l), !1;
+    {
+      const e = this.getScrollOffset() + this.scrollAdjustments + l, n = this.scrollElement, i = n !== null && ("scrollHeight" in n || "document" in n) ? this.getMaxScrollOffset() : null;
+      return this._clampedAdjustment = i !== null && e > i + 0.5 ? {
+        target: e,
+        maxAtWrite: i
+      } : null, this._scrollToOffset(this.getScrollOffset(), {
+        adjustments: this.scrollAdjustments + l,
+        behavior: t
+      }), this.scrollOffset !== null && (this.scrollOffset += this.scrollAdjustments, this.scrollOffset < 0 && (this.scrollOffset = 0), this.pendingWrite && (this.pendingWrite.adjustments = 0)), !0;
+    }
+  }
+  scheduleScrollReconcile() {
+    if (!this.targetWindow) {
+      this.scrollState = null;
+      return;
+    }
+    this.rafId == null && (this.rafId = this.targetWindow.requestAnimationFrame(() => {
+      this.rafId = null, this.reconcileScroll();
+    }));
+  }
+  getScrollStateTarget(l) {
+    const t = l.toEnd ? [Math.max(this.getMaxScrollOffset(), 0)] : l.index != null ? this.getOffsetForIndex(l.index, l.align) : void 0;
+    return t ? t[0] : l.lastTargetOffset;
+  }
+  reconcileScroll() {
+    if (!this.scrollState || !this.scrollElement) return;
+    if (this.now() - this.scrollState.startedAt > 5e3) {
+      this.scrollState = null;
+      return;
+    }
+    this.getMeasurements();
+    const l = this.getScrollStateTarget(this.scrollState), t = this.scrollState.index == null ? 1 : this.options.useAnimationFrameWithResizeObserver ? 3 : 2, s = l !== this.scrollState.lastTargetOffset;
+    if (!s && z(l, this.getScrollOffset())) {
+      if (this.scrollState.phase === "smooth" ? this.scrollState.phase = "smoothLanded" : this.scrollState.phase === "smoothFinishing" && (this.scrollState.phase = "instant"), this.scrollState.stableFrames++, this.scrollState.stableFrames >= t) {
+        this.getScrollOffset() !== l && this._scrollToOffset(l, {
+          adjustments: void 0,
+          behavior: "auto"
+        }), this.scrollState = null;
+        return;
+      }
+    } else if (this.scrollState.stableFrames = 0, s) {
+      const e = this.getSize() || 600, n = Math.abs(l - this.getScrollOffset()), i = W(this.scrollState) && n > e;
+      this.scrollState.lastTargetOffset = l, i ? this.scrollState.phase = "smooth" : this.scrollState.phase === "smooth" ? this.scrollState.phase = "smoothFinishing" : this.scrollState.phase === "smoothLanded" && (this.scrollState.phase = "instant"), this._scrollToOffset(l, {
+        adjustments: void 0,
+        behavior: i ? "smooth" : "auto"
+      });
+    }
+    this.scheduleScrollReconcile();
+  }
+  _startScroll(l, t, s, e) {
+    e === "absolute" && (this._iosDeferredAdjustment = 0), this.scrollState = {
+      ...l,
+      startedAt: this.now(),
+      lastTargetOffset: t,
+      stableFrames: 0,
+      phase: ct(s, l.index != null && z(t, this.getScrollOffset()))
+    }, this._scrollToOffset(t, {
+      adjustments: void 0,
+      behavior: s
+    }), this.scheduleScrollReconcile();
+  }
+}, $ = (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 mt(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 gt(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 c = mt(n, i, s);
+    let f = c;
+    const m = s + t;
+    for (; f < i && n[f * 2] + n[f * 2 + 1] < m; ) f++;
+    return {
+      startIndex: c,
+      endIndex: f
+    };
+  }
+  let r = $(0, i, (c) => l[c].start, s), a = r;
+  if (e === 1) for (; a < i && l[a].end < s + t; ) a++;
+  else if (e > 1) {
+    const c = Array(e).fill(0);
+    for (; a < i && c.some((m) => m < s + t); ) {
+      const m = l[a];
+      c[m.lane] = m.end, a++;
+    }
+    const f = Array(e).fill(s + t);
+    for (; r >= 0 && f.some((m) => m >= s); ) {
+      const m = l[r];
+      f[m.lane] = m.start, r--;
+    }
+    r = Math.max(0, r - r % e), a = Math.min(i, a + (e - 1 - a % e));
+  }
+  return {
+    startIndex: r,
+    endIndex: a
+  };
+}
+var k = typeof document < "u" ? A.useLayoutEffect : A.useEffect;
+function pt({ useFlushSync: l = !0, directDomUpdates: t = !1, directDomUpdatesMode: s = "transform", ...e }) {
+  const n = A.useReducer((h) => h + 1, 0)[1], i = A.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.useRef(!1), r = (h) => {
+    const g = i.current;
+    if (!g.enabled || !g.container) return;
+    const d = h.getTotalSize();
+    if (d !== g.lastSize) {
+      g.lastSize = d;
+      const p = h.options.horizontal ? "width" : "height";
+      g.container.style[p] = `${d}px`;
+    }
+  }, a = (h, g, d) => {
+    const p = i.current, S = !!h.options.horizontal, u = g.start - h.options.scrollMargin;
+    p.lastPositions.get(d) !== u && (p.lastPositions.set(d, u), p.mode === "transform" ? d.style.transform = S ? `translate3d(${u}px, 0, 0)` : `translate3d(0, ${u}px, 0)` : d.style[S ? "left" : "top"] = `${u}px`);
+  }, c = (h) => {
+    const g = i.current;
+    if (!(!g.enabled || !g.container)) {
+      r(h);
+      for (const d of h.getVirtualItems()) {
+        const p = h.elementsCache.get(d.key);
+        p && a(h, d, p);
+      }
+    }
+  }, f = {
+    ...e,
+    onChange: (h, g) => {
+      var d;
+      const p = i.current;
+      let S = !0;
+      if (p.enabled) {
+        c(h);
+        const u = h.range, v = p.prevRange;
+        S = !v || v.isScrolling !== h.isScrolling || v.startIndex !== u?.startIndex || v.endIndex !== u?.endIndex, S && (p.prevRange = u ? {
+          startIndex: u.startIndex,
+          endIndex: u.endIndex,
+          isScrolling: h.isScrolling
+        } : null);
+      }
+      S && (l && g && !o.current ? Q(n) : n()), (d = e.onChange) == null || d.call(e, h, g);
+    }
+  }, [m] = A.useState(() => {
+    const h = new ft(f), g = h.measureElement;
+    return h.measureElement = (d) => {
+      o.current = !0;
+      try {
+        g(d);
+      } finally {
+        o.current = !1;
+      }
+      const p = i.current;
+      if (d !== null && p.enabled && p.container) {
+        const S = h.measurementsCache[h.indexFromElement(d)];
+        S && a(h, S, d);
+      }
+    }, Object.assign(h, { containerRef: (d) => {
+      const p = i.current;
+      p.container = d, p.lastSize = null, d !== null && c(h);
+    } });
+  });
+  return m.setOptions(f), k(() => m._didMount(), []), k(() => (r(m), m._willUpdate())), k(() => {
+    c(m);
+  }), m;
+}
+function St(l) {
+  return pt({
+    observeElementRect: nt,
+    observeElementOffset: ot,
+    scrollToFn: ht,
+    ...l
+  });
+}
+var It = ({ showFlagOnSearch: l, showNameOnSearch: t }) => {
+  const s = J(null), { termOfSearch: e, countries: n, handleSelectCountry: i } = H(), o = G(() => n.filter((a) => a.name.toLocaleLowerCase().includes(e.toLowerCase())), [e]), r = St({
+    count: o.length,
+    overscan: 5,
+    getScrollElement: () => s.current,
+    estimateSize: () => 40
+  });
+  return U(() => {
+    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(P, {
+          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((a) => {
+        const c = o[a.index], { flag: f, name: m, prefix: h } = c;
+        return /* @__PURE__ */ E("li", {
+          className: V("absolute", "w-full", "snap-start", "snap-always", "scroll-m-0", "flex", "items-center", "h-10"),
+          style: {
+            top: a.start,
+            height: a.size
+          },
+          children: /* @__PURE__ */ E("button", {
+            className: V("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(c),
+            children: /* @__PURE__ */ X(P, {
+              variant: "body2",
+              component: "span",
+              className: "flex gap-2 items-center text-left",
+              children: [l && /* @__PURE__ */ E(f, {}), t && /* @__PURE__ */ E(q, {
+                text: m,
+                prefix: h
+              })]
+            })
+          })
+        }, a.key);
+      })
+    })
+  });
+};
+export {
+  It as t
+};