react-excel-lite 0.0.7 → 0.2.0

package/dist/react-excel-lite.js

@@ -1,298 +1,341 @@
-import { jsxs as K, jsx as v } from "react/jsx-runtime";
-import { useState as L, useCallback as C, useEffect as W, useRef as O, useMemo as U } from "react";
-function H(...o) {
-  return o.filter(Boolean).join(" ");
+import { jsxs as A, jsx as N, Fragment as Q } from "react/jsx-runtime";
+import { useState as z, useCallback as M, useEffect as j, useRef as U, useLayoutEffect as Y, useMemo as $ } from "react";
+function W(...e) {
+  return e.filter(Boolean).join(" ");
 }
-function Co(o) {
-  return `${o.row}-${o.col}`;
+function ke(e) {
+  return `${e.row}-${e.col}`;
 }
-function xo(o) {
-  const [t, n] = o.split("-").map(Number);
-  return { row: t, col: n };
+function Ee(e) {
+  const [o, l] = e.split("-").map(Number);
+  return { row: o, col: l };
 }
-function So(o, t) {
-  if (!o || !t) return o ? [o] : [];
-  const n = Math.min(o.row, t.row), s = Math.max(o.row, t.row), u = Math.min(o.col, t.col), b = Math.max(o.col, t.col), c = [];
-  for (let h = n; h <= s; h++)
-    for (let f = u; f <= b; f++)
-      c.push({ row: h, col: f });
-  return c;
+function ve(e, o) {
+  if (!e || !o) return e ? [e] : [];
+  const l = Math.min(e.row, o.row), i = Math.max(e.row, o.row), a = Math.min(e.col, o.col), x = Math.max(e.col, o.col), u = [];
+  for (let m = l; m <= i; m++)
+    for (let f = a; f <= x; f++)
+      u.push({ row: m, col: f });
+  return u;
 }
-function X(o, t) {
-  if (!t.start) return !1;
-  const n = t.end || t.start, s = Math.min(t.start.row, n.row), u = Math.max(t.start.row, n.row), b = Math.min(t.start.col, n.col), c = Math.max(t.start.col, n.col);
-  return o.row >= s && o.row <= u && o.col >= b && o.col <= c;
+function Z(e, o) {
+  if (!o.start) return !1;
+  const l = o.end || o.start, i = Math.min(o.start.row, l.row), a = Math.max(o.start.row, l.row), x = Math.min(o.start.col, l.col), u = Math.max(o.start.col, l.col);
+  return e.row >= i && e.row <= a && e.col >= x && e.col <= u;
 }
-function _(o) {
-  return o.split(/\r?\n/).filter((t) => t.trim()).map((t) => t.split("	").map((n) => n.trim()));
+function ee(e) {
+  return e.split(/\r?\n/).filter((o) => o.trim()).map((o) => o.split("	").map((l) => l.trim()));
 }
-function J(o) {
-  return o.map((t) => t.join("	")).join(`
+function te(e) {
+  return e.map((o) => o.join("	")).join(`
 `);
 }
-function j(o) {
-  return !o.start || !o.end ? o : {
+function B(e) {
+  return !e.start || !e.end ? e : {
     start: {
-      row: Math.min(o.start.row, o.end.row),
-      col: Math.min(o.start.col, o.end.col)
+      row: Math.min(e.start.row, e.end.row),
+      col: Math.min(e.start.col, e.end.col)
     },
     end: {
-      row: Math.max(o.start.row, o.end.row),
-      col: Math.max(o.start.col, o.end.col)
+      row: Math.max(e.start.row, e.end.row),
+      col: Math.max(e.start.col, e.end.col)
     }
   };
 }
-function yo(o, t) {
-  if (o.row === t.row && o.col === t.col)
+function Fe(e, o) {
+  if (e.row === o.row && e.col === o.col)
     return [];
-  const n = Math.min(o.row, t.row), s = Math.max(o.row, t.row), u = Math.min(o.col, t.col), b = Math.max(o.col, t.col), c = [];
-  for (let h = n; h <= s; h++)
-    for (let f = u; f <= b; f++)
-      h === o.row && f === o.col || c.push({ row: h, col: f });
-  return c;
+  const l = Math.min(e.row, o.row), i = Math.max(e.row, o.row), a = Math.min(e.col, o.col), x = Math.max(e.col, o.col), u = [];
+  for (let m = l; m <= i; m++)
+    for (let f = a; f <= x; f++)
+      m === e.row && f === e.col || u.push({ row: m, col: f });
+  return u;
 }
-function Q() {
-  const [o, t] = L({
+function oe({
+  containerRef: e
+}) {
+  const [o, l] = z({
     start: null,
     end: null
-  }), [n, s] = L(!1), u = C((a) => {
-    t({ start: a, end: a }), s(!0);
-  }, []), b = C(
-    (a) => {
-      n && t((l) => ({ ...l, end: a }));
+  }), [i, a] = z(!1), x = M((c) => {
+    l({ start: c, end: c }), a(!0);
+  }, []), u = M(
+    (c) => {
+      i && l((n) => ({ ...n, end: c }));
     },
-    [n]
-  ), c = C(() => {
-    s(!1);
-  }, []), h = C(() => {
-    t({ start: null, end: null }), s(!1);
-  }, []), f = C(
-    (a) => X(a, o),
+    [i]
+  ), m = M(() => {
+    a(!1);
+  }, []), f = M(() => {
+    l({ start: null, end: null }), a(!1);
+  }, []), g = M(
+    (c) => Z(c, o),
     [o]
   );
-  return W(() => {
-    const a = () => {
-      n && s(!1);
+  return j(() => {
+    const c = () => {
+      i && a(!1);
+    };
+    return window.addEventListener("mouseup", c), () => window.removeEventListener("mouseup", c);
+  }, [i]), j(() => {
+    const c = (n) => {
+      e.current && !e.current.contains(n.target) && f();
     };
-    return window.addEventListener("mouseup", a), () => window.removeEventListener("mouseup", a);
-  }, [n]), {
+    return document.addEventListener("mousedown", c), () => document.removeEventListener("mousedown", c);
+  }, [e, f]), {
     selection: o,
-    isSelecting: n,
-    isCellSelected: f,
-    handleCellMouseDown: u,
-    handleCellMouseEnter: b,
-    handleMouseUp: c,
-    clearSelection: h,
-    setSelection: t
+    isSelecting: i,
+    isCellSelected: g,
+    handleCellMouseDown: x,
+    handleCellMouseEnter: u,
+    handleMouseUp: m,
+    clearSelection: f,
+    setSelection: l
   };
 }
-function Y({
-  selection: o,
-  getValue: t,
-  setValues: n,
-  rowCount: s,
-  colCount: u
+function ne({
+  selection: e,
+  getValue: o,
+  setValues: l,
+  setSelection: i,
+  rowCount: a,
+  colCount: x
 }) {
-  const b = C(() => {
-    const l = j(o);
-    if (!l.start || !l.end) return [];
-    const x = [];
-    for (let y = l.start.row; y <= l.end.row; y++) {
-      const M = [];
-      for (let g = l.start.col; g <= l.end.col; g++)
-        M.push(t({ row: y, col: g }));
-      x.push(M);
+  const u = M(() => {
+    const n = B(e);
+    if (!n.start || !n.end) return [];
+    const S = [];
+    for (let d = n.start.row; d <= n.end.row; d++) {
+      const C = [];
+      for (let r = n.start.col; r <= n.end.col; r++)
+        C.push(o({ row: d, col: r }));
+      S.push(C);
     }
-    return x;
-  }, [o, t]), c = C(async () => {
-    const l = b();
-    if (l.length === 0) return;
-    const x = J(l);
+    return S;
+  }, [e, o]), m = M(async () => {
+    const n = u();
+    if (n.length === 0) return;
+    const S = te(n);
     try {
-      await navigator.clipboard.writeText(x);
-    } catch (y) {
-      console.error("Clipboard copy failed:", y);
+      await navigator.clipboard.writeText(S);
+    } catch (d) {
+      console.error("Clipboard copy failed:", d);
     }
-  }, [b]), h = C(async () => {
-    if (o.start)
+  }, [u]), f = M(async () => {
+    if (e.start)
       try {
-        const l = await navigator.clipboard.readText(), x = _(l);
-        if (x.length === 0) return;
-        const y = o.start.row, M = o.start.col, g = [];
-        x.forEach((w, p) => {
-          const d = y + p;
-          d >= s || w.forEach((i, R) => {
-            const F = M + R;
-            F >= u || g.push({ coord: { row: d, col: F }, value: i });
+        const n = await navigator.clipboard.readText(), S = ee(n);
+        if (S.length === 0) return;
+        const d = e.start.row, C = e.start.col, r = [];
+        S.forEach((b, w) => {
+          const h = d + w;
+          h >= a || b.forEach((F, v) => {
+            const s = C + v;
+            s >= x || r.push({ coord: { row: h, col: s }, value: F });
           });
-        }), g.length > 0 && n(g);
-      } catch (l) {
-        console.error("Clipboard paste failed:", l);
+        }), r.length > 0 && l(r);
+      } catch (n) {
+        console.error("Clipboard paste failed:", n);
+      }
+  }, [e.start, l, a, x]), g = M(() => {
+    const n = B(e);
+    if (!n.start || !n.end) return;
+    const S = [];
+    for (let d = n.start.row; d <= n.end.row; d++)
+      for (let C = n.start.col; C <= n.end.col; C++)
+        S.push({ coord: { row: d, col: C }, value: "" });
+    S.length > 0 && l(S);
+  }, [e, l]), c = M(
+    (n) => {
+      if (!(n.target instanceof HTMLInputElement && !n.target.readOnly)) {
+        if (["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"].includes(n.key)) {
+          n.preventDefault();
+          const d = B(e).start ?? { row: 0, col: 0 };
+          let C = d.row, r = d.col;
+          switch (n.key) {
+            case "ArrowUp":
+              C = Math.max(0, d.row - 1);
+              break;
+            case "ArrowDown":
+              C = Math.min(a - 1, d.row + 1);
+              break;
+            case "ArrowLeft":
+              r = Math.max(0, d.col - 1);
+              break;
+            case "ArrowRight":
+              r = Math.min(x - 1, d.col + 1);
+              break;
+          }
+          i({
+            start: { row: C, col: r },
+            end: { row: C, col: r }
+          });
+          return;
+        }
+        (n.ctrlKey || n.metaKey) && n.key === "c" && (n.preventDefault(), m()), (n.ctrlKey || n.metaKey) && n.key === "v" && (n.preventDefault(), f()), (n.key === "Backspace" || n.key === "Delete") && (n.preventDefault(), g());
       }
-  }, [o.start, n, s, u]), f = C(() => {
-    const l = j(o);
-    if (!l.start || !l.end) return;
-    const x = [];
-    for (let y = l.start.row; y <= l.end.row; y++)
-      for (let M = l.start.col; M <= l.end.col; M++)
-        x.push({ coord: { row: y, col: M }, value: "" });
-    x.length > 0 && n(x);
-  }, [o, n]), a = C(
-    (l) => {
-      (l.ctrlKey || l.metaKey) && l.key === "c" && (l.preventDefault(), c()), (l.ctrlKey || l.metaKey) && l.key === "v" && (l.preventDefault(), h()), (l.key === "Backspace" || l.key === "Delete") && (l.preventDefault(), f());
     },
-    [c, h, f]
+    [
+      m,
+      f,
+      g,
+      e,
+      i,
+      a,
+      x
+    ]
   );
   return {
-    handleCopy: c,
-    handlePaste: h,
-    handleKeyDown: a
+    handleCopy: m,
+    handlePaste: f,
+    handleKeyDown: c
   };
 }
-function Z(o) {
-  if (o.trim() === "") return null;
-  const t = Number(o);
-  return isNaN(t) ? null : t;
+function le(e) {
+  if (e.trim() === "") return null;
+  const o = Number(e);
+  return isNaN(o) ? null : o;
 }
-function q(o) {
-  if (o.length === 0) return null;
-  const t = o.map(Z);
-  if (t.some((u) => u === null)) return null;
-  const n = t;
-  if (n.length === 1)
-    return { numbers: n, diff: 0 };
-  const s = n[1] - n[0];
-  for (let u = 2; u < n.length; u++)
-    if (n[u] - n[u - 1] !== s)
-      return { numbers: n, diff: 0 };
-  return { numbers: n, diff: s };
+function X(e) {
+  if (e.length === 0) return null;
+  const o = e.map(le);
+  if (o.some((a) => a === null)) return null;
+  const l = o;
+  if (l.length === 1)
+    return { numbers: l, diff: 0 };
+  const i = l[1] - l[0];
+  for (let a = 2; a < l.length; a++)
+    if (l[a] - l[a - 1] !== i)
+      return { numbers: l, diff: 0 };
+  return { numbers: l, diff: i };
 }
-function oo({
-  selection: o,
-  getValue: t,
-  setValues: n
+function re({
+  selection: e,
+  getValue: o,
+  setValues: l
 }) {
-  const [s, u] = L(null), [b, c] = L([]), [h, f] = L(!1), [a, l] = L(null), x = C((w) => {
-    u(w), f(!0), c([]), l(null);
-  }, []), y = C(
-    (w) => {
-      if (!h || !o.start) return;
-      const p = j(o);
-      if (!p.start || !p.end) return;
-      l(w);
-      const d = {
-        row: Math.min(p.start.row, w.row),
-        col: Math.min(p.start.col, w.col)
-      }, i = {
-        row: Math.max(p.end.row, w.row),
-        col: Math.max(p.end.col, w.col)
-      }, R = [];
-      for (let F = d.row; F <= i.row; F++)
-        for (let r = d.col; r <= i.col; r++)
-          F >= p.start.row && F <= p.end.row && r >= p.start.col && r <= p.end.col || R.push({ row: F, col: r });
-      c(R);
+  const [i, a] = z(null), [x, u] = z([]), [m, f] = z(!1), [g, c] = z(null), n = M((r) => {
+    a(r), f(!0), u([]), c(null);
+  }, []), S = M(
+    (r) => {
+      if (!m || !e.start) return;
+      const b = B(e);
+      if (!b.start || !b.end) return;
+      c(r);
+      const w = {
+        row: Math.min(b.start.row, r.row),
+        col: Math.min(b.start.col, r.col)
+      }, h = {
+        row: Math.max(b.end.row, r.row),
+        col: Math.max(b.end.col, r.col)
+      }, F = [];
+      for (let v = w.row; v <= h.row; v++)
+        for (let s = w.col; s <= h.col; s++)
+          v >= b.start.row && v <= b.end.row && s >= b.start.col && s <= b.end.col || F.push({ row: v, col: s });
+      u(F);
     },
-    [h, o]
-  ), M = C(() => {
-    if (!o.start || b.length === 0 || !a) {
-      u(null), c([]), f(!1), l(null);
+    [m, e]
+  ), d = M(() => {
+    if (!e.start || x.length === 0 || !g) {
+      a(null), u([]), f(!1), c(null);
       return;
     }
-    const w = j(o);
-    if (!w.start || !w.end) {
-      u(null), c([]), f(!1), l(null);
+    const r = B(e);
+    if (!r.start || !r.end) {
+      a(null), u([]), f(!1), c(null);
       return;
     }
-    const p = [], d = w.start, i = w.end, R = i.row - d.row + 1, F = i.col - d.col + 1;
-    b.forEach((r) => {
-      let k, T;
-      if (r.row < d.row) {
-        const N = d.row - r.row;
-        k = i.row - (N - 1) % R;
-      } else if (r.row > i.row) {
-        const N = r.row - i.row;
-        k = d.row + (N - 1) % R;
+    const b = [], w = r.start, h = r.end, F = h.row - w.row + 1, v = h.col - w.col + 1;
+    x.forEach((s) => {
+      let R, I;
+      if (s.row < w.row) {
+        const E = w.row - s.row;
+        R = h.row - (E - 1) % F;
+      } else if (s.row > h.row) {
+        const E = s.row - h.row;
+        R = w.row + (E - 1) % F;
       } else
-        k = r.row;
-      if (r.col < d.col) {
-        const N = d.col - r.col;
-        T = i.col - (N - 1) % F;
-      } else if (r.col > i.col) {
-        const N = r.col - i.col;
-        T = d.col + (N - 1) % F;
+        R = s.row;
+      if (s.col < w.col) {
+        const E = w.col - s.col;
+        I = h.col - (E - 1) % v;
+      } else if (s.col > h.col) {
+        const E = s.col - h.col;
+        I = w.col + (E - 1) % v;
       } else
-        T = r.col;
-      let G = t({ row: k, col: T });
-      if (r.row !== k && r.col >= d.col && r.col <= i.col) {
-        const N = [];
-        for (let S = d.row; S <= i.row; S++)
-          N.push(t({ row: S, col: r.col }));
-        const D = q(N);
+        I = s.col;
+      let H = o({ row: R, col: I });
+      if (s.row !== R && s.col >= w.col && s.col <= h.col) {
+        const E = [];
+        for (let k = w.row; k <= h.row; k++)
+          E.push(o({ row: k, col: s.col }));
+        const D = X(E);
         if (D && D.diff !== 0) {
-          if (r.row > i.row) {
-            const S = r.row - i.row;
-            G = String(D.numbers[D.numbers.length - 1] + D.diff * S);
-          } else if (r.row < d.row) {
-            const S = d.row - r.row;
-            G = String(D.numbers[0] - D.diff * S);
+          if (s.row > h.row) {
+            const k = s.row - h.row;
+            H = String(D.numbers[D.numbers.length - 1] + D.diff * k);
+          } else if (s.row < w.row) {
+            const k = w.row - s.row;
+            H = String(D.numbers[0] - D.diff * k);
           }
         }
       }
-      if (r.col !== T && r.row >= d.row && r.row <= i.row) {
-        const N = [];
-        for (let S = d.col; S <= i.col; S++)
-          N.push(t({ row: r.row, col: S }));
-        const D = q(N);
+      if (s.col !== I && s.row >= w.row && s.row <= h.row) {
+        const E = [];
+        for (let k = w.col; k <= h.col; k++)
+          E.push(o({ row: s.row, col: k }));
+        const D = X(E);
         if (D && D.diff !== 0) {
-          if (r.col > i.col) {
-            const S = r.col - i.col;
-            G = String(D.numbers[D.numbers.length - 1] + D.diff * S);
-          } else if (r.col < d.col) {
-            const S = d.col - r.col;
-            G = String(D.numbers[0] - D.diff * S);
+          if (s.col > h.col) {
+            const k = s.col - h.col;
+            H = String(D.numbers[D.numbers.length - 1] + D.diff * k);
+          } else if (s.col < w.col) {
+            const k = w.col - s.col;
+            H = String(D.numbers[0] - D.diff * k);
           }
         }
       }
-      p.push({ coord: r, value: G });
-    }), p.length > 0 && n(p), u(null), c([]), f(!1), l(null);
-  }, [o, b, a, t, n]), g = C(
-    (w) => b.some(
-      (p) => p.row === w.row && p.col === w.col
+      b.push({ coord: s, value: H });
+    }), b.length > 0 && l(b), a(null), u([]), f(!1), c(null);
+  }, [e, x, g, o, l]), C = M(
+    (r) => x.some(
+      (b) => b.row === r.row && b.col === r.col
     ),
-    [b]
+    [x]
   );
-  return W(() => {
-    const w = () => {
-      h && M();
+  return j(() => {
+    const r = () => {
+      m && d();
     };
-    return window.addEventListener("mouseup", w), () => window.removeEventListener("mouseup", w);
-  }, [h, M]), {
-    fillSource: s,
-    fillTargets: b,
-    isDraggingFill: h,
-    isFillTarget: g,
-    handleFillHandleMouseDown: x,
-    handleCellMouseEnterForFill: y,
-    handleFillMouseUp: M
+    return window.addEventListener("mouseup", r), () => window.removeEventListener("mouseup", r);
+  }, [m, d]), {
+    fillSource: i,
+    fillTargets: x,
+    isDraggingFill: m,
+    isFillTarget: C,
+    handleFillHandleMouseDown: n,
+    handleCellMouseEnterForFill: S,
+    handleFillMouseUp: d
   };
 }
-const to = {
+const se = {
   position: "relative",
   border: "1px solid #d1d5db",
-  padding: 0
-}, no = {
+  padding: 0,
+  height: "28px",
+  minWidth: "80px"
+}, ce = {
   width: "100%",
   height: "100%",
-  paddingLeft: "4px",
-  paddingRight: "4px",
-  paddingTop: "4px",
-  paddingBottom: "4px",
+  padding: "4px",
   textAlign: "right",
   fontSize: "12px",
+  boxSizing: "border-box",
+  cursor: "cell",
   backgroundColor: "transparent",
   outline: "none",
-  cursor: "cell"
-}, lo = {
+  border: "none"
+}, ie = {
   position: "absolute",
   bottom: "-2px",
   right: "-2px",
@@ -301,80 +344,146 @@ const to = {
   cursor: "crosshair",
   zIndex: 20,
   backgroundColor: "#3b82f6"
-}, eo = {
+}, ae = {
+  position: "absolute",
+  top: 0,
+  left: 0,
+  minWidth: "100%",
+  height: "100%",
+  zIndex: 30
+}, ue = {
+  height: "100%",
+  padding: "4px",
+  textAlign: "right",
+  fontSize: "12px",
+  boxSizing: "border-box",
+  backgroundColor: "#fff",
+  border: "2px solid #3b82f6",
+  outline: "none",
+  minWidth: "100%"
+}, fe = {
+  position: "absolute",
+  visibility: "hidden",
+  whiteSpace: "pre",
+  fontSize: "12px",
+  padding: "4px"
+}, de = {
   backgroundColor: "#dbeafe",
   outline: "2px solid #3b82f6",
   outlineOffset: "-2px"
-}, ro = {
+}, we = {
   backgroundColor: "#eff6ff"
 };
-function so({
-  coord: o,
-  value: t,
-  isSelected: n,
-  isFillTarget: s,
-  showFillHandle: u,
-  onMouseDown: b,
-  onMouseEnter: c,
-  onChange: h,
+function he({
+  coord: e,
+  value: o,
+  isSelected: l,
+  isFillTarget: i,
+  showFillHandle: a,
+  onMouseDown: x,
+  onMouseEnter: u,
+  onChange: m,
   onFillHandleMouseDown: f,
-  styles: a
+  styles: g
 }) {
-  const l = (i) => {
-    h(o, i.target.value);
-  }, x = (i) => {
-    i.target.classList.contains("fill-handle") || b(o);
-  }, y = (i) => {
-    i.stopPropagation(), i.preventDefault(), f(o);
-  }, M = !!a?.selected, g = !!a?.fillTarget, w = !!a?.fillHandle, p = {
-    ...to,
-    ...n && !M ? eo : {},
-    ...s && !g ? ro : {}
-  }, d = {
-    ...lo,
-    ...w ? { backgroundColor: void 0 } : {}
+  const [c, n] = z(!1), [S, d] = z(!1), [C, r] = z(null), b = U(null), w = U(null), h = U(null), F = U(null);
+  Y(() => {
+    if (c && h.current && F.current) {
+      const t = h.current.offsetWidth, p = F.current.offsetWidth;
+      r(Math.max(t + 16, p));
+    }
+  }, [c, o]), j(() => {
+    c && w.current ? (w.current.focus(), S && (w.current.select(), d(!1))) : l && !c && b.current && b.current.focus();
+  }, [l, c, S]), j(() => {
+    !l && c && (n(!1), r(null));
+  }, [l, c]);
+  const v = (t) => {
+    m(e, t.target.value);
+  }, s = (t) => {
+    t.target.classList.contains("fill-handle") || x(e);
+  }, R = () => {
+    n(!0), d(!0);
+  }, I = () => {
+    n(!1);
+  }, H = (t) => {
+    c ? (t.key === "Enter" || t.key === "Escape") && n(!1) : t.key === "Enter" ? (t.preventDefault(), n(!0), d(!0)) : t.key.length === 1 && !t.ctrlKey && !t.metaKey && (t.preventDefault(), m(e, t.key), n(!0));
+  }, E = (t) => {
+    t.stopPropagation(), t.preventDefault(), f(e);
+  }, D = !!g?.selected, k = !!g?.fillTarget, O = !!g?.fillHandle, G = {
+    ...se,
+    ...l && !D ? de : {},
+    ...i && !k ? we : {}
+  }, q = {
+    ...ie,
+    ...O ? { backgroundColor: void 0 } : {}
+  }, P = {
+    ...ce,
+    overflow: "hidden",
+    textOverflow: "ellipsis"
   };
-  return /* @__PURE__ */ K(
+  return /* @__PURE__ */ A(
     "td",
     {
-      className: H(
-        a?.cell,
-        n && a?.selected,
-        s && a?.fillTarget
+      ref: F,
+      className: W(
+        g?.cell,
+        l && g?.selected,
+        i && g?.fillTarget
       ),
-      style: p,
-      onMouseDown: x,
-      onMouseEnter: () => c(o),
+      style: G,
+      onMouseDown: s,
+      onMouseEnter: () => u(e),
+      onDoubleClick: R,
       children: [
-        /* @__PURE__ */ v(
+        /* @__PURE__ */ N(
           "input",
           {
+            ref: b,
             type: "text",
-            value: t,
-            onChange: l,
-            style: no
+            value: o,
+            readOnly: !0,
+            onChange: v,
+            onKeyDown: H,
+            style: P,
+            tabIndex: c ? -1 : 0
           }
         ),
-        u && /* @__PURE__ */ v(
+        c && /* @__PURE__ */ N("div", { style: ae, children: /* @__PURE__ */ N(
+          "input",
+          {
+            ref: w,
+            type: "text",
+            value: o,
+            onChange: v,
+            onBlur: I,
+            onKeyDown: H,
+            style: {
+              ...ue,
+              width: C ?? "100%"
+            }
+          }
+        ) }),
+        c && /* @__PURE__ */ N("span", { ref: h, style: fe, children: o }),
+        a && /* @__PURE__ */ N(
           "div",
           {
-            className: H("fill-handle", a?.fillHandle),
-            style: d,
-            onMouseDown: y
+            className: W("fill-handle", g?.fillHandle),
+            style: q,
+            onMouseDown: E
           }
         )
       ]
     }
   );
 }
-const co = {
+const pe = {
   outline: "none",
   overflowX: "auto"
-}, io = {
+}, me = {
   borderCollapse: "collapse",
   fontSize: "12px",
   userSelect: "none"
-}, ao = {
+}, be = {
   position: "sticky",
   left: 0,
   zIndex: 10,
@@ -382,222 +491,255 @@ const co = {
   padding: "6px 8px",
   textAlign: "center",
   fontWeight: 500
-}, uo = {
+}, ye = {
   border: "1px solid #d1d5db",
   padding: "6px 4px",
   textAlign: "center",
   fontWeight: 500
-}, fo = {
+}, xe = {
   border: "1px solid #d1d5db",
   padding: "4px",
   textAlign: "center",
   fontWeight: 500,
   fontSize: "11px"
-}, wo = {
+}, ge = {
   backgroundColor: "#f3f4f6"
-}, ho = {
+}, Se = {
   backgroundColor: "#dbeafe",
   color: "#1d4ed8"
-}, po = {
+}, Ce = {
   backgroundColor: "#f9fafb"
 };
-function Mo({
-  data: o,
-  onChange: t,
-  rowHeaders: n,
-  colHeaders: s,
-  className: u,
-  rowHeaderTitle: b = "",
-  styles: c
+function Ne({
+  data: e,
+  onChange: o,
+  rowHeaders: l,
+  colHeaders: i,
+  className: a,
+  rowHeaderTitle: x = "",
+  styles: u
 }) {
-  const h = O(null), f = o.length, a = U(() => s ? s.reduce(
-    (e, m) => e + m.headers.length,
+  const m = U(null), f = e.length, g = $(() => i ? i.reduce(
+    (t, p) => t + p.headers.length,
     0
-  ) : o[0]?.length ?? 0, [s, o]), l = U(() => s ? s.flatMap((e) => e.headers) : [], [s]), x = C(
-    (e) => e.row < 0 || e.row >= f || e.col < 0 || e.col >= a ? "" : o[e.row]?.[e.col] ?? "",
-    [o, f, a]
-  ), y = C(
-    (e, m) => {
-      const E = o.map(
-        (z, B) => B === e.row ? z.map(
-          (A, I) => I === e.col ? m : A
-        ) : z
+  ) : e[0]?.length ?? 0, [i, e]), c = $(() => i ? i.flatMap((t) => t.headers) : [], [i]), n = $(() => {
+    if (!l) return null;
+    const t = [];
+    return l.forEach((p, y) => {
+      p.headers.forEach((L, K) => {
+        t.push({
+          groupIndex: y,
+          isFirstInGroup: K === 0,
+          groupLabel: p.label,
+          groupRowCount: p.headers.length,
+          rowHeader: L,
+          groupClassName: p.className,
+          groupDescription: p.description
+        });
+      });
+    }), t;
+  }, [l]), S = M(
+    (t) => t.row < 0 || t.row >= f || t.col < 0 || t.col >= g ? "" : e[t.row]?.[t.col] ?? "",
+    [e, f, g]
+  ), d = M(
+    (t, p) => {
+      const y = e.map(
+        (L, K) => K === t.row ? L.map(
+          (T, V) => V === t.col ? p : T
+        ) : L
       );
-      t(E);
+      o(y);
     },
-    [o, t]
-  ), M = C(
-    (e) => {
-      if (e.length === 0) return;
-      const m = o.map((E) => [...E]);
-      e.forEach(({ coord: E, value: z }) => {
-        E.row >= 0 && E.row < f && E.col >= 0 && E.col < a && (m[E.row][E.col] = z);
-      }), t(m);
+    [e, o]
+  ), C = M(
+    (t) => {
+      if (t.length === 0) return;
+      const p = e.map((y) => [...y]);
+      t.forEach(({ coord: y, value: L }) => {
+        y.row >= 0 && y.row < f && y.col >= 0 && y.col < g && (p[y.row][y.col] = L);
+      }), o(p);
     },
-    [o, t, f, a]
+    [e, o, f, g]
   ), {
-    selection: g,
-    isSelecting: w,
-    isCellSelected: p,
-    handleCellMouseDown: d,
-    handleCellMouseEnter: i
-  } = Q(), { handleKeyDown: R } = Y({
-    selection: g,
-    getValue: x,
-    setValues: M,
+    selection: r,
+    isSelecting: b,
+    isCellSelected: w,
+    handleCellMouseDown: h,
+    handleCellMouseEnter: F,
+    setSelection: v
+  } = oe({ containerRef: m }), { handleKeyDown: s } = ne({
+    selection: r,
+    getValue: S,
+    setValues: C,
+    setSelection: v,
     rowCount: f,
-    colCount: a
+    colCount: g
   }), {
-    isDraggingFill: F,
-    isFillTarget: r,
-    handleFillHandleMouseDown: k,
-    handleCellMouseEnterForFill: T
-  } = oo({
-    selection: g,
-    getValue: x,
-    setValues: M
-  }), G = C(
-    (e) => {
-      F ? T(e) : w && i(e);
+    isDraggingFill: R,
+    isFillTarget: I,
+    handleFillHandleMouseDown: H,
+    handleCellMouseEnterForFill: E
+  } = re({
+    selection: r,
+    getValue: S,
+    setValues: C
+  }), D = M(
+    (t) => {
+      R ? E(t) : b && F(t);
     },
     [
-      F,
-      w,
-      T,
-      i
+      R,
+      b,
+      E,
+      F
     ]
-  ), N = C(
-    (e, m) => {
-      y(e, m);
+  ), k = M(
+    (t, p) => {
+      d(t, p);
     },
-    [y]
-  ), D = C(
-    (e) => {
-      if (!g.start) return !1;
-      const m = j(g);
-      return !m.start || !m.end ? !1 : e.row === m.end.row && e.col === m.end.col;
+    [d]
+  ), O = M(
+    (t) => {
+      if (!r.start) return !1;
+      const p = B(r);
+      return !p.start || !p.end ? !1 : t.row === p.end.row && t.col === p.end.col;
     },
-    [g]
-  ), S = (e) => ({
-    ...ao,
-    ...!e && !c?.rowHeader ? wo : {}
-  }), P = (e) => ({
-    ...uo,
-    ...!e && !c?.colGroup ? ho : {}
-  }), V = (e) => ({
-    ...fo,
-    ...!e && !c?.colHeader ? po : {}
+    [r]
+  ), G = (t) => ({
+    ...be,
+    ...!t && !u?.rowHeader ? ge : {}
+  }), q = (t) => ({
+    ...ye,
+    ...!t && !u?.colGroup ? Se : {}
+  }), P = (t) => ({
+    ...xe,
+    ...!t && !u?.colHeader ? Ce : {}
   });
-  return /* @__PURE__ */ v(
+  return /* @__PURE__ */ N(
     "div",
     {
-      ref: h,
-      className: u,
-      style: co,
+      ref: m,
+      className: a,
+      style: pe,
       tabIndex: 0,
-      onKeyDown: R,
-      children: /* @__PURE__ */ K("table", { style: io, children: [
-        /* @__PURE__ */ K("thead", { children: [
-          s && /* @__PURE__ */ K("tr", { children: [
-            n && /* @__PURE__ */ v(
+      onKeyDown: s,
+      children: /* @__PURE__ */ A("table", { style: me, children: [
+        /* @__PURE__ */ A("thead", { children: [
+          i && /* @__PURE__ */ A("tr", { children: [
+            l && /* @__PURE__ */ N(
               "th",
               {
-                className: c?.rowHeader,
-                style: S(),
-                children: b
+                colSpan: 2,
+                className: u?.rowHeader,
+                style: G(),
+                children: x
               }
             ),
-            s.map((e, m) => /* @__PURE__ */ v(
+            i.map((t, p) => /* @__PURE__ */ N(
               "th",
               {
-                colSpan: e.headers.length,
-                className: H(c?.colGroup, e.className),
-                style: P(e.className),
-                children: e.label
+                colSpan: t.headers.length,
+                className: W(u?.colGroup, t.className),
+                style: q(t.className),
+                title: t.description,
+                children: t.label
               },
-              m
+              p
             ))
           ] }),
-          s && /* @__PURE__ */ K("tr", { children: [
-            n && /* @__PURE__ */ v(
+          i && /* @__PURE__ */ A("tr", { children: [
+            l && /* @__PURE__ */ N(
               "th",
               {
-                className: c?.rowHeader,
-                style: S()
+                colSpan: 2,
+                className: u?.rowHeader,
+                style: G()
               }
             ),
-            l.map((e) => /* @__PURE__ */ v(
+            c.map((t) => /* @__PURE__ */ N(
               "th",
               {
-                className: H(c?.colHeader, e.className),
-                style: V(e.className),
-                title: e.description,
-                children: e.label
+                className: W(u?.colHeader, t.className),
+                style: P(t.className),
+                title: t.description,
+                children: t.label
               },
-              e.key
+              t.key
             ))
           ] })
         ] }),
-        /* @__PURE__ */ v("tbody", { children: o.map((e, m) => /* @__PURE__ */ K("tr", { children: [
-          n && n[m] && /* @__PURE__ */ v(
-            "td",
-            {
-              className: H(
-                c?.rowHeader,
-                n[m].className
+        /* @__PURE__ */ N("tbody", { children: e.map((t, p) => {
+          const y = n?.[p];
+          return /* @__PURE__ */ A("tr", { children: [
+            y && /* @__PURE__ */ A(Q, { children: [
+              y.isFirstInGroup && /* @__PURE__ */ N(
+                "td",
+                {
+                  rowSpan: y.groupRowCount,
+                  className: W(u?.rowHeader, y.groupClassName),
+                  style: G(y.groupClassName),
+                  title: y.groupDescription,
+                  children: y.groupLabel
+                }
               ),
-              style: S(n[m].className),
-              title: n[m].description,
-              children: n[m].label
-            }
-          ),
-          e.map((E, z) => {
-            const B = { row: m, col: z }, A = p(B), I = r(B), $ = D(B);
-            return /* @__PURE__ */ v(
-              so,
-              {
-                coord: B,
-                value: x(B),
-                isSelected: A,
-                isFillTarget: I,
-                showFillHandle: $ && !F,
-                onMouseDown: d,
-                onMouseEnter: G,
-                onChange: N,
-                onFillHandleMouseDown: k,
-                styles: c
-              },
-              z
-            );
-          })
-        ] }, m)) })
+              /* @__PURE__ */ N(
+                "td",
+                {
+                  className: W(u?.rowHeader, y.rowHeader.className),
+                  style: G(y.rowHeader.className),
+                  title: y.rowHeader.description,
+                  children: y.rowHeader.label
+                }
+              )
+            ] }),
+            t.map((L, K) => {
+              const T = { row: p, col: K }, V = w(T), _ = I(T), J = O(T);
+              return /* @__PURE__ */ N(
+                he,
+                {
+                  coord: T,
+                  value: S(T),
+                  isSelected: V,
+                  isFillTarget: _,
+                  showFillHandle: J && !R,
+                  onMouseDown: h,
+                  onMouseEnter: D,
+                  onChange: k,
+                  onFillHandleMouseDown: H,
+                  styles: u
+                },
+                K
+              );
+            })
+          ] }, p);
+        }) })
       ] })
     }
   );
 }
-function go(o) {
-  const t = typeof o == "string" ? parseFloat(o.replace(/,/g, "")) : o;
-  return isNaN(t) ? "0" : new Intl.NumberFormat("ko-KR").format(t);
+function Re(e) {
+  const o = typeof e == "string" ? parseFloat(e.replace(/,/g, "")) : e;
+  return isNaN(o) ? "0" : new Intl.NumberFormat("ko-KR").format(o);
 }
-function Do(o) {
-  const t = parseInt(o.replace(/,/g, ""), 10);
-  return isNaN(t) ? 0 : t;
+function He(e) {
+  const o = parseInt(e.replace(/,/g, ""), 10);
+  return isNaN(o) ? 0 : o;
 }
 export {
-  Mo as ExcelGrid,
-  so as GridCell,
-  H as cn,
-  Co as coordToKey,
-  go as formatCurrency,
-  So as getCellsInRange,
-  yo as getFillTargetCells,
-  X as isCellInRange,
-  xo as keyToCoord,
-  j as normalizeRange,
-  Do as parseCurrency,
-  _ as parseTSV,
-  J as toTSV,
-  Y as useGridClipboard,
-  oo as useGridDragFill,
-  Q as useGridSelection
+  Ne as ExcelGrid,
+  he as GridCell,
+  W as cn,
+  ke as coordToKey,
+  Re as formatCurrency,
+  ve as getCellsInRange,
+  Fe as getFillTargetCells,
+  Z as isCellInRange,
+  Ee as keyToCoord,
+  B as normalizeRange,
+  He as parseCurrency,
+  ee as parseTSV,
+  te as toTSV,
+  ne as useGridClipboard,
+  re as useGridDragFill,
+  oe as useGridSelection
 };