@aiquants/virtualscroll 0.1.0 → 0.2.0

package/dist/index.js

@@ -0,0 +1,1105 @@
+import me, { useState as W, useRef as Y, useEffect as X, forwardRef as de, useReducer as ge, useMemo as ne, useCallback as L, useLayoutEffect as oe, useImperativeHandle as he, useId as be } from "react";
+import { twMerge as ae } from "tailwind-merge";
+var re = { exports: {} }, K = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var ie;
+function ve() {
+  if (ie) return K;
+  ie = 1;
+  var u = Symbol.for("react.transitional.element"), e = Symbol.for("react.fragment");
+  function n(r, s, a) {
+    var o = null;
+    if (a !== void 0 && (o = "" + a), s.key !== void 0 && (o = "" + s.key), "key" in s) {
+      a = {};
+      for (var d in s)
+        d !== "key" && (a[d] = s[d]);
+    } else a = s;
+    return s = a.ref, {
+      $$typeof: u,
+      type: r,
+      key: o,
+      ref: s !== void 0 ? s : null,
+      props: a
+    };
+  }
+  return K.Fragment = e, K.jsx = n, K.jsxs = n, K;
+}
+var ee = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var le;
+function pe() {
+  return le || (le = 1, process.env.NODE_ENV !== "production" && (function() {
+    function u(t) {
+      if (t == null) return null;
+      if (typeof t == "function")
+        return t.$$typeof === H ? null : t.displayName || t.name || null;
+      if (typeof t == "string") return t;
+      switch (t) {
+        case F:
+          return "Fragment";
+        case k:
+          return "Profiler";
+        case b:
+          return "StrictMode";
+        case y:
+          return "Suspense";
+        case N:
+          return "SuspenseList";
+        case J:
+          return "Activity";
+      }
+      if (typeof t == "object")
+        switch (typeof t.tag == "number" && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), t.$$typeof) {
+          case I:
+            return "Portal";
+          case f:
+            return (t.displayName || "Context") + ".Provider";
+          case S:
+            return (t._context.displayName || "Context") + ".Consumer";
+          case w:
+            var i = t.render;
+            return t = t.displayName, t || (t = i.displayName || i.name || "", t = t !== "" ? "ForwardRef(" + t + ")" : "ForwardRef"), t;
+          case $:
+            return i = t.displayName || null, i !== null ? i : u(t.type) || "Memo";
+          case _:
+            i = t._payload, t = t._init;
+            try {
+              return u(t(i));
+            } catch {
+            }
+        }
+      return null;
+    }
+    function e(t) {
+      return "" + t;
+    }
+    function n(t) {
+      try {
+        e(t);
+        var i = !1;
+      } catch {
+        i = !0;
+      }
+      if (i) {
+        i = console;
+        var m = i.error, p = typeof Symbol == "function" && Symbol.toStringTag && t[Symbol.toStringTag] || t.constructor.name || "Object";
+        return m.call(
+          i,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          p
+        ), e(t);
+      }
+    }
+    function r(t) {
+      if (t === F) return "<>";
+      if (typeof t == "object" && t !== null && t.$$typeof === _)
+        return "<...>";
+      try {
+        var i = u(t);
+        return i ? "<" + i + ">" : "<...>";
+      } catch {
+        return "<...>";
+      }
+    }
+    function s() {
+      var t = U.A;
+      return t === null ? null : t.getOwner();
+    }
+    function a() {
+      return Error("react-stack-top-frame");
+    }
+    function o(t) {
+      if (Z.call(t, "key")) {
+        var i = Object.getOwnPropertyDescriptor(t, "key").get;
+        if (i && i.isReactWarning) return !1;
+      }
+      return t.key !== void 0;
+    }
+    function d(t, i) {
+      function m() {
+        G || (G = !0, console.error(
+          "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+          i
+        ));
+      }
+      m.isReactWarning = !0, Object.defineProperty(t, "key", {
+        get: m,
+        configurable: !0
+      });
+    }
+    function l() {
+      var t = u(this.type);
+      return B[t] || (B[t] = !0, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      )), t = this.props.ref, t !== void 0 ? t : null;
+    }
+    function c(t, i, m, p, P, T, C, D) {
+      return m = T.ref, t = {
+        $$typeof: E,
+        type: t,
+        key: i,
+        props: T,
+        _owner: P
+      }, (m !== void 0 ? m : null) !== null ? Object.defineProperty(t, "ref", {
+        enumerable: !1,
+        get: l
+      }) : Object.defineProperty(t, "ref", { enumerable: !1, value: null }), t._store = {}, Object.defineProperty(t._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: 0
+      }), Object.defineProperty(t, "_debugInfo", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      }), Object.defineProperty(t, "_debugStack", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: C
+      }), Object.defineProperty(t, "_debugTask", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: D
+      }), Object.freeze && (Object.freeze(t.props), Object.freeze(t)), t;
+    }
+    function g(t, i, m, p, P, T, C, D) {
+      var V = i.children;
+      if (V !== void 0)
+        if (p)
+          if (j(V)) {
+            for (p = 0; p < V.length; p++)
+              x(V[p]);
+            Object.freeze && Object.freeze(V);
+          } else
+            console.error(
+              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+            );
+        else x(V);
+      if (Z.call(i, "key")) {
+        V = u(t);
+        var q = Object.keys(i).filter(function(se) {
+          return se !== "key";
+        });
+        p = 0 < q.length ? "{key: someKey, " + q.join(": ..., ") + ": ...}" : "{key: someKey}", v[V + p] || (q = 0 < q.length ? "{" + q.join(": ..., ") + ": ...}" : "{}", console.error(
+          `A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`,
+          p,
+          V,
+          q,
+          V
+        ), v[V + p] = !0);
+      }
+      if (V = null, m !== void 0 && (n(m), V = "" + m), o(i) && (n(i.key), V = "" + i.key), "key" in i) {
+        m = {};
+        for (var Q in i)
+          Q !== "key" && (m[Q] = i[Q]);
+      } else m = i;
+      return V && d(
+        m,
+        typeof t == "function" ? t.displayName || t.name || "Unknown" : t
+      ), c(
+        t,
+        V,
+        T,
+        P,
+        s(),
+        m,
+        C,
+        D
+      );
+    }
+    function x(t) {
+      typeof t == "object" && t !== null && t.$$typeof === E && t._store && (t._store.validated = 1);
+    }
+    var R = me, E = Symbol.for("react.transitional.element"), I = Symbol.for("react.portal"), F = Symbol.for("react.fragment"), b = Symbol.for("react.strict_mode"), k = Symbol.for("react.profiler"), S = Symbol.for("react.consumer"), f = Symbol.for("react.context"), w = Symbol.for("react.forward_ref"), y = Symbol.for("react.suspense"), N = Symbol.for("react.suspense_list"), $ = Symbol.for("react.memo"), _ = Symbol.for("react.lazy"), J = Symbol.for("react.activity"), H = Symbol.for("react.client.reference"), U = R.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, Z = Object.prototype.hasOwnProperty, j = Array.isArray, M = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    R = {
+      react_stack_bottom_frame: function(t) {
+        return t();
+      }
+    };
+    var G, B = {}, te = R.react_stack_bottom_frame.bind(
+      R,
+      a
+    )(), h = M(r(a)), v = {};
+    ee.Fragment = F, ee.jsx = function(t, i, m, p, P) {
+      var T = 1e4 > U.recentlyCreatedOwnerStacks++;
+      return g(
+        t,
+        i,
+        m,
+        !1,
+        p,
+        P,
+        T ? Error("react-stack-top-frame") : te,
+        T ? M(r(t)) : h
+      );
+    }, ee.jsxs = function(t, i, m, p, P) {
+      var T = 1e4 > U.recentlyCreatedOwnerStacks++;
+      return g(
+        t,
+        i,
+        m,
+        !0,
+        p,
+        P,
+        T ? Error("react-stack-top-frame") : te,
+        T ? M(r(t)) : h
+      );
+    };
+  })()), ee;
+}
+var ue;
+function xe() {
+  return ue || (ue = 1, process.env.NODE_ENV === "production" ? re.exports = ve() : re.exports = pe()), re.exports;
+}
+var z = xe();
+const A = {
+  debug(u, ...e) {
+    typeof window < "u" && window.localStorage?.getItem("debug") === "true" && console.debug(`[VirtualScroll] ${u}`, ...e);
+  },
+  warn(u, ...e) {
+    console.warn(`[VirtualScroll] ${u}`, ...e);
+  },
+  error(u, ...e) {
+    console.error(`[VirtualScroll] ${u}`, ...e);
+  }
+}, O = (u, e, n) => Math.min(n, Math.max(e, u)), ce = (u, e, n) => {
+  const r = "touches" in u.nativeEvent, s = r ? u.nativeEvent.touches[0] : u.nativeEvent, a = (d) => {
+    r && d.cancelable && d.preventDefault();
+    const l = "touches" in d ? d.touches[0] : d;
+    e({
+      deltaX: l.clientX - s.clientX,
+      deltaY: l.clientY - s.clientY
+    });
+  }, o = () => {
+    r ? (document.removeEventListener("touchmove", a), document.removeEventListener("touchend", o)) : (document.removeEventListener("mousemove", a), document.removeEventListener("mouseup", o)), n?.();
+  };
+  r ? (document.addEventListener("touchmove", a, { passive: !1 }), document.addEventListener("touchend", o)) : (document.addEventListener("mousemove", a), document.addEventListener("mouseup", o));
+}, Te = 20, Ee = ({ contentSize: u, viewportSize: e, scrollPosition: n, onScroll: r, horizontal: s = !1, scrollBarWidth: a = 12, className: o, ariaControls: d }) => {
+  const [l, c] = W(!1), g = Y(null), x = e / u, R = Math.max(Te, x * e), E = u - e, I = n / E * (e - R), F = u > e;
+  X(() => {
+    g.current && (l ? g.current.style.backgroundColor = "#4F4F4F" : g.current.style.backgroundColor = "#7F7F7F");
+  }, [l]);
+  const b = (f) => O(f / (e - R) * E, 0, E), k = (f) => {
+    if (!F || "button" in f && f.button !== 0 || f.ctrlKey)
+      return;
+    f.stopPropagation();
+    const w = I;
+    c(!0), ce(
+      f,
+      ({ deltaX: y, deltaY: N }) => {
+        r?.(b(w + (s ? y : N)), I);
+      },
+      () => {
+        c(!1);
+      }
+    );
+  }, S = (f) => {
+    if (!F || "button" in f && f.button !== 0 || f.ctrlKey)
+      return;
+    const y = "touches" in f.nativeEvent ? f.nativeEvent.touches[0] : f.nativeEvent, N = s ? y.clientX : y.clientY, $ = f.currentTarget.getBoundingClientRect(), J = (s ? N - $.left : N - $.top) - R / 2;
+    r?.(b(J), I), ce(f, ({ deltaX: H, deltaY: U }) => {
+      r?.(b(J + (s ? H : U)), I);
+    });
+  };
+  return (
+    // スクロールバーのコンテナ
+    /* @__PURE__ */ z.jsx(
+      "div",
+      {
+        className: ae("group relative cursor-default select-none", o),
+        style: {
+          [s ? "width" : "height"]: e,
+          [s ? "height" : "width"]: a,
+          backgroundColor: "white",
+          userSelect: "none"
+        },
+        onMouseDown: S,
+        onTouchStart: S,
+        role: "scrollbar",
+        tabIndex: -1,
+        "aria-controls": d,
+        "aria-valuenow": n,
+        "aria-valuemin": 0,
+        "aria-valuemax": E,
+        "aria-orientation": s ? "horizontal" : "vertical",
+        children: u > e && // スクロールバーのつまみの当たり判定を広げるためのラッパー
+        /* @__PURE__ */ z.jsx(
+          "div",
+          {
+            className: "group absolute",
+            style: {
+              [s ? "width" : "height"]: R,
+              [s ? "left" : "top"]: I,
+              // 当たり判定を上下または左右に広げる
+              ...s ? { top: 0, bottom: 0 } : { left: 0, right: 0 }
+            },
+            onMouseDown: k,
+            onTouchStart: k,
+            role: "slider",
+            "aria-orientation": s ? "horizontal" : "vertical",
+            "aria-valuenow": n,
+            "aria-valuemin": 0,
+            "aria-valuemax": E,
+            tabIndex: 0,
+            children: /* @__PURE__ */ z.jsx(
+              "div",
+              {
+                ref: g,
+                className: ae(
+                  "absolute",
+                  s ? `inset-x-0 inset-y-[1.5px] group-hover:inset-y-[-0.5px] ${l ? "inset-y-[-2px]" : "group-active:inset-y-[-2px]"}` : `inset-x-[1.5px] inset-y-0 group-hover:inset-x-[-0.5px] ${l ? "inset-x-[-2px]" : "group-active:inset-x-[-2px]"}`
+                ),
+                style: {
+                  backgroundColor: "#7F7F7F",
+                  borderRadius: a - 1,
+                  // Tailwind が適用されない場合のフォールバック
+                  ...s ? {
+                    left: 0,
+                    right: 0,
+                    top: l ? -2 : 1.5,
+                    bottom: l ? -2 : 1.5
+                  } : {
+                    top: 0,
+                    bottom: 0,
+                    left: l ? -2 : 1.5,
+                    right: l ? -2 : 1.5
+                  }
+                },
+                onMouseEnter: (f) => {
+                  s ? (f.currentTarget.style.top = "-0.5px", f.currentTarget.style.bottom = "-0.5px") : (f.currentTarget.style.left = "-0.5px", f.currentTarget.style.right = "-0.5px"), l || (f.currentTarget.style.backgroundColor = "#5F5F5F");
+                },
+                onMouseLeave: (f) => {
+                  s ? (f.currentTarget.style.top = l ? "-2px" : "1.5px", f.currentTarget.style.bottom = l ? "-2px" : "1.5px") : (f.currentTarget.style.left = l ? "-2px" : "1.5px", f.currentTarget.style.right = l ? "-2px" : "1.5px"), l || (f.currentTarget.style.backgroundColor = "#7F7F7F");
+                }
+              }
+            )
+          }
+        )
+      }
+    )
+  );
+}, _e = de(({ children: u, contentSize: e, viewportSize: n, scrollBarWidth: r = 12, onScroll: s, className: a, style: o, background: d }, l) => {
+  const c = Y(0), [g, x] = ge((k) => k + 1, 0), R = Y(null);
+  A.debug("[ScrollPane] ScrollPane rendered", { contentSize: e, viewportSize: n, scrollBarWidth: r, className: a, style: o });
+  const E = ne(() => e > n, [e, n]), I = L(
+    (k) => {
+      const S = e > n, f = c.current;
+      if (A.debug("[ScrollPane] scrollTo called", { newPosition: k, contentSize: e, viewportSize: n, currentIsScrollable: S, prevPosition: f }), !S) {
+        c.current !== 0 && (c.current = 0, s?.(0, f));
+        return;
+      }
+      const w = typeof k == "function" ? k(c.current) : k, y = O(w, 0, e - n);
+      c.current !== y && (c.current = y, s?.(y, f));
+    },
+    [s, e, n]
+  );
+  oe(() => {
+    if (E) {
+      A.debug("[ScrollPane] Adjusting scroll position due to content or viewport size change", { contentSize: e, viewportSize: n, scrollPosition: c.current });
+      const k = O(e - n, 0, e);
+      c.current > k && I(k);
+    } else
+      I(0);
+  }, [E, I, e, n]), X(() => {
+    const k = (f) => {
+      if (!E)
+        return;
+      f.preventDefault();
+      let w = f.deltaY;
+      f.deltaMode === 1 ? w *= 16 : f.deltaMode === 2 && (w *= n), A.debug("[ScrollPane] wheel event", { deltaY: w, scrollPosition: c.current }), I((y) => y + w);
+    }, S = R.current;
+    return S && S.addEventListener("wheel", k, { passive: !1 }), () => {
+      S && S.removeEventListener("wheel", k);
+    };
+  }, [E, I, n]), he(
+    l,
+    () => ({
+      scrollTo: I,
+      getScrollPosition: () => c.current,
+      getContentSize: () => e,
+      getViewportSize: () => n
+    }),
+    [I, e, n]
+  );
+  const F = be();
+  return ne(() => /* @__PURE__ */ z.jsxs("div", { ref: R, className: ae("flex", a), style: o, children: [
+    /* @__PURE__ */ z.jsxs("div", { className: "relative h-full flex-1 overflow-hidden", style: { height: n }, id: F, children: [
+      d,
+      u(c.current)
+    ] }),
+    E && /* @__PURE__ */ z.jsx(Ee, { contentSize: e, viewportSize: n, scrollPosition: c.current, onScroll: I, scrollBarWidth: r, ariaControls: F })
+  ] }), [u, e, n, r, a, o, E, I, F, d]);
+});
+class Re {
+  /**
+   * @private
+   * @property {Map<number, number>} tree - The Map storing the Fenwick tree structure, specifically the sums of deltas. It is 1-indexed.
+   * @property {Map<number, number>} tree - Fenwick Tree 構造を格納する Map。特に差分の合計を保持する。1-indexed。
+   */
+  tree;
+  /**
+   * @private
+   * @property {Map<number, number>} deltas - The Map storing the differences (deltas) from the base value at each index.
+   * @property {Map<number, number>} deltas - 各インデックスにおける基準値との差分 (delta) を格納する Map。
+   */
+  deltas;
+  /**
+   * @private
+   * @property {number} size - The number of elements the tree manages.
+   * @property {number} size - ツリーが管理する要素数。
+   */
+  size;
+  /**
+   * @private
+   * @property {number} baseValue - The uniform base value for all elements, used to optimize memory.
+   * @property {number} baseValue - 全要素の均一な基準値。メモリ最適化のために使用。
+   */
+  baseValue;
+  /**
+   * @private
+   * @property {((index: number) => number) | undefined} valueFn - A function to generate values, stored for lazy initialization.
+   * @property {((index: number) => number) | undefined} valueFn - 値を生成するための関数。遅延初期化のために保存される。
+   */
+  valueFn;
+  total;
+  /**
+   * @constructor
+   * @description Initializes the Fenwick Tree.
+   * @description Fenwick Tree の初期化。
+   * @param {number} size - The total number of items.
+   * @param {number | ((index: number) => number)} valueOrFn - The value for all elements, or a function to generate values.
+   * @param {{ sampleRange?: { from: number; to: number }, materialize?: boolean }} [options] - Optional settings for initialization.
+   */
+  constructor(e, n, r) {
+    this.reset(e, n, r);
+  }
+  /**
+   * @method reset
+   * @description Resets the Fenwick Tree with a new size and initial values.
+   * @description Fenwick Tree を新しいサイズと初期値でリセット。
+   * @param {number} size - The total number of items.
+   * @param {number | ((index: number) => number)} valueOrFn - The value for all elements, or a function to generate values.
+   * @param {{ sampleRange?: { from: number; to: number }, materialize?: boolean }} [options] - Optional settings for initialization.
+   */
+  reset(e, n, r) {
+    if (this.size = e, this.tree = /* @__PURE__ */ new Map(), this.deltas = /* @__PURE__ */ new Map(), this.total = void 0, typeof n == "function") {
+      if (this.valueFn = n, this.size > 0) {
+        const a = r?.sampleRange ?? {
+          from: 0,
+          to: Math.min(99, this.size - 1)
+        }, { mode: o, materializedValues: d } = this._calculateMode(a.from, a.to);
+        if (this.baseValue = o, r?.materialize)
+          for (let l = 0; l < d.length; l++) {
+            const c = d[l], g = a.from + l;
+            if (g >= this.size)
+              break;
+            const x = c - this.baseValue;
+            this.deltas.set(g, x), this._updateTree(g, x);
+          }
+      } else
+        this.baseValue = 0;
+      this.total = this.getTotal();
+    } else
+      this.valueFn = void 0, this.baseValue = n, this.total = this.baseValue * this.size;
+  }
+  /**
+   * @method setValueFn
+   * @description Updates the value function and re-initializes the tree.
+   * @description 値関数を更新し、ツリーを再初期化する。
+   * @param {number | ((index: number) => number)} valueOrFn - The new value for all elements, or a function to generate values.
+   */
+  setValueFn(e) {
+    typeof e == "function" ? this.valueFn = e : (this.valueFn = void 0, this.baseValue = e);
+  }
+  /**
+   * @private
+   * @method _calculateMode
+   * @description Calculates the mode (most frequent value) within a given range of values generated by `valueFn`. If multiple modes exist, it returns their average. If no value appears more than once, it returns the median of the range. This approach helps determine a representative `baseValue` for the Fenwick tree, especially for data with high variance. It also returns the array of values generated within the range for reuse.
+   * @description `valueFn` によって生成される値の指定された範囲内の最頻値を計算する。最頻値が複数存在する場合は、それらの平均値を返す。どの値も複数回出現しない場合は、範囲の中央値を返す。このアプローチは、特に分散の大きいデータに対して、Fenwick Tree の代表的な `baseValue` を決定するのに役立つ。また、再利用のために範囲内で生成された値の配列も返す。
+   * @param {number} from - The starting index of the range (inclusive).
+   * @param {number} to - The ending index of the range (inclusive).
+   * @returns {{ mode: number; materializedValues: number[] }} An object containing the calculated mode and the array of generated values.
+   */
+  _calculateMode(e, n) {
+    if (!this.valueFn)
+      return { mode: 0, materializedValues: [] };
+    const r = [];
+    for (let c = e; c <= n && !(c >= this.size); c++)
+      r.push(this.valueFn(c));
+    const s = [...r];
+    if (r.length === 0)
+      return { mode: 0, materializedValues: [] };
+    r.sort((c, g) => c - g);
+    const a = Math.floor(r.length / 2);
+    let o;
+    r.length % 2 === 0 ? o = Math.floor((r[a - 1] + r[a]) / 2) : o = r[a];
+    const d = /* @__PURE__ */ new Map();
+    let l = 0;
+    for (const c of r) {
+      const g = (d.get(c) ?? 0) + 1;
+      d.set(c, g), g > l && (l = g);
+    }
+    if (l > 1) {
+      const c = [];
+      for (const [x, R] of d.entries())
+        R === l && c.push(x);
+      const g = c.reduce((x, R) => x + R, 0);
+      o = Math.floor(g / c.length);
+    }
+    return { mode: o, materializedValues: s };
+  }
+  /**
+   * @method update
+   * @description Updates the value at a given index.
+   * @description 指定されたインデックスの値を更新。
+   * @param {number} index - The 0-based index to update.
+   * @param {number} value - The new value.
+   */
+  update(e, n) {
+    return this.updates([{ index: e, value: n }]);
+  }
+  /**
+   * @method updates
+   * @description Updates the values at given indices.
+   * @description 指定されたインデックスの値を更新。
+   * @param {{ index: number; value: number }[]} updates - An array of updates, each with an index and the new value.
+   */
+  updates(e) {
+    const n = e.map(({ index: r, value: s }) => {
+      if (r < 0 || r >= this.size)
+        throw new Error(`Index ${r} out of bounds`);
+      if (s < 0)
+        throw new Error("Value cannot be negative.");
+      const a = this.deltas.has(r) ? (this.deltas.get(r) ?? 0) + this.baseValue : this.baseValue, o = s - a;
+      return { index: r, change: o };
+    }).filter((r) => r.change !== 0);
+    return n.length > 0 ? this.updateDeltas(n) : this.total;
+  }
+  /**
+   * @method updateDelta
+   * @description Updates the delta at a given index and propagates the change through the tree.
+   * @description 指定されたインデックスのデルタを更新し、変更をツリーに伝播させる。
+   * @param {number} index - The 0-based index to update.
+   * @param {number} change - The value to add to the delta at the given index.
+   */
+  updateDelta(e, n) {
+    return this.updateDeltas([{ index: e, change: n }]);
+  }
+  /**
+   * @method updateDeltas
+   * @description Updates the deltas at given indices and propagates the changes through the tree.
+   * @description 指定されたインデックスのデルタを更新し、変更をツリーに伝播させる。
+   * @param {{ index: number; change: number }[]} updates - An array of updates, each with an index and the change to apply.
+   */
+  updateDeltas(e) {
+    for (const { index: n, change: r } of e) {
+      if (n < 0 || n >= this.size)
+        throw new Error(`Index ${n} out of bounds`);
+      const s = this.deltas.get(n) ?? 0;
+      this.deltas.set(n, s + r), this._updateTree(n, r);
+    }
+    return this.total;
+  }
+  /**
+   * @private
+   * @method _updateTree
+   * @description Updates the Fenwick tree and the total sum with a given change.
+   * @description Fenwick Tree と合計値を指定された変更で更新する。
+   * @param {number} index - The 0-based index that changed.
+   * @param {number} change - The change in value.
+   */
+  _updateTree(e, n) {
+    if (n === 0)
+      return;
+    let r = e + 1;
+    for (; r <= this.size; )
+      this.tree.set(r, (this.tree.get(r) ?? 0) + n), r += r & -r;
+    this.total !== void 0 && (this.total += n);
+  }
+  /**
+   * @private
+   * @method _materialize
+   * @description Materializes the value at a specific index if it hasn't been already.
+   * @description 特定のインデックスの値がまだ具現化されていない場合に具現化する。
+   * @param {number} index - The 0-based index to materialize.
+   * @param {boolean} [updateTree=true] - Whether to update the Fenwick tree after materialization.
+   */
+  _materialize(e, n = !0) {
+    if (this.valueFn) {
+      const r = this.deltas.get(e) ?? 0, a = this.valueFn(e) - this.baseValue;
+      if (a !== r && (this.deltas.set(e, a), n)) {
+        const o = a - r;
+        this._updateTree(e, o);
+      }
+    }
+  }
+  /**
+   * @method prefixSum
+   * @description Calculates the cumulative sum up to a given index (inclusive) in O(log n) time.
+   * @description 指定されたインデックスまでの累積和を O(log n) で計算。
+   * @param {number} index - The 0-based index to prefixSum up to.
+   * @param {object} [options] - Optional settings for materializing values.
+   * @param {object} [options.materializeOption] - Options to control materialization.
+   * @param {boolean} [options.materializeOption.materialize=false] - Whether to materialize values.
+   * @param {object[]} [options.materializeOption.ranges] - An optional array of ranges to materialize values for.
+   * @param {number} options.materializeOption.ranges.from - The starting index of the range.
+   * @param {number} options.materializeOption.ranges.to - The ending index of the range.
+   * @returns {{ cumulative: number; total: number | undefined; currentValue: number; safeIndex: number }} The cumulative sum of values from index 0 to the given index, the total sum, and the value at the given index.
+   */
+  prefixSum(e, n) {
+    if (e < 0)
+      return { cumulative: 0, total: this.total, currentValue: 0, safeIndex: 0 };
+    const r = O(e, 0, this.size - 1), s = n?.materializeOption;
+    if (s?.materialize && this.valueFn) {
+      if (s.ranges)
+        for (const l of s.ranges) {
+          const c = l.from, g = Math.min(l.to, this.size - 1);
+          for (let x = c; x <= g; x++)
+            this._materialize(x);
+        }
+      this._materialize(r);
+    }
+    let a = 0, o = r + 1;
+    for (; o > 0; ) {
+      const l = this.tree.get(o) ?? 0;
+      a += l, o -= o & -o;
+    }
+    const d = s?.materialize ? this.get(r) : (this.deltas.get(r) || 0) + this.baseValue;
+    return { cumulative: a + this.baseValue * (r + 1), total: this.total, currentValue: d, safeIndex: r };
+  }
+  /**
+   * @method get
+   * @description Gets the value at a specific index.
+   * @description 特定のインデックスの値を取得。
+   * @param {number} index - The 0-based index to get.
+   * @param {object} [options] - Optional settings for materializing values.
+   * @param {object} [options.materializeOption] - Options to control materialization.
+   * @param {boolean} [options.materializeOption.materialize=false] - Whether to materialize values.
+   * @param {object[]} [options.materializeOption.ranges] - An optional array of ranges to materialize values for.
+   * @param {number} options.materializeOption.ranges.from - The starting index of the range.
+   * @param {number} options.materializeOption.ranges.to - The ending index of the range.
+   * @returns {number} The value at the given index.
+   */
+  get(e, n) {
+    if (e < 0 || e >= this.size)
+      throw new Error("Index out of bounds");
+    const r = n?.materializeOption;
+    if (r?.materialize && this.valueFn)
+      if (r.ranges) {
+        for (const s of r.ranges) {
+          const a = s.from, o = Math.min(s.to, this.size - 1);
+          for (let d = a; d <= o; d++)
+            this._materialize(d);
+        }
+        e >= r.ranges[0].from && e <= r.ranges[r.ranges.length - 1].to && this._materialize(e);
+      } else
+        this._materialize(e);
+    return (this.deltas.get(e) ?? 0) + this.baseValue;
+  }
+  /**
+   * @method getTotal
+   * @description Gets the total sum of all values in the tree.
+   * @description ツリー内のすべての値の合計を取得。
+   * @param {object} [options] - Optional settings for materializing values.
+   * @param {object} [options.materializeOption] - Options to control materialization.
+   * @param {boolean} [options.materializeOption.materialize=false] - Whether to materialize values.
+   * @param {object[]} [options.materializeOption.ranges] - An optional array of ranges to materialize values for.
+   * @param {number} options.materializeOption.ranges.from - The starting index of the range.
+   * @param {number} options.materializeOption.ranges.to - The ending index of the range.
+   * @returns {number} The total sum of all values.
+   */
+  getTotal(e) {
+    const n = e?.materializeOption;
+    if (n?.materialize && this.valueFn && n.ranges)
+      for (const r of n.ranges) {
+        const s = r.from, a = Math.min(r.to, this.size - 1);
+        for (let o = s; o <= a; o++)
+          this._materialize(o);
+      }
+    if (this.total === void 0)
+      if (this.size === 0)
+        this.total = 0;
+      else {
+        let r = this.baseValue * this.size;
+        for (const s of this.deltas.values())
+          r += s;
+        this.total = r, console.assert(this.prefixSum(this.getSize() - 1).cumulative === this.prefixSum(this.getSize() - 1).total, "Inconsistent Fenwick Tree state");
+      }
+    return this.total;
+  }
+  /**
+   * @method rebuildTree
+   * @description Rebuilds the Fenwick Tree from the existing `baseValue` and `deltas`. This corrects any discrepancies in the tree's internal state, such as those caused by floating-point errors, by recalculating the tree structure and the total sum from the source `deltas`. This method does not re-materialize values from `valueFn`.
+   * @description 既存の `baseValue` と `deltas` から Fenwick Tree を再構築します。これにより、`deltas` からツリー構造と合計値を再計算することで、浮動小数点誤差などによって生じた内部状態の不一致を修正します。このメソッドは `valueFn` から値を再具現化しません。
+   * @param {object} [options] - Optional settings for rebuilding.
+   * @param {boolean} [options.materialize=false] - If true and `valueFn` is provided, re-materializes all values, recalculating `deltas` and `baseValue`.
+   */
+  rebuildTree(e) {
+    if (e?.materialize && this.valueFn) {
+      const s = this.valueFn;
+      this.reset(this.size, (a) => s(a), { materialize: !0 });
+      return;
+    }
+    const n = /* @__PURE__ */ new Map();
+    let r = this.baseValue * this.size;
+    for (const [s, a] of this.deltas.entries()) {
+      if (r += a, a === 0)
+        continue;
+      let o = s + 1;
+      for (; o <= this.size; )
+        n.set(o, (n.get(o) ?? 0) + a), o += o & -o;
+    }
+    this.tree = n, this.total = r;
+  }
+  /**
+   * @method calculateAccumulatedError
+   * @description Compares the cached total sum with a theoretical total calculated directly from the source values (`deltas` and `baseValue`, or `valueFn`). This helps detect any discrepancy in the tree's cached state, which might be caused by floating-point errors or other inconsistencies.
+   * @description キャッシュされている合計値と、元の値 (`deltas` と `baseValue`、または `valueFn`) から直接計算した理論上の合計値とを比較します。これにより、浮動小数点数の累積誤差やその他の不整合によって生じる可能性のある、ツリーのキャッシュ状態の不一致を検出できます。
+   * @returns {number} The difference between the cached total and the theoretical total.
+   */
+  calculateAccumulatedError() {
+    if (this.total === void 0)
+      return 0;
+    let e = this.baseValue * this.size;
+    for (const n of this.deltas.values())
+      e += n;
+    return this.total - e;
+  }
+  /**
+   * @method changeSize
+   * @description Changes the size of the Fenwick Tree.
+   * @description Fenwick Tree のサイズを変更する。
+   * @param {number} newSize - The new size of the tree.
+   */
+  changeSize(e) {
+    const n = this.size;
+    if (e !== n) {
+      if (e < n)
+        for (const r of this.deltas.keys())
+          r >= e && this.deltas.delete(r);
+      this.size = e, this.rebuildTree(), console.assert(this.prefixSum(this.getSize() - 1).cumulative === this.prefixSum(this.getSize() - 1).total, "Inconsistent Fenwick Tree state");
+    }
+  }
+  /**
+   * @method getSize
+   * @description Gets the size of the tree.
+   * @description ツリーのサイズを取得。
+   * @returns {number} The total number of items.
+   */
+  getSize() {
+    return this.size;
+  }
+  /**
+   * @method findIndexAtOrAfter
+   * @description Finds the first index where the cumulative sum is greater than or equal to a target value.
+   * @description 累積和がターゲット値以上になる最初のインデックスを検索。
+   * @param {number} target - The target cumulative sum.
+   * @param {object} [options] - Optional settings for materializing values.
+   * @param {object} [options.materializeOption] - Options to control materialization.
+   * @param {boolean} [options.materializeOption.materialize=false] - Whether to materialize values.
+   * @param {object[]} [options.materializeOption.ranges] - An optional array of ranges to materialize values for.
+   * @param {number} options.materializeOption.ranges.from - The starting index of the range.
+   * @param {number} options.materializeOption.ranges.to - The ending index of the range.
+   * @returns {{ index: number, total: number | undefined, cumulative: number | undefined, currentValue: number | undefined, safeIndex: number | undefined }} The 0-based index and the total sum, or -1 if not found.
+   */
+  findIndexAtOrAfter(e, n) {
+    if (this.size === 0)
+      return { index: -1, total: this.total ?? 0, cumulative: void 0, currentValue: void 0, safeIndex: void 0 };
+    let r = 0, s = this.size - 1, a = -1, o, d = this.total;
+    for (; r <= s; ) {
+      const l = Math.floor((r + s) / 2);
+      o = this.prefixSum(l, n), d = o.total, o.cumulative >= e ? (a = l, s = l - 1) : r = l + 1;
+    }
+    return { index: a, total: d, cumulative: o?.cumulative, currentValue: o?.currentValue, safeIndex: o?.safeIndex };
+  }
+  /**
+   * @method findIndexAtOrBefore
+   * @description Finds the last index where the cumulative sum is less than or equal to a target value.
+   * @description 累積和がターゲット値以下になる最後のインデックスを検索。
+   * @param {number} target - The target cumulative sum.
+   * @param {object} [options] - Optional settings for materializing values.
+   * @param {object} [options.materializeOption] - Options to control materialization.
+   * @param {boolean} [options.materializeOption.materialize=false] - Whether to materialize values.
+   * @param {object[]} [options.materializeOption.ranges] - An optional array of ranges to materialize values for.
+   * @param {number} options.materializeOption.ranges.from - The starting index of the range.
+   * @param {number} options.materializeOption.ranges.to - The ending index of the range.
+   * @returns {{ index: number, total: number | undefined, cumulative: number | undefined, currentValue: number | undefined, safeIndex: number | undefined }} The 0-based index and the total sum, or -1 if not found.
+   */
+  findIndexAtOrBefore(e, n) {
+    if (this.size === 0)
+      return { index: -1, total: this.total ?? 0, cumulative: void 0, currentValue: void 0, safeIndex: void 0 };
+    let r = 0, s = this.size - 1, a = -1, o, d = this.total;
+    for (; r <= s; ) {
+      const l = Math.floor((r + s) / 2);
+      o = this.prefixSum(l, n), d = o.total, o.cumulative <= e ? (a = l, r = l + 1) : s = l - 1;
+    }
+    return { index: a, total: d, cumulative: o?.cumulative, currentValue: o?.currentValue, safeIndex: o?.safeIndex };
+  }
+}
+const Ie = (u, e, n) => {
+  const r = Math.max(0, u), s = Y(null), a = ne(() => new Re(r, e, n), [r, e, n]);
+  return Object.is(s.current, a) || console.warn("[useFenwickMapTree] instance changed"), s.current = a, a;
+};
+function ke({ itemCount: u, getItem: e, getItemHeight: n, viewportSize: r, overscanCount: s = 5, className: a, onScroll: o, onRangeChange: d, children: l, background: c, initialScrollIndex: g, initialScrollOffset: x }, R) {
+  const E = Y(null), I = Y(!1);
+  X(() => (I.current = !0, () => {
+    I.current = !1;
+  }), []);
+  const F = Y({ size: u, valueOrFn: n, options: { sampleRange: { from: 0, to: 100 } } }), b = Ie(F.current.size, F.current.valueOrFn, F.current.options), [k] = W(() => {
+    let h = 0, v = 0;
+    if (typeof g == "number") {
+      const t = O(g, 0, u - 1), i = O(t - s * 2, 0, u - 1), m = O(t + s * 2, 0, u - 1), p = g > 0 ? { materializeOption: { materialize: !0, ranges: [{ from: i, to: m }] } } : void 0, { cumulative: P, total: T, currentValue: C } = b.prefixSum(g, p);
+      h = P - C, v = T ?? b.getTotal();
+    } else typeof x == "number" && (h = x), v = b.getTotal();
+    return { position: h, total: v };
+  }), [S, f] = W(k.position), [w, y] = W(k.total), [N, $] = W(k.position), [_, J] = W(u);
+  oe(() => {
+    b.setValueFn(n), _ !== u && (b.changeSize(u), J(u));
+    const h = b.getTotal();
+    w !== h && y(h);
+  }, [b, _, u, w, n]), oe(() => {
+    N !== null && E.current && (A.debug("[VirtualScroll] Scrolling to position:", N), E.current.scrollTo(N), $(null));
+  }, [N]);
+  const H = L(
+    (h) => {
+      if (E.current) {
+        A.debug("[VirtualScroll] Scrolling to index:", h);
+        const v = O(h, 0, _ - 1), t = O(v - s * 2, 0, _ - 1), i = O(v + s * 2, 0, _ - 1), { cumulative: m, total: p, currentValue: P } = b.prefixSum(v, { materializeOption: { materialize: !0, ranges: [{ from: t, to: i }] } });
+        A.debug("[VirtualScroll] Scrolling to index:", h, "Offset:", m, "Total height:", p, "Current value:", P, "safeIndex:", v, "safeIndexFrom:", t, "safeIndexTo:", i), p && (y(p), $(m - P)), A.debug("[VirtualScroll] Setting scroll position to:", m - P);
+      }
+    },
+    [b, s, _]
+  ), U = L(
+    (h) => {
+      if (E.current) {
+        const v = b.getTotal(), t = O(Math.floor(h), 0, v), i = b.findIndexAtOrAfter(t, { materializeOption: { materialize: !1 } }).index;
+        H(i);
+      }
+    },
+    [b, H]
+  ), Z = L(
+    (h, v) => {
+      A.debug("[VirtualScroll] Scroll position changed:", h), f(h);
+      const t = b.getTotal();
+      o?.(h, t);
+    },
+    [b, o]
+  ), { renderingStartIndex: j, renderingEndIndex: M, visibleStartIndex: G, visibleEndIndex: B } = ne(() => {
+    if (_ === 0)
+      return { renderingStartIndex: 0, renderingEndIndex: 0, visibleStartIndex: 0, visibleEndIndex: 0 };
+    const { index: h, cumulative: v, currentValue: t } = b.findIndexAtOrAfter(S, { materializeOption: { materialize: !1 } });
+    let i = 0;
+    h === -1 ? i = 0 : (v ?? 0) < S + (t ?? 0) ? i = 1 : i = 0;
+    const m = h === -1 ? 0 : h + i, p = O(m - s, 0, _ - 1);
+    let P = 0, T = h === -1 ? 0 : h + i;
+    for (; T < _ && P < r; ) {
+      const D = n(T);
+      P += D, T++;
+    }
+    T -= 1;
+    const C = O(T + s, 0, _ - 1);
+    return A.debug("[VirtualScroll] Calculated rendering range:", {
+      renderingStartIndex: p,
+      renderingEndIndex: C,
+      visibleStartIndex: m,
+      visibleEndIndex: T,
+      scrollPosition: S,
+      renderingContentSize: b.getTotal(),
+      overscanCount: s,
+      viewportSize: r
+    }), { renderingStartIndex: p, renderingEndIndex: C, visibleStartIndex: m, visibleEndIndex: T };
+  }, [S, s, r, n, b, _]);
+  X(() => {
+    const h = E.current?.getScrollPosition() ?? 0;
+    A.debug("[VirtualScroll] Range change effect triggered", {
+      renderingStartIndex: j,
+      renderingEndIndex: M,
+      visibleStartIndex: G,
+      visibleEndIndex: B,
+      scrollPosition: S,
+      contentSize: w,
+      scrollPaneScrollPosition: h
+    }), d?.(j, M, G, B, S, w);
+  }, [j, M, G, B, d, S, w]), X(() => {
+    if (_ === 0) return;
+    const h = [];
+    for (let v = j; v <= M; v++) {
+      const t = n(v);
+      b.get(v) !== t && h.push({ index: v, value: t });
+    }
+    if (h.length > 0) {
+      const v = b.updates(h);
+      v && y((t) => v !== t && I.current ? (A.debug("[VirtualScroll] Updated heights for items", h, "New total height:", v), v) : t);
+    }
+  }, [j, M, n, b, _]);
+  const te = L(
+    (h) => {
+      if (A.debug("[VirtualScroll] Rendering visible items", { currentScrollPosition: h, renderingStartIndex: j, renderingEndIndex: M, fenwickSize: _, viewportSize: r }), _ === 0)
+        return /* @__PURE__ */ z.jsx("div", { className: "absolute w-full", style: { top: 0 }, children: /* @__PURE__ */ z.jsx("div", { className: "text-center text-gray-500", children: "No items" }) });
+      const v = O(j, 0, _ - 1), { cumulative: t, currentValue: i } = b.prefixSum(v, { materializeOption: { materialize: !1 } }), m = t - i, p = [];
+      for (let T = j; T <= M; T++)
+        p.push(e(T));
+      const P = w < r ? 0 : m - h;
+      return A.debug("[VirtualScroll] Rendering items", { visibleItems: p, containerTop: P }), /* @__PURE__ */ z.jsx("div", { className: "absolute w-full", style: { top: P }, children: p.map((T, C) => {
+        const D = j + C, V = O(D, 0, _ - 1), { cumulative: q, currentValue: Q } = b.prefixSum(V, { materializeOption: { materialize: !1 } }), se = q - Q;
+        return /* @__PURE__ */ z.jsx(
+          "div",
+          {
+            "data-index": D,
+            style: {
+              position: "absolute",
+              top: se - m,
+              width: "100%"
+            },
+            children: l(T, D)
+          },
+          D
+        );
+      }) });
+    },
+    [e, l, w, r, j, M, b, _]
+  );
+  return he(
+    R,
+    () => ({
+      getScrollPosition: () => E.current?.getScrollPosition() ?? -1,
+      getContentSize: () => E.current?.getContentSize() ?? -1,
+      getViewportSize: () => E.current?.getViewportSize() ?? -1,
+      scrollTo: (h) => U(h),
+      scrollToIndex: (h) => H(h),
+      getFenwickTreeTotalHeight: () => b.getTotal(),
+      getFenwickSize: () => b.getSize()
+    }),
+    [H, b, U]
+  ), /* @__PURE__ */ z.jsx(_e, { ref: E, contentSize: w, viewportSize: r, className: a, onScroll: Z, background: c, children: te });
+}
+const Oe = de(ke);
+class Se {
+  key;
+  value;
+  prev = null;
+  next = null;
+  constructor(e, n) {
+    this.key = e, this.value = n;
+  }
+}
+class fe {
+  head = null;
+  tail = null;
+  /**
+   * @method addToTail
+   * @description Adds a node to the tail of the list, marking it as the most recently used.
+   * @description ノードをリストの末尾に追加し、最も最近使用されたものとしてマークします。
+   * @param {DoublyLinkedListNode<K, V>} node - The node to add.
+   */
+  addToTail(e) {
+    this.tail ? (this.tail.next = e, e.prev = this.tail, this.tail = e) : this.head = this.tail = e;
+  }
+  /**
+   * @method remove
+   * @description Removes a given node from the list.
+   * @description 指定されたノードをリストから削除します。
+   * @param {DoublyLinkedListNode<K, V>} node - The node to remove.
+   */
+  remove(e) {
+    e.prev ? e.prev.next = e.next : this.head = e.next, e.next ? e.next.prev = e.prev : this.tail = e.prev, e.prev = null, e.next = null;
+  }
+  /**
+   * @method removeHead
+   * @description Removes and returns the head of the list, which is the least recently used item.
+   * @description リストの先頭（最も最近使用されていないアイテム）を削除して返します。
+   * @returns {DoublyLinkedListNode<K, V> | null} The removed head node, or null if the list is empty.
+   */
+  removeHead() {
+    const e = this.head;
+    return e && this.remove(e), e;
+  }
+  /**
+   * @method moveToTail
+   * @description Moves an existing node to the tail of the list to mark it as most recently used.
+   * @description 既存のノードをリストの末尾に移動し、最も最近使用されたものとしてマークします。
+   * @param {DoublyLinkedListNode<K, V>} node - The node to move.
+   */
+  moveToTail(e) {
+    this.remove(e), this.addToTail(e);
+  }
+}
+function we(u) {
+  const e = Y(/* @__PURE__ */ new Map()), n = Y(new fe());
+  X(() => {
+    for (; e.current.size > u; ) {
+      const c = n.current.removeHead();
+      if (c)
+        e.current.delete(c.key);
+      else
+        break;
+    }
+  }, [u]);
+  const r = L((c) => {
+    const g = e.current.get(c);
+    if (g)
+      return n.current.moveToTail(g), g.value;
+  }, []), s = L(
+    (c, g) => {
+      if (u <= 0)
+        return;
+      let x = e.current.get(c);
+      if (x)
+        x.value = g, n.current.moveToTail(x);
+      else {
+        if (e.current.size >= u) {
+          const R = n.current.removeHead();
+          R && e.current.delete(R.key);
+        }
+        x = new Se(c, g), e.current.set(c, x), n.current.addToTail(x);
+      }
+    },
+    [u]
+  ), a = L((c) => e.current.has(c), []), o = L(() => {
+    e.current.clear(), n.current = new fe();
+  }, []), [d, l] = W(() => ({ get: r, set: s, has: a, clear: o }));
+  return X(() => l({ get: r, set: s, has: a, clear: o }), [r, s, a, o]), d;
+}
+const Pe = 1e4, Fe = () => {
+  const { get: u, set: e, has: n, clear: r } = we(Pe);
+  return { get: u, set: e, has: n, clear: r };
+};
+export {
+  Re as FenwickMapTree,
+  Ee as ScrollBar,
+  _e as ScrollPane,
+  Oe as VirtualScroll,
+  O as minmax,
+  Ie as useFenwickMapTree,
+  Fe as useHeightCache,
+  we as useLruCache
+};
+//# sourceMappingURL=index.js.map