mytek-components 2.0.4 → 2.0.5

package/dist/main.umd.js

@@ -1,7 +1,10 @@
 (function(global2, factory) {
-  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("react"), require("@emotion/styled"), require("@emotion/react"), require("@mui/material"), require("react-dom")) : typeof define === "function" && define.amd ? define(["exports", "react", "@emotion/styled", "@emotion/react", "@mui/material", "react-dom"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.MytekComponents = {}, global2.React, global2.emotionStyled, global2.emotionReact, global2.MuiMaterial, global2.ReactDOM));
-})(this, (function(exports2, React, emStyled, react, material, ReactDOM) {
-  "use strict";
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("react"), require("@emotion/styled"), require("@emotion/react"), require("@mui/material"), require("react-dom"), require("material-react-table"), require("@mui/x-date-pickers"), require("dayjs"), require("xlsx")) : typeof define === "function" && define.amd ? define(["exports", "react", "@emotion/styled", "@emotion/react", "@mui/material", "react-dom", "material-react-table", "@mui/x-date-pickers", "dayjs", "xlsx"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.MytekComponents = {}, global2.React, global2.emotionStyled, global2.emotionReact, global2.MuiMaterial, global2.ReactDOM, global2.MaterialReactTable, global2.MuiDatePickers, global2.dayjs, global2.XLSX));
+})(this, (function(exports2, React, emStyled, react, material, ReactDOM, materialReactTable, xDatePickers, dayjs, XLSX) {
+  "use strict";var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
   function _interopNamespaceDefault(e) {
     const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
     if (e) {
@@ -19,6 +22,7 @@
     return Object.freeze(n);
   }
   const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
+  const XLSX__namespace = /* @__PURE__ */ _interopNamespaceDefault(XLSX);
   function getDefaultExportFromCjs(x) {
     return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
   }
@@ -631,8 +635,8 @@
     }
     return target;
   }
-  function _extends() {
-    _extends = Object.assign ? Object.assign.bind() : function(target) {
+  function _extends$1() {
+    _extends$1 = Object.assign ? Object.assign.bind() : function(target) {
       for (var i = 1; i < arguments.length; i++) {
         var source = arguments[i];
         for (var key in source) {
@@ -643,7 +647,7 @@
       }
       return target;
     };
-    return _extends.apply(this, arguments);
+    return _extends$1.apply(this, arguments);
   }
   function ownKeys$4(e, r2) {
     var t = Object.keys(e);
@@ -695,7 +699,7 @@
     }, node.attr), Tree2Element(node.child)));
   }
   function GenIcon(data) {
-    return (props) => /* @__PURE__ */ React.createElement(IconBase, _extends({
+    return (props) => /* @__PURE__ */ React.createElement(IconBase, _extends$1({
       attr: _objectSpread$4({}, data.attr)
     }, props), Tree2Element(data.child));
   }
@@ -710,7 +714,7 @@
       var className;
       if (conf.className) className = conf.className;
       if (props.className) className = (className ? className + " " : "") + props.className;
-      return /* @__PURE__ */ React.createElement("svg", _extends({
+      return /* @__PURE__ */ React.createElement("svg", _extends$1({
         stroke: "currentColor",
         fill: "currentColor",
         strokeWidth: "0"
@@ -6489,6 +6493,15 @@ To suppress this warning, you need to explicitly provide the \`palette.${key}Cha
   }
   var classnamesExports = requireClassnames();
   const classNames = /* @__PURE__ */ getDefaultExportFromCjs(classnamesExports);
+  function _extends() {
+    return _extends = Object.assign ? Object.assign.bind() : function(n) {
+      for (var e = 1; e < arguments.length; e++) {
+        var t = arguments[e];
+        for (var r2 in t) ({}).hasOwnProperty.call(t, r2) && (n[r2] = t[r2]);
+      }
+      return n;
+    }, _extends.apply(null, arguments);
+  }
   function _objectWithoutPropertiesLoose$3(r2, e) {
     if (null == r2) return {};
     var t = {};
@@ -15080,7 +15093,7 @@ To suppress this warning, you need to explicitly provide the \`palette.${key}Cha
       onSelectionChange(updated);
     };
     const isAllSelected = data.length > 0 && selectedRows.length === data.length;
-    const formatDate = (value, format = "YYYY-MM-DD") => {
+    const formatDate2 = (value, format = "YYYY-MM-DD") => {
       if (!value) return "";
       const date = new Date(value);
       if (isNaN(date)) return value;
@@ -15273,7 +15286,7 @@ To suppress this warning, you need to explicitly provide the \`palette.${key}Cha
                         checked: selectedRows.includes(rowIndex),
                         onChange: () => handleRowSelect(rowIndex)
                       }
-                    ) : column.key === "__sr_no" ? rowIndex + 1 : column.render ? column.render(row) : column.type === "date" ? formatDate(value, column.format) : column.type === "category" ? /* @__PURE__ */ jsxRuntimeExports.jsx(
+                    ) : column.key === "__sr_no" ? rowIndex + 1 : column.render ? column.render(row) : column.type === "date" ? formatDate2(value, column.format) : column.type === "category" ? /* @__PURE__ */ jsxRuntimeExports.jsx(
                       "span",
                       {
                         className: `
@@ -16441,12 +16454,2133 @@ To suppress this warning, you need to explicitly provide the \`palette.${key}Cha
       )
     ] });
   };
+  /**
+   * @license lucide-react v0.542.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+  const toKebabCase = (string) => string.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+  const toCamelCase = (string) => string.replace(
+    /^([A-Z])|[\s-_]+(\w)/g,
+    (match, p1, p2) => p2 ? p2.toUpperCase() : p1.toLowerCase()
+  );
+  const toPascalCase = (string) => {
+    const camelCase = toCamelCase(string);
+    return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+  };
+  const mergeClasses = (...classes) => classes.filter((className, index, array) => {
+    return Boolean(className) && className.trim() !== "" && array.indexOf(className) === index;
+  }).join(" ").trim();
+  const hasA11yProp = (props) => {
+    for (const prop in props) {
+      if (prop.startsWith("aria-") || prop === "role" || prop === "title") {
+        return true;
+      }
+    }
+  };
+  /**
+   * @license lucide-react v0.542.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+  var defaultAttributes = {
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 24,
+    height: 24,
+    viewBox: "0 0 24 24",
+    fill: "none",
+    stroke: "currentColor",
+    strokeWidth: 2,
+    strokeLinecap: "round",
+    strokeLinejoin: "round"
+  };
+  /**
+   * @license lucide-react v0.542.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+  const Icon = React.forwardRef(
+    ({
+      color: color2 = "currentColor",
+      size = 24,
+      strokeWidth = 2,
+      absoluteStrokeWidth,
+      className = "",
+      children,
+      iconNode,
+      ...rest
+    }, ref) => React.createElement(
+      "svg",
+      {
+        ref,
+        ...defaultAttributes,
+        width: size,
+        height: size,
+        stroke: color2,
+        strokeWidth: absoluteStrokeWidth ? Number(strokeWidth) * 24 / Number(size) : strokeWidth,
+        className: mergeClasses("lucide", className),
+        ...!children && !hasA11yProp(rest) && { "aria-hidden": "true" },
+        ...rest
+      },
+      [
+        ...iconNode.map(([tag, attrs]) => React.createElement(tag, attrs)),
+        ...Array.isArray(children) ? children : [children]
+      ]
+    )
+  );
+  /**
+   * @license lucide-react v0.542.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+  const createLucideIcon = (iconName, iconNode) => {
+    const Component = React.forwardRef(
+      ({ className, ...props }, ref) => React.createElement(Icon, {
+        ref,
+        iconNode,
+        className: mergeClasses(
+          `lucide-${toKebabCase(toPascalCase(iconName))}`,
+          `lucide-${iconName}`,
+          className
+        ),
+        ...props
+      })
+    );
+    Component.displayName = toPascalCase(iconName);
+    return Component;
+  };
+  /**
+   * @license lucide-react v0.542.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+  const __iconNode$4 = [
+    ["path", { d: "M12 15V3", key: "m9g1x1" }],
+    ["path", { d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4", key: "ih7n3h" }],
+    ["path", { d: "m7 10 5 5 5-5", key: "brsn70" }]
+  ];
+  const Download = createLucideIcon("download", __iconNode$4);
+  /**
+   * @license lucide-react v0.542.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+  const __iconNode$3 = [
+    [
+      "path",
+      {
+        d: "M10 20a1 1 0 0 0 .553.895l2 1A1 1 0 0 0 14 21v-7a2 2 0 0 1 .517-1.341L21.74 4.67A1 1 0 0 0 21 3H3a1 1 0 0 0-.742 1.67l7.225 7.989A2 2 0 0 1 10 14z",
+        key: "sc7q7i"
+      }
+    ]
+  ];
+  const Funnel = createLucideIcon("funnel", __iconNode$3);
+  /**
+   * @license lucide-react v0.542.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+  const __iconNode$2 = [
+    ["path", { d: "m8 11 2 2 4-4", key: "1sed1v" }],
+    ["circle", { cx: "11", cy: "11", r: "8", key: "4ej97u" }],
+    ["path", { d: "m21 21-4.3-4.3", key: "1qie3q" }]
+  ];
+  const SearchCheck = createLucideIcon("search-check", __iconNode$2);
+  /**
+   * @license lucide-react v0.542.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+  const __iconNode$1 = [
+    ["rect", { width: "18", height: "18", x: "3", y: "3", rx: "2", ry: "2", key: "1m3agn" }],
+    ["line", { x1: "3", x2: "21", y1: "9", y2: "9", key: "1vqk6q" }],
+    ["line", { x1: "3", x2: "21", y1: "15", y2: "15", key: "o2sbyz" }],
+    ["line", { x1: "9", x2: "9", y1: "9", y2: "21", key: "1ib60c" }],
+    ["line", { x1: "15", x2: "15", y1: "9", y2: "21", key: "1n26ft" }]
+  ];
+  const Sheet = createLucideIcon("sheet", __iconNode$1);
+  /**
+   * @license lucide-react v0.542.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+  const __iconNode = [
+    ["path", { d: "M12 3v18", key: "108xh3" }],
+    ["rect", { width: "18", height: "18", x: "3", y: "3", rx: "2", key: "afitv7" }],
+    ["path", { d: "M3 9h18", key: "1pudct" }],
+    ["path", { d: "M3 15h18", key: "5xshup" }]
+  ];
+  const Table = createLucideIcon("table", __iconNode);
+  var weekOfYear$1 = { exports: {} };
+  var weekOfYear = weekOfYear$1.exports;
+  var hasRequiredWeekOfYear;
+  function requireWeekOfYear() {
+    if (hasRequiredWeekOfYear) return weekOfYear$1.exports;
+    hasRequiredWeekOfYear = 1;
+    (function(module2, exports$1) {
+      !(function(e, t) {
+        module2.exports = t();
+      })(weekOfYear, (function() {
+        var e = "week", t = "year";
+        return function(i, n, r2) {
+          var f = n.prototype;
+          f.week = function(i2) {
+            if (void 0 === i2 && (i2 = null), null !== i2) return this.add(7 * (i2 - this.week()), "day");
+            var n2 = this.$locale().yearStart || 1;
+            if (11 === this.month() && this.date() > 25) {
+              var f2 = r2(this).startOf(t).add(1, t).date(n2), s = r2(this).endOf(e);
+              if (f2.isBefore(s)) return 1;
+            }
+            var a = r2(this).startOf(t).date(n2).startOf(e).subtract(1, "millisecond"), o = this.diff(a, e, true);
+            return o < 0 ? r2(this).startOf("week").week() : Math.ceil(o);
+          }, f.weeks = function(e2) {
+            return void 0 === e2 && (e2 = null), this.week(e2);
+          };
+        };
+      }));
+    })(weekOfYear$1);
+    return weekOfYear$1.exports;
+  }
+  var weekOfYearExports = requireWeekOfYear();
+  const weekOfYearPlugin = /* @__PURE__ */ getDefaultExportFromCjs(weekOfYearExports);
+  var customParseFormat$1 = { exports: {} };
+  var customParseFormat = customParseFormat$1.exports;
+  var hasRequiredCustomParseFormat;
+  function requireCustomParseFormat() {
+    if (hasRequiredCustomParseFormat) return customParseFormat$1.exports;
+    hasRequiredCustomParseFormat = 1;
+    (function(module2, exports$1) {
+      !(function(e, t) {
+        module2.exports = t();
+      })(customParseFormat, (function() {
+        var e = { LTS: "h:mm:ss A", LT: "h:mm A", L: "MM/DD/YYYY", LL: "MMMM D, YYYY", LLL: "MMMM D, YYYY h:mm A", LLLL: "dddd, MMMM D, YYYY h:mm A" }, t = /(\[[^[]*\])|([-_:/.,()\s]+)|(A|a|Q|YYYY|YY?|ww?|MM?M?M?|Do|DD?|hh?|HH?|mm?|ss?|S{1,3}|z|ZZ?)/g, n = /\d/, r2 = /\d\d/, i = /\d\d?/, o = /\d*[^-_:/,()\s\d]+/, s = {}, a = function(e2) {
+          return (e2 = +e2) + (e2 > 68 ? 1900 : 2e3);
+        };
+        var f = function(e2) {
+          return function(t2) {
+            this[e2] = +t2;
+          };
+        }, h = [/[+-]\d\d:?(\d\d)?|Z/, function(e2) {
+          (this.zone || (this.zone = {})).offset = (function(e3) {
+            if (!e3) return 0;
+            if ("Z" === e3) return 0;
+            var t2 = e3.match(/([+-]|\d\d)/g), n2 = 60 * t2[1] + (+t2[2] || 0);
+            return 0 === n2 ? 0 : "+" === t2[0] ? -n2 : n2;
+          })(e2);
+        }], u = function(e2) {
+          var t2 = s[e2];
+          return t2 && (t2.indexOf ? t2 : t2.s.concat(t2.f));
+        }, d = function(e2, t2) {
+          var n2, r3 = s.meridiem;
+          if (r3) {
+            for (var i2 = 1; i2 <= 24; i2 += 1) if (e2.indexOf(r3(i2, 0, t2)) > -1) {
+              n2 = i2 > 12;
+              break;
+            }
+          } else n2 = e2 === (t2 ? "pm" : "PM");
+          return n2;
+        }, c = { A: [o, function(e2) {
+          this.afternoon = d(e2, false);
+        }], a: [o, function(e2) {
+          this.afternoon = d(e2, true);
+        }], Q: [n, function(e2) {
+          this.month = 3 * (e2 - 1) + 1;
+        }], S: [n, function(e2) {
+          this.milliseconds = 100 * +e2;
+        }], SS: [r2, function(e2) {
+          this.milliseconds = 10 * +e2;
+        }], SSS: [/\d{3}/, function(e2) {
+          this.milliseconds = +e2;
+        }], s: [i, f("seconds")], ss: [i, f("seconds")], m: [i, f("minutes")], mm: [i, f("minutes")], H: [i, f("hours")], h: [i, f("hours")], HH: [i, f("hours")], hh: [i, f("hours")], D: [i, f("day")], DD: [r2, f("day")], Do: [o, function(e2) {
+          var t2 = s.ordinal, n2 = e2.match(/\d+/);
+          if (this.day = n2[0], t2) for (var r3 = 1; r3 <= 31; r3 += 1) t2(r3).replace(/\[|\]/g, "") === e2 && (this.day = r3);
+        }], w: [i, f("week")], ww: [r2, f("week")], M: [i, f("month")], MM: [r2, f("month")], MMM: [o, function(e2) {
+          var t2 = u("months"), n2 = (u("monthsShort") || t2.map((function(e3) {
+            return e3.slice(0, 3);
+          }))).indexOf(e2) + 1;
+          if (n2 < 1) throw new Error();
+          this.month = n2 % 12 || n2;
+        }], MMMM: [o, function(e2) {
+          var t2 = u("months").indexOf(e2) + 1;
+          if (t2 < 1) throw new Error();
+          this.month = t2 % 12 || t2;
+        }], Y: [/[+-]?\d+/, f("year")], YY: [r2, function(e2) {
+          this.year = a(e2);
+        }], YYYY: [/\d{4}/, f("year")], Z: h, ZZ: h };
+        function l(n2) {
+          var r3, i2;
+          r3 = n2, i2 = s && s.formats;
+          for (var o2 = (n2 = r3.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g, (function(t2, n3, r4) {
+            var o3 = r4 && r4.toUpperCase();
+            return n3 || i2[r4] || e[r4] || i2[o3].replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, (function(e2, t3, n4) {
+              return t3 || n4.slice(1);
+            }));
+          }))).match(t), a2 = o2.length, f2 = 0; f2 < a2; f2 += 1) {
+            var h2 = o2[f2], u2 = c[h2], d2 = u2 && u2[0], l2 = u2 && u2[1];
+            o2[f2] = l2 ? { regex: d2, parser: l2 } : h2.replace(/^\[|\]$/g, "");
+          }
+          return function(e2) {
+            for (var t2 = {}, n3 = 0, r4 = 0; n3 < a2; n3 += 1) {
+              var i3 = o2[n3];
+              if ("string" == typeof i3) r4 += i3.length;
+              else {
+                var s2 = i3.regex, f3 = i3.parser, h3 = e2.slice(r4), u3 = s2.exec(h3)[0];
+                f3.call(t2, u3), e2 = e2.replace(u3, "");
+              }
+            }
+            return (function(e3) {
+              var t3 = e3.afternoon;
+              if (void 0 !== t3) {
+                var n4 = e3.hours;
+                t3 ? n4 < 12 && (e3.hours += 12) : 12 === n4 && (e3.hours = 0), delete e3.afternoon;
+              }
+            })(t2), t2;
+          };
+        }
+        return function(e2, t2, n2) {
+          n2.p.customParseFormat = true, e2 && e2.parseTwoDigitYear && (a = e2.parseTwoDigitYear);
+          var r3 = t2.prototype, i2 = r3.parse;
+          r3.parse = function(e3) {
+            var t3 = e3.date, r4 = e3.utc, o2 = e3.args;
+            this.$u = r4;
+            var a2 = o2[1];
+            if ("string" == typeof a2) {
+              var f2 = true === o2[2], h2 = true === o2[3], u2 = f2 || h2, d2 = o2[2];
+              h2 && (d2 = o2[2]), s = this.$locale(), !f2 && d2 && (s = n2.Ls[d2]), this.$d = (function(e4, t4, n3, r5) {
+                try {
+                  if (["x", "X"].indexOf(t4) > -1) return new Date(("X" === t4 ? 1e3 : 1) * e4);
+                  var i3 = l(t4)(e4), o3 = i3.year, s2 = i3.month, a3 = i3.day, f3 = i3.hours, h3 = i3.minutes, u3 = i3.seconds, d3 = i3.milliseconds, c3 = i3.zone, m2 = i3.week, M2 = /* @__PURE__ */ new Date(), Y = a3 || (o3 || s2 ? 1 : M2.getDate()), p = o3 || M2.getFullYear(), v = 0;
+                  o3 && !s2 || (v = s2 > 0 ? s2 - 1 : M2.getMonth());
+                  var D, w = f3 || 0, g = h3 || 0, y = u3 || 0, L = d3 || 0;
+                  return c3 ? new Date(Date.UTC(p, v, Y, w, g, y, L + 60 * c3.offset * 1e3)) : n3 ? new Date(Date.UTC(p, v, Y, w, g, y, L)) : (D = new Date(p, v, Y, w, g, y, L), m2 && (D = r5(D).week(m2).toDate()), D);
+                } catch (e5) {
+                  return /* @__PURE__ */ new Date("");
+                }
+              })(t3, a2, r4, n2), this.init(), d2 && true !== d2 && (this.$L = this.locale(d2).$L), u2 && t3 != this.format(a2) && (this.$d = /* @__PURE__ */ new Date("")), s = {};
+            } else if (a2 instanceof Array) for (var c2 = a2.length, m = 1; m <= c2; m += 1) {
+              o2[1] = a2[m - 1];
+              var M = n2.apply(this, o2);
+              if (M.isValid()) {
+                this.$d = M.$d, this.$L = M.$L, this.init();
+                break;
+              }
+              m === c2 && (this.$d = /* @__PURE__ */ new Date(""));
+            }
+            else i2.call(this, e3);
+          };
+        };
+      }));
+    })(customParseFormat$1);
+    return customParseFormat$1.exports;
+  }
+  var customParseFormatExports = requireCustomParseFormat();
+  const customParseFormatPlugin = /* @__PURE__ */ getDefaultExportFromCjs(customParseFormatExports);
+  var localizedFormat$1 = { exports: {} };
+  var localizedFormat = localizedFormat$1.exports;
+  var hasRequiredLocalizedFormat;
+  function requireLocalizedFormat() {
+    if (hasRequiredLocalizedFormat) return localizedFormat$1.exports;
+    hasRequiredLocalizedFormat = 1;
+    (function(module2, exports$1) {
+      !(function(e, t) {
+        module2.exports = t();
+      })(localizedFormat, (function() {
+        var e = { LTS: "h:mm:ss A", LT: "h:mm A", L: "MM/DD/YYYY", LL: "MMMM D, YYYY", LLL: "MMMM D, YYYY h:mm A", LLLL: "dddd, MMMM D, YYYY h:mm A" };
+        return function(t, o, n) {
+          var r2 = o.prototype, i = r2.format;
+          n.en.formats = e, r2.format = function(t2) {
+            void 0 === t2 && (t2 = "YYYY-MM-DDTHH:mm:ssZ");
+            var o2 = this.$locale().formats, n2 = (function(t3, o3) {
+              return t3.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g, (function(t4, n3, r3) {
+                var i2 = r3 && r3.toUpperCase();
+                return n3 || o3[r3] || e[r3] || o3[i2].replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, (function(e2, t5, o4) {
+                  return t5 || o4.slice(1);
+                }));
+              }));
+            })(t2, void 0 === o2 ? {} : o2);
+            return i.call(this, n2);
+          };
+        };
+      }));
+    })(localizedFormat$1);
+    return localizedFormat$1.exports;
+  }
+  var localizedFormatExports = requireLocalizedFormat();
+  const localizedFormatPlugin = /* @__PURE__ */ getDefaultExportFromCjs(localizedFormatExports);
+  var isBetween$1 = { exports: {} };
+  var isBetween = isBetween$1.exports;
+  var hasRequiredIsBetween;
+  function requireIsBetween() {
+    if (hasRequiredIsBetween) return isBetween$1.exports;
+    hasRequiredIsBetween = 1;
+    (function(module2, exports$1) {
+      !(function(e, i) {
+        module2.exports = i();
+      })(isBetween, (function() {
+        return function(e, i, t) {
+          i.prototype.isBetween = function(e2, i2, s, f) {
+            var n = t(e2), o = t(i2), r2 = "(" === (f = f || "()")[0], u = ")" === f[1];
+            return (r2 ? this.isAfter(n, s) : !this.isBefore(n, s)) && (u ? this.isBefore(o, s) : !this.isAfter(o, s)) || (r2 ? this.isBefore(n, s) : !this.isAfter(n, s)) && (u ? this.isAfter(o, s) : !this.isBefore(o, s));
+          };
+        };
+      }));
+    })(isBetween$1);
+    return isBetween$1.exports;
+  }
+  var isBetweenExports = requireIsBetween();
+  const isBetweenPlugin = /* @__PURE__ */ getDefaultExportFromCjs(isBetweenExports);
+  var advancedFormat$1 = { exports: {} };
+  var advancedFormat = advancedFormat$1.exports;
+  var hasRequiredAdvancedFormat;
+  function requireAdvancedFormat() {
+    if (hasRequiredAdvancedFormat) return advancedFormat$1.exports;
+    hasRequiredAdvancedFormat = 1;
+    (function(module2, exports$1) {
+      !(function(e, t) {
+        module2.exports = t();
+      })(advancedFormat, (function() {
+        return function(e, t) {
+          var r2 = t.prototype, n = r2.format;
+          r2.format = function(e2) {
+            var t2 = this, r3 = this.$locale();
+            if (!this.isValid()) return n.bind(this)(e2);
+            var s = this.$utils(), a = (e2 || "YYYY-MM-DDTHH:mm:ssZ").replace(/\[([^\]]+)]|Q|wo|ww|w|WW|W|zzz|z|gggg|GGGG|Do|X|x|k{1,2}|S/g, (function(e3) {
+              switch (e3) {
+                case "Q":
+                  return Math.ceil((t2.$M + 1) / 3);
+                case "Do":
+                  return r3.ordinal(t2.$D);
+                case "gggg":
+                  return t2.weekYear();
+                case "GGGG":
+                  return t2.isoWeekYear();
+                case "wo":
+                  return r3.ordinal(t2.week(), "W");
+                case "w":
+                case "ww":
+                  return s.s(t2.week(), "w" === e3 ? 1 : 2, "0");
+                case "W":
+                case "WW":
+                  return s.s(t2.isoWeek(), "W" === e3 ? 1 : 2, "0");
+                case "k":
+                case "kk":
+                  return s.s(String(0 === t2.$H ? 24 : t2.$H), "k" === e3 ? 1 : 2, "0");
+                case "X":
+                  return Math.floor(t2.$d.getTime() / 1e3);
+                case "x":
+                  return t2.$d.getTime();
+                case "z":
+                  return "[" + t2.offsetName() + "]";
+                case "zzz":
+                  return "[" + t2.offsetName("long") + "]";
+                default:
+                  return e3;
+              }
+            }));
+            return n.bind(this)(a);
+          };
+        };
+      }));
+    })(advancedFormat$1);
+    return advancedFormat$1.exports;
+  }
+  var advancedFormatExports = requireAdvancedFormat();
+  const advancedFormatPlugin = /* @__PURE__ */ getDefaultExportFromCjs(advancedFormatExports);
+  const warnedOnceCache = /* @__PURE__ */ new Set();
+  function warnOnce(message, gravity = "warning") {
+    if (process.env.NODE_ENV === "production") {
+      return;
+    }
+    const cleanMessage = Array.isArray(message) ? message.join("\n") : message;
+    if (!warnedOnceCache.has(cleanMessage)) {
+      warnedOnceCache.add(cleanMessage);
+      if (gravity === "error") {
+        console.error(cleanMessage);
+      } else {
+        console.warn(cleanMessage);
+      }
+    }
+  }
+  dayjs.extend(localizedFormatPlugin);
+  dayjs.extend(weekOfYearPlugin);
+  dayjs.extend(isBetweenPlugin);
+  dayjs.extend(advancedFormatPlugin);
+  const formatTokenMap = {
+    // Year
+    YY: "year",
+    YYYY: {
+      sectionType: "year",
+      contentType: "digit",
+      maxLength: 4
+    },
+    // Month
+    M: {
+      sectionType: "month",
+      contentType: "digit",
+      maxLength: 2
+    },
+    MM: "month",
+    MMM: {
+      sectionType: "month",
+      contentType: "letter"
+    },
+    MMMM: {
+      sectionType: "month",
+      contentType: "letter"
+    },
+    // Day of the month
+    D: {
+      sectionType: "day",
+      contentType: "digit",
+      maxLength: 2
+    },
+    DD: "day",
+    Do: {
+      sectionType: "day",
+      contentType: "digit-with-letter"
+    },
+    // Day of the week
+    d: {
+      sectionType: "weekDay",
+      contentType: "digit",
+      maxLength: 2
+    },
+    dd: {
+      sectionType: "weekDay",
+      contentType: "letter"
+    },
+    ddd: {
+      sectionType: "weekDay",
+      contentType: "letter"
+    },
+    dddd: {
+      sectionType: "weekDay",
+      contentType: "letter"
+    },
+    // Meridiem
+    A: "meridiem",
+    a: "meridiem",
+    // Hours
+    H: {
+      sectionType: "hours",
+      contentType: "digit",
+      maxLength: 2
+    },
+    HH: "hours",
+    h: {
+      sectionType: "hours",
+      contentType: "digit",
+      maxLength: 2
+    },
+    hh: "hours",
+    // Minutes
+    m: {
+      sectionType: "minutes",
+      contentType: "digit",
+      maxLength: 2
+    },
+    mm: "minutes",
+    // Seconds
+    s: {
+      sectionType: "seconds",
+      contentType: "digit",
+      maxLength: 2
+    },
+    ss: "seconds"
+  };
+  const defaultFormats = {
+    year: "YYYY",
+    month: "MMMM",
+    monthShort: "MMM",
+    dayOfMonth: "D",
+    dayOfMonthFull: "Do",
+    weekday: "dddd",
+    weekdayShort: "dd",
+    hours24h: "HH",
+    hours12h: "hh",
+    meridiem: "A",
+    minutes: "mm",
+    seconds: "ss",
+    fullDate: "ll",
+    keyboardDate: "L",
+    shortDate: "MMM D",
+    normalDate: "D MMMM",
+    normalDateWithWeekday: "ddd, MMM D",
+    fullTime12h: "hh:mm A",
+    fullTime24h: "HH:mm",
+    keyboardDateTime12h: "L hh:mm A",
+    keyboardDateTime24h: "L HH:mm"
+  };
+  const MISSING_UTC_PLUGIN = ["Missing UTC plugin", "To be able to use UTC or timezones, you have to enable the `utc` plugin", "Find more information on https://mui.com/x/react-date-pickers/timezone/#day-js-and-utc"].join("\n");
+  const MISSING_TIMEZONE_PLUGIN = ["Missing timezone plugin", "To be able to use timezones, you have to enable both the `utc` and the `timezone` plugin", "Find more information on https://mui.com/x/react-date-pickers/timezone/#day-js-and-timezone"].join("\n");
+  class AdapterDayjs {
+    constructor({
+      locale,
+      formats
+    } = {}) {
+      __publicField(this, "isMUIAdapter", true);
+      __publicField(this, "isTimezoneCompatible", true);
+      __publicField(this, "lib", "dayjs");
+      __publicField(this, "escapedCharacters", {
+        start: "[",
+        end: "]"
+      });
+      __publicField(this, "formatTokenMap", /* @__PURE__ */ (() => formatTokenMap)());
+      __publicField(this, "setLocaleToValue", (value) => {
+        const expectedLocale = this.getCurrentLocaleCode();
+        if (expectedLocale === value.locale()) {
+          return value;
+        }
+        return value.locale(expectedLocale);
+      });
+      __publicField(this, "hasUTCPlugin", () => typeof dayjs.utc !== "undefined");
+      __publicField(this, "hasTimezonePlugin", () => typeof dayjs.tz !== "undefined");
+      __publicField(this, "isSame", (value, comparing, comparisonTemplate) => {
+        const comparingInValueTimezone = this.setTimezone(comparing, this.getTimezone(value));
+        return value.format(comparisonTemplate) === comparingInValueTimezone.format(comparisonTemplate);
+      });
+      /**
+       * Replaces "default" by undefined and "system" by the system timezone before passing it to `dayjs`.
+       */
+      __publicField(this, "cleanTimezone", (timezone) => {
+        switch (timezone) {
+          case "default": {
+            return void 0;
+          }
+          case "system": {
+            return dayjs.tz.guess();
+          }
+          default: {
+            return timezone;
+          }
+        }
+      });
+      __publicField(this, "createSystemDate", (value) => {
+        let date;
+        if (this.hasUTCPlugin() && this.hasTimezonePlugin()) {
+          const timezone = dayjs.tz.guess();
+          if (timezone === "UTC") {
+            date = dayjs(value);
+          } else {
+            date = dayjs.tz(value, timezone);
+          }
+        } else {
+          date = dayjs(value);
+        }
+        return this.setLocaleToValue(date);
+      });
+      __publicField(this, "createUTCDate", (value) => {
+        if (!this.hasUTCPlugin()) {
+          throw new Error(MISSING_UTC_PLUGIN);
+        }
+        return this.setLocaleToValue(dayjs.utc(value));
+      });
+      __publicField(this, "createTZDate", (value, timezone) => {
+        if (!this.hasUTCPlugin()) {
+          throw new Error(MISSING_UTC_PLUGIN);
+        }
+        if (!this.hasTimezonePlugin()) {
+          throw new Error(MISSING_TIMEZONE_PLUGIN);
+        }
+        const keepLocalTime = value !== void 0 && !value.endsWith("Z");
+        return this.setLocaleToValue(dayjs(value).tz(this.cleanTimezone(timezone), keepLocalTime));
+      });
+      __publicField(this, "getLocaleFormats", () => {
+        const locales = dayjs.Ls;
+        const locale = this.locale || "en";
+        let localeObject = locales[locale];
+        if (localeObject === void 0) {
+          if (process.env.NODE_ENV !== "production") {
+            warnOnce(["MUI X: Your locale has not been found.", "Either the locale key is not a supported one. Locales supported by dayjs are available here: https://github.com/iamkun/dayjs/tree/dev/src/locale.", "Or you forget to import the locale from 'dayjs/locale/{localeUsed}'", "fallback on English locale."]);
+          }
+          localeObject = locales.en;
+        }
+        return localeObject.formats;
+      });
+      /**
+       * If the new day does not have the same offset as the old one (when switching to summer day time for example),
+       * Then dayjs will not automatically adjust the offset (moment does).
+       * We have to parse again the value to make sure the `fixOffset` method is applied.
+       * See https://github.com/iamkun/dayjs/blob/b3624de619d6e734cd0ffdbbd3502185041c1b60/src/plugin/timezone/index.js#L72
+       */
+      __publicField(this, "adjustOffset", (value) => {
+        if (!this.hasTimezonePlugin()) {
+          return value;
+        }
+        const timezone = this.getTimezone(value);
+        if (timezone !== "UTC") {
+          const fixedValue = value.tz(this.cleanTimezone(timezone), true);
+          if (fixedValue.$offset === (value.$offset ?? 0)) {
+            return value;
+          }
+          value.$offset = fixedValue.$offset;
+        }
+        return value;
+      });
+      __publicField(this, "date", (value, timezone = "default") => {
+        if (value === null) {
+          return null;
+        }
+        if (timezone === "UTC") {
+          return this.createUTCDate(value);
+        }
+        if (timezone === "system" || timezone === "default" && !this.hasTimezonePlugin()) {
+          return this.createSystemDate(value);
+        }
+        return this.createTZDate(value, timezone);
+      });
+      __publicField(this, "getInvalidDate", () => dayjs(/* @__PURE__ */ new Date("Invalid date")));
+      __publicField(this, "getTimezone", (value) => {
+        var _a;
+        if (this.hasTimezonePlugin()) {
+          const zone = (_a = value.$x) == null ? void 0 : _a.$timezone;
+          if (zone) {
+            return zone;
+          }
+        }
+        if (this.hasUTCPlugin() && value.isUTC()) {
+          return "UTC";
+        }
+        return "system";
+      });
+      __publicField(this, "setTimezone", (value, timezone) => {
+        if (this.getTimezone(value) === timezone) {
+          return value;
+        }
+        if (timezone === "UTC") {
+          if (!this.hasUTCPlugin()) {
+            throw new Error(MISSING_UTC_PLUGIN);
+          }
+          return value.utc();
+        }
+        if (timezone === "system") {
+          return value.local();
+        }
+        if (!this.hasTimezonePlugin()) {
+          if (timezone === "default") {
+            return value;
+          }
+          throw new Error(MISSING_TIMEZONE_PLUGIN);
+        }
+        return this.setLocaleToValue(dayjs.tz(value, this.cleanTimezone(timezone)));
+      });
+      __publicField(this, "toJsDate", (value) => {
+        return value.toDate();
+      });
+      __publicField(this, "parse", (value, format) => {
+        if (value === "") {
+          return null;
+        }
+        return dayjs(value, format, this.locale, true);
+      });
+      __publicField(this, "getCurrentLocaleCode", () => {
+        return this.locale || "en";
+      });
+      __publicField(this, "is12HourCycleInCurrentLocale", () => {
+        return /A|a/.test(this.getLocaleFormats().LT || "");
+      });
+      __publicField(this, "expandFormat", (format) => {
+        const localeFormats = this.getLocaleFormats();
+        const t = (formatBis) => formatBis.replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, (_, a, b) => a || b.slice(1));
+        return format.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g, (_, a, b) => {
+          const B = b && b.toUpperCase();
+          return a || localeFormats[b] || t(localeFormats[B]);
+        });
+      });
+      __publicField(this, "isValid", (value) => {
+        if (value == null) {
+          return false;
+        }
+        return value.isValid();
+      });
+      __publicField(this, "format", (value, formatKey) => {
+        return this.formatByString(value, this.formats[formatKey]);
+      });
+      __publicField(this, "formatByString", (value, formatString) => {
+        return this.setLocaleToValue(value).format(formatString);
+      });
+      __publicField(this, "formatNumber", (numberToFormat) => {
+        return numberToFormat;
+      });
+      __publicField(this, "isEqual", (value, comparing) => {
+        if (value === null && comparing === null) {
+          return true;
+        }
+        if (value === null || comparing === null) {
+          return false;
+        }
+        return value.toDate().getTime() === comparing.toDate().getTime();
+      });
+      __publicField(this, "isSameYear", (value, comparing) => {
+        return this.isSame(value, comparing, "YYYY");
+      });
+      __publicField(this, "isSameMonth", (value, comparing) => {
+        return this.isSame(value, comparing, "YYYY-MM");
+      });
+      __publicField(this, "isSameDay", (value, comparing) => {
+        return this.isSame(value, comparing, "YYYY-MM-DD");
+      });
+      __publicField(this, "isSameHour", (value, comparing) => {
+        return value.isSame(comparing, "hour");
+      });
+      __publicField(this, "isAfter", (value, comparing) => {
+        return value > comparing;
+      });
+      __publicField(this, "isAfterYear", (value, comparing) => {
+        if (!this.hasUTCPlugin()) {
+          return value.isAfter(comparing, "year");
+        }
+        return !this.isSameYear(value, comparing) && value.utc() > comparing.utc();
+      });
+      __publicField(this, "isAfterDay", (value, comparing) => {
+        if (!this.hasUTCPlugin()) {
+          return value.isAfter(comparing, "day");
+        }
+        return !this.isSameDay(value, comparing) && value.utc() > comparing.utc();
+      });
+      __publicField(this, "isBefore", (value, comparing) => {
+        return value < comparing;
+      });
+      __publicField(this, "isBeforeYear", (value, comparing) => {
+        if (!this.hasUTCPlugin()) {
+          return value.isBefore(comparing, "year");
+        }
+        return !this.isSameYear(value, comparing) && value.utc() < comparing.utc();
+      });
+      __publicField(this, "isBeforeDay", (value, comparing) => {
+        if (!this.hasUTCPlugin()) {
+          return value.isBefore(comparing, "day");
+        }
+        return !this.isSameDay(value, comparing) && value.utc() < comparing.utc();
+      });
+      __publicField(this, "isWithinRange", (value, [start2, end2]) => {
+        return value >= start2 && value <= end2;
+      });
+      __publicField(this, "startOfYear", (value) => {
+        return this.adjustOffset(value.startOf("year"));
+      });
+      __publicField(this, "startOfMonth", (value) => {
+        return this.adjustOffset(value.startOf("month"));
+      });
+      __publicField(this, "startOfWeek", (value) => {
+        return this.adjustOffset(this.setLocaleToValue(value).startOf("week"));
+      });
+      __publicField(this, "startOfDay", (value) => {
+        return this.adjustOffset(value.startOf("day"));
+      });
+      __publicField(this, "endOfYear", (value) => {
+        return this.adjustOffset(value.endOf("year"));
+      });
+      __publicField(this, "endOfMonth", (value) => {
+        return this.adjustOffset(value.endOf("month"));
+      });
+      __publicField(this, "endOfWeek", (value) => {
+        return this.adjustOffset(this.setLocaleToValue(value).endOf("week"));
+      });
+      __publicField(this, "endOfDay", (value) => {
+        return this.adjustOffset(value.endOf("day"));
+      });
+      __publicField(this, "addYears", (value, amount) => {
+        return this.adjustOffset(value.add(amount, "year"));
+      });
+      __publicField(this, "addMonths", (value, amount) => {
+        return this.adjustOffset(value.add(amount, "month"));
+      });
+      __publicField(this, "addWeeks", (value, amount) => {
+        return this.adjustOffset(value.add(amount, "week"));
+      });
+      __publicField(this, "addDays", (value, amount) => {
+        return this.adjustOffset(value.add(amount, "day"));
+      });
+      __publicField(this, "addHours", (value, amount) => {
+        return this.adjustOffset(value.add(amount, "hour"));
+      });
+      __publicField(this, "addMinutes", (value, amount) => {
+        return this.adjustOffset(value.add(amount, "minute"));
+      });
+      __publicField(this, "addSeconds", (value, amount) => {
+        return this.adjustOffset(value.add(amount, "second"));
+      });
+      __publicField(this, "getYear", (value) => {
+        return value.year();
+      });
+      __publicField(this, "getMonth", (value) => {
+        return value.month();
+      });
+      __publicField(this, "getDate", (value) => {
+        return value.date();
+      });
+      __publicField(this, "getHours", (value) => {
+        return value.hour();
+      });
+      __publicField(this, "getMinutes", (value) => {
+        return value.minute();
+      });
+      __publicField(this, "getSeconds", (value) => {
+        return value.second();
+      });
+      __publicField(this, "getMilliseconds", (value) => {
+        return value.millisecond();
+      });
+      __publicField(this, "setYear", (value, year) => {
+        return this.adjustOffset(value.set("year", year));
+      });
+      __publicField(this, "setMonth", (value, month) => {
+        return this.adjustOffset(value.set("month", month));
+      });
+      __publicField(this, "setDate", (value, date) => {
+        return this.adjustOffset(value.set("date", date));
+      });
+      __publicField(this, "setHours", (value, hours) => {
+        return this.adjustOffset(value.set("hour", hours));
+      });
+      __publicField(this, "setMinutes", (value, minutes) => {
+        return this.adjustOffset(value.set("minute", minutes));
+      });
+      __publicField(this, "setSeconds", (value, seconds) => {
+        return this.adjustOffset(value.set("second", seconds));
+      });
+      __publicField(this, "setMilliseconds", (value, milliseconds) => {
+        return this.adjustOffset(value.set("millisecond", milliseconds));
+      });
+      __publicField(this, "getDaysInMonth", (value) => {
+        return value.daysInMonth();
+      });
+      __publicField(this, "getWeekArray", (value) => {
+        const start2 = this.startOfWeek(this.startOfMonth(value));
+        const end2 = this.endOfWeek(this.endOfMonth(value));
+        let count = 0;
+        let current = start2;
+        const nestedWeeks = [];
+        while (current < end2) {
+          const weekNumber = Math.floor(count / 7);
+          nestedWeeks[weekNumber] = nestedWeeks[weekNumber] || [];
+          nestedWeeks[weekNumber].push(current);
+          current = this.addDays(current, 1);
+          count += 1;
+        }
+        return nestedWeeks;
+      });
+      __publicField(this, "getWeekNumber", (value) => {
+        return value.week();
+      });
+      __publicField(this, "getYearRange", ([start2, end2]) => {
+        const startDate = this.startOfYear(start2);
+        const endDate = this.endOfYear(end2);
+        const years = [];
+        let current = startDate;
+        while (this.isBefore(current, endDate)) {
+          years.push(current);
+          current = this.addYears(current, 1);
+        }
+        return years;
+      });
+      this.locale = locale;
+      this.formats = _extends({}, defaultFormats, formats);
+      dayjs.extend(customParseFormatPlugin);
+    }
+    getDayOfWeek(value) {
+      return value.day() + 1;
+    }
+  }
+  const DEFAULT_THEME = {
+    headerBg: "#3f5fa3",
+    headerText: "#ffffff",
+    bodyBg: "#ffffff",
+    border: "#cfd6e4"
+  };
+  const percentToGrow = (p) => Math.max(1, Math.round((p || 10) / 10));
+  const MONTHS_SHORT = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ];
+  const pad = (n) => String(n).padStart(2, "0");
+  const isNumericValue = (v) => v !== null && v !== void 0 && v !== "" && !isNaN(v) && typeof v !== "boolean";
+  const isDateValue = (v) => {
+    if (v instanceof Date && !isNaN(v)) return true;
+    if (typeof v === "string") {
+      return /^\d{4}-\d{2}-\d{2}/.test(v) || /^\d{4}\/\d{2}\/\d{2}/.test(v) || /^\d{2}-\d{2}-\d{4}/.test(v);
+    }
+    return false;
+  };
+  const isBooleanValue = (v) => typeof v === "boolean" || v === "true" || v === "false";
+  const formatDate = (value, format = "dd/MM/yyyy") => {
+    if (!value) return "";
+    const d = value instanceof Date ? value : new Date(value);
+    if (isNaN(d)) return "";
+    const dd = pad(d.getDate());
+    const mm = pad(d.getMonth() + 1);
+    const yyyy = d.getFullYear();
+    const MMM = MONTHS_SHORT[d.getMonth()];
+    pad(d.getHours());
+    const hh12 = pad(d.getHours() % 12 || 12);
+    const min2 = pad(d.getMinutes());
+    const ampm = d.getHours() >= 12 ? "PM" : "AM";
+    switch (format) {
+      case "dd/MM/yyyy":
+        return `${dd}/${mm}/${yyyy}`;
+      case "dd-MM-yyyy":
+        return `${dd}-${mm}-${yyyy}`;
+      case "yyyy/MM/dd":
+        return `${yyyy}/${mm}/${dd}`;
+      case "dd-MMM-yyyy":
+        return `${dd}-${MMM}-${yyyy}`;
+      case "dd-MMM-yyyy hh:mm a":
+        return `${dd}-${MMM}-${yyyy} ${hh12}:${min2} ${ampm}`;
+      case "yyyy-MM-dd":
+        return `${yyyy}-${mm}-${dd}`;
+      default:
+        return `${dd}/${mm}/${yyyy}`;
+    }
+  };
+  const CURRENCY_LOCALE_MAP = {
+    INR: "en-IN",
+    USD: "en-US",
+    EUR: "de-DE",
+    GBP: "en-GB",
+    JPY: "ja-JP",
+    AUD: "en-AU",
+    CAD: "en-CA",
+    SGD: "en-SG"
+  };
+  const getLocaleFromCurrency = (currency) => {
+    return CURRENCY_LOCALE_MAP[currency] || "en-IN";
+  };
+  const formatCurrency = ({
+    value,
+    decimal = 0,
+    // 👈 NO DEFAULT
+    currency,
+    showSymbol = false
+  }) => {
+    if (value === null || value === void 0 || value === "") return "";
+    const num = Number(value);
+    if (isNaN(num)) return "";
+    const locale = getLocaleFromCurrency(currency);
+    const options2 = {};
+    if (typeof decimal === "number") {
+      options2.minimumFractionDigits = decimal;
+      options2.maximumFractionDigits = decimal;
+    }
+    if (currency && showSymbol) {
+      options2.style = "currency";
+      options2.currency = currency;
+    }
+    return new Intl.NumberFormat(locale, options2).format(num);
+  };
+  const formatPercentage = ({
+    value,
+    decimal,
+    showSymbol = true
+  }) => {
+    if (value === null || value === void 0 || value === "") return "";
+    const num = Number(value);
+    if (isNaN(num)) return "";
+    const options2 = {};
+    if (typeof decimal === "number") {
+      options2.minimumFractionDigits = decimal;
+      options2.maximumFractionDigits = decimal;
+    }
+    const formatted = new Intl.NumberFormat("en-IN", options2).format(num);
+    return showSymbol ? `${formatted}%` : formatted;
+  };
+  const sanitizeColumns = (columns = []) => {
+    if (!Array.isArray(columns)) return [];
+    return columns.filter((col) => col && typeof col === "object").filter((col) => {
+      if (!col.ColFields || typeof col.ColFields !== "string") return false;
+      if (!col.ColHeading || typeof col.ColHeading !== "string") return false;
+      return true;
+    }).map((col, index) => ({
+      // 🔒 enforce safe defaults
+      ColOrder: typeof col.ColOrder === "number" ? col.ColOrder : index + 1,
+      ...col
+    }));
+  };
+  const getFinancialRange = (fy, quarter) => {
+    const [startYear, endYear] = fy.split("-").map(Number);
+    if (!quarter) {
+      return {
+        start: new Date(startYear, 3, 1),
+        end: new Date(endYear, 2, 31)
+      };
+    }
+    const map = {
+      Q1: [3, 0, startYear],
+      Q2: [6, 0, startYear],
+      Q3: [9, 0, startYear],
+      Q4: [0, 0, endYear]
+    };
+    const [month, day, year] = map[quarter];
+    const start2 = new Date(year, month, 1);
+    const end2 = new Date(year, month + 3, 0);
+    return { start: start2, end: end2 };
+  };
+  function RangeDateFilter({ column, onClose }) {
+    const current = column.getFilterValue() || {};
+    const [from, setFrom] = React.useState(
+      (current == null ? void 0 : current.from) ? dayjs(current.from) : null
+    );
+    const [to, setTo] = React.useState(
+      (current == null ? void 0 : current.to) ? dayjs(current.to) : null
+    );
+    const canApply = Boolean(from && to);
+    const handleApply = () => {
+      column.setFilterValue({
+        mode: "range",
+        from: from.toDate(),
+        // 🔥 convert here
+        to: to.toDate()
+      });
+      onClose == null ? void 0 : onClose();
+    };
+    const handleClear = () => {
+      setFrom(null);
+      setTo(null);
+      column.setFilterValue(void 0);
+      onClose == null ? void 0 : onClose();
+    };
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs(material.Box, { p: 2, width: 240, children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        xDatePickers.DatePicker,
+        {
+          label: "From",
+          value: from,
+          onChange: (v) => {
+            setFrom(v);
+            setTo(null);
+          },
+          slotProps: {
+            textField: {
+              size: "small",
+              // Options: 'small', 'medium'
+              style: { height: "40px", width: "100%" }
+              // Custom height
+            }
+          }
+        }
+      ),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        xDatePickers.DatePicker,
+        {
+          label: "To",
+          value: to,
+          minDate: from,
+          disabled: !from,
+          onChange: (v) => setTo(v),
+          sx: { mt: 2 },
+          slotProps: {
+            textField: {
+              size: "small",
+              // Options: 'small', 'medium'
+              style: { height: "40px", width: "100%" }
+              // Custom height
+            }
+          }
+        }
+      ),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        material.Button,
+        {
+          fullWidth: true,
+          size: "small",
+          variant: "contained",
+          sx: { mt: 1 },
+          disabled: !canApply,
+          onClick: handleApply,
+          children: "Apply"
+        }
+      ),
+      current.from && current.to && /* @__PURE__ */ jsxRuntimeExports.jsx(
+        material.Button,
+        {
+          fullWidth: true,
+          size: "small",
+          sx: { mt: 0.5 },
+          color: "error",
+          onClick: handleClear,
+          children: "Clear"
+        }
+      )
+    ] });
+  }
+  const financialDateFilterFn = (row, columnId, filterValue) => {
+    if (!filterValue) return true;
+    const rowDate = row.getValue(columnId);
+    if (!(rowDate instanceof Date)) return false;
+    const { mode, from, to, fy, quarter } = filterValue;
+    if (mode === "range") {
+      if (from && rowDate < from) return false;
+      if (to && rowDate > to) return false;
+      return true;
+    }
+    if (mode === "financial") {
+      const { start: start2, end: end2 } = getFinancialRange(fy, quarter);
+      return rowDate >= start2 && rowDate <= end2;
+    }
+    return true;
+  };
+  const getFinancialYear = (date) => {
+    const d = date instanceof Date ? date : new Date(date);
+    if (isNaN(d)) return null;
+    const year = d.getFullYear();
+    return d.getMonth() >= 3 ? `${year}-${year + 1}` : `${year - 1}-${year}`;
+  };
+  function FinancialDateFilter({ column, fyOptions = [], closePopover }) {
+    const activeFilter = column.getFilterValue();
+    const [from, setFrom] = React.useState(
+      (activeFilter == null ? void 0 : activeFilter.from) ? dayjs(activeFilter.from) : null
+    );
+    const [to, setTo] = React.useState(
+      (activeFilter == null ? void 0 : activeFilter.to) ? dayjs(activeFilter.to) : null
+    );
+    const [fy, setFy] = React.useState((activeFilter == null ? void 0 : activeFilter.fy) || "");
+    const [quarter, setQuarter] = React.useState((activeFilter == null ? void 0 : activeFilter.quarter) || "");
+    const isManual = !fy;
+    const isFinancial = Boolean(fy);
+    const apply = () => {
+      if (isFinancial) {
+        const { start: start2, end: end2 } = getFinancialRange(fy, quarter || null);
+        column.setFilterValue({
+          mode: "financial",
+          fy,
+          quarter: quarter || null,
+          from: start2,
+          // Date
+          to: end2
+          // Date
+        });
+        closePopover();
+        return;
+      }
+      if (from && to) {
+        column.setFilterValue({
+          mode: "range",
+          from: from.toDate(),
+          // ✅ convert HERE only
+          to: to.toDate()
+        });
+        closePopover();
+      }
+    };
+    const clear = () => {
+      column.setFilterValue(void 0);
+      setFrom(null);
+      setTo(null);
+      setFy("");
+      setQuarter("");
+      closePopover();
+    };
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs(material.Box, { p: 2, width: 240, children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        xDatePickers.DatePicker,
+        {
+          label: "From",
+          value: from,
+          disabled: !isManual,
+          onChange: (v) => {
+            setFrom(v);
+            setTo(null);
+          },
+          slotProps: {
+            textField: {
+              size: "small",
+              // Options: 'small', 'medium'
+              style: { height: "40px", width: "100%" }
+              // Custom height
+            }
+          }
+        }
+      ),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        xDatePickers.DatePicker,
+        {
+          sx: { mt: 2 },
+          label: "To",
+          value: to,
+          minDate: from,
+          disabled: !isManual || !from,
+          onChange: (v) => setTo(v),
+          slotProps: {
+            textField: {
+              size: "small",
+              // Options: 'small', 'medium'
+              style: { height: "40px", width: "100%" }
+              // Custom height
+            }
+          }
+        }
+      ),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs(
+        material.Select,
+        {
+          fullWidth: true,
+          value: fy,
+          onChange: (e) => {
+            setFy(e.target.value);
+            setQuarter("");
+            setFrom(null);
+            setTo(null);
+          },
+          sx: { mt: 1 },
+          displayEmpty: true,
+          size: "small",
+          children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx(material.MenuItem, { value: "", children: "Financial Year" }),
+            fyOptions.map((y) => /* @__PURE__ */ jsxRuntimeExports.jsx(material.MenuItem, { value: y, children: y }, y))
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs(
+        material.Select,
+        {
+          fullWidth: true,
+          disabled: !fy,
+          value: quarter,
+          onChange: (e) => setQuarter(e.target.value),
+          sx: { mt: 1 },
+          displayEmpty: true,
+          size: "small",
+          children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx(material.MenuItem, { value: "", disabled: true, children: "Quarter" }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(material.MenuItem, { value: "Q1", children: "Q1 (Apr–Jun)" }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(material.MenuItem, { value: "Q2", children: "Q2 (Jul–Sep)" }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(material.MenuItem, { value: "Q3", children: "Q3 (Oct–Dec)" }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(material.MenuItem, { value: "Q4", children: "Q4 (Jan–Mar)" })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        material.Button,
+        {
+          fullWidth: true,
+          variant: "contained",
+          sx: { mt: 1 },
+          disabled: !(isFinancial || from && to),
+          onClick: apply,
+          children: "APPLY"
+        }
+      ),
+      activeFilter && /* @__PURE__ */ jsxRuntimeExports.jsx(
+        material.Button,
+        {
+          fullWidth: true,
+          color: "error",
+          sx: { mt: 1 },
+          onClick: clear,
+          children: "CLEAR"
+        }
+      )
+    ] });
+  }
+  function DateFilterHeader({ title, column, mode, fyOptions = [] }) {
+    const [anchorEl, setAnchorEl] = React.useState(null);
+    const open = Boolean(anchorEl);
+    const filterValue = column.getFilterValue();
+    const hasFilter = filterValue && (filterValue.mode === "range" && filterValue.from && filterValue.to || filterValue.mode === "financial" && filterValue.fy);
+    const tooltipText = (() => {
+      if (!hasFilter) return "";
+      if (filterValue.mode === "range") {
+        return `${filterValue.from.toLocaleDateString()} → ${filterValue.to.toLocaleDateString()}`;
+      }
+      if (filterValue.mode === "financial") {
+        return filterValue.quarter ? `${filterValue.fy} - ${filterValue.quarter}` : `${filterValue.fy}`;
+      }
+      return "";
+    })();
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { display: "flex", alignItems: "center", gap: 6 }, children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: title }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        material.IconButton,
+        {
+          size: "small",
+          onClick: (e) => setAnchorEl(e.currentTarget),
+          title: tooltipText,
+          color: hasFilter ? "primary" : "default",
+          children: /* @__PURE__ */ jsxRuntimeExports.jsx(Funnel, { size: 14 })
+        }
+      ),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        material.Popover,
+        {
+          open,
+          anchorEl,
+          onClose: () => setAnchorEl(null),
+          anchorOrigin: { vertical: "bottom", horizontal: "left" },
+          children: mode === "financial" ? /* @__PURE__ */ jsxRuntimeExports.jsx(
+            FinancialDateFilter,
+            {
+              column,
+              fyOptions,
+              closePopover: () => setAnchorEl(null)
+            }
+          ) : /* @__PURE__ */ jsxRuntimeExports.jsx(
+            RangeDateFilter,
+            {
+              column,
+              onClose: () => setAnchorEl(null)
+            }
+          )
+        }
+      )
+    ] });
+  }
+  const alignOpt = ["left", "center", "right"];
+  const buildColumn = (col, fyOptions, detectedColumnTypes, aggregates) => {
+    const grow = percentToGrow(col.ColSize);
+    const resolvedType = col.ColDataType || detectedColumnTypes[col.ColFields] || "string";
+    const isNumericColumn = resolvedType === "number";
+    const isDateColumn = resolvedType === "date";
+    const isBooleanColumn = resolvedType === "boolean";
+    let align = "left";
+    if (typeof col.ColAllignment === "string") {
+      align = alignOpt.includes(col.ColAllignment.toLowerCase()) ? col.ColAllignment.toLowerCase() : "left";
+    } else if (isNumericColumn) {
+      align = "right";
+    } else if (isDateColumn || isBooleanColumn) {
+      align = "center";
+    }
+    const column = {
+      header: col.ColHeading,
+      accessorKey: col.ColFields,
+      size: grow * 50,
+      grow,
+      enableSorting: !!col.ColSortable,
+      enableEditing: !!col.ColEditable,
+      enableHiding: true,
+      enablePinning: Boolean(col.Pin),
+      muiTableBodyCellProps: {
+        align,
+        sx: {
+          fontFamily: col.FntName,
+          color: col.FColor || "#1f2937",
+          backgroundColor: col.BColor || "#ffffff",
+          fontSize: col.FntSize || 13,
+          fontWeight: col.FntBold ? 600 : 400
+        }
+      },
+      muiTableFooterCellProps: {
+        align,
+        sx: {
+          fontWeight: "bold",
+          fontSize: col.FntSize || 14
+        }
+      }
+    };
+    if (typeof col.Render === "function") {
+      column.Cell = ({ row, cell }) => col.Render({
+        row,
+        cell,
+        value: row.original[col.ColFields]
+      });
+      if (col.IsUIOnly) {
+        column.enableSorting = false;
+        column.enableColumnFilter = false;
+        column.enableGrouping = false;
+        column.enableEditing = false;
+        column.enableColumnOrdering = false;
+        column.enableColumnActions = false;
+        column.enableHiding = false;
+        column.enablePinning = Boolean(col.Pin);
+      }
+      return column;
+    }
+    if (isDateColumn) {
+      column.id = col.ColFields;
+      column.accessorFn = (row) => {
+        const v = row[col.ColFields];
+        if (!v) return null;
+        const d = v instanceof Date ? v : new Date(v);
+        return isNaN(d) ? null : d;
+      };
+      column.Cell = ({ cell }) => formatDate(cell.getValue(), col.DateFormat || "dd/MM/yyyy");
+      if (!col.DateMode || col.DateMode === "single") {
+        column.filterVariant = "date";
+        column.filterFn = (row, columnId, filterValue) => {
+          if (!filterValue) return true;
+          const rowDate = row.getValue(columnId);
+          if (!(rowDate instanceof Date)) return false;
+          const f = filterValue instanceof Date ? filterValue : filterValue.toDate();
+          return rowDate.getFullYear() === f.getFullYear() && rowDate.getMonth() === f.getMonth() && rowDate.getDate() === f.getDate();
+        };
+        return column;
+      }
+      if (col.DateMode === "range" || col.DateMode === "financial") {
+        delete column.filterVariant;
+        column.enableColumnFilter = false;
+        column.filterFn = financialDateFilterFn;
+        column.Header = ({ column: column2 }) => /* @__PURE__ */ jsxRuntimeExports.jsx(
+          DateFilterHeader,
+          {
+            title: col.ColHeading,
+            column: column2,
+            mode: col.DateMode,
+            fyOptions
+          }
+        );
+      }
+      return column;
+    }
+    if (isNumericColumn) {
+      column.Cell = ({ cell }) => {
+        const value = cell.getValue();
+        if (col.IsPercentage) {
+          return formatPercentage({
+            value,
+            decimal: col.Decimal
+          });
+        }
+        if (col.Currency) {
+          return formatCurrency({
+            value,
+            decimal: col.Decimal,
+            currency: col.Currency,
+            showSymbol: col.ShowCurrencySymbol
+          });
+        }
+        return formatCurrency({
+          value,
+          decimal: col.Decimal
+        });
+      };
+    }
+    if (col.TotTyp) {
+      column.Footer = () => {
+        const value = aggregates[col.ColFields];
+        if (value === void 0 || value === null) return "";
+        if (isNumericColumn && col.IsPercentage) {
+          return formatPercentage({
+            value,
+            decimal: col.Decimal
+          });
+        }
+        if (isNumericColumn && col.Currency) {
+          return formatCurrency({
+            value,
+            decimal: col.Decimal,
+            currency: col.Currency,
+            showSymbol: col.ShowCurrencySymbol
+          });
+        }
+        if (isNumericColumn) {
+          return formatCurrency({
+            value,
+            decimal: col.Decimal
+          });
+        }
+        return String(value);
+      };
+    }
+    return column;
+  };
+  const defaultToolBarOpt = {
+    enabled: true,
+    globalSearch: true,
+    columnFilters: true,
+    densityToggle: true,
+    fullscreenToggle: true,
+    exportBtn: true,
+    showHideColumnsBtn: true
+  };
+  const defaultControlOpt = {
+    columnActions: true,
+    dragging: true,
+    colPinning: true,
+    pagination: true,
+    rowSelection: false,
+    rowPinning: false,
+    grouping: false,
+    sorting: true,
+    editing: false,
+    resizing: true
+  };
+  function SmartGridTable({
+    columns = [],
+    data = [],
+    height: height2 = "100%",
+    width: width2 = "100%",
+    theme = DEFAULT_THEME,
+    paginationStyle = "default",
+    topToolbar = defaultToolBarOpt,
+    controls = defaultControlOpt,
+    onRowSelectionChange,
+    isLoading = false
+  }) {
+    const safeColumns = React.useMemo(
+      () => sanitizeColumns(columns),
+      [columns]
+    );
+    const safeData = React.useMemo(
+      () => Array.isArray(data) ? data : [],
+      [data]
+    );
+    const [rowSelection, setRowSelection] = React.useState({});
+    const isMobile = material.useMediaQuery("(max-width:600px)");
+    const mergedTheme = { ...DEFAULT_THEME, ...theme };
+    topToolbar = { ...defaultToolBarOpt, ...topToolbar };
+    controls = { ...defaultControlOpt, ...controls };
+    const isGridDisabled = isLoading || safeColumns.length === 0 || safeData.length === 0;
+    const resolvedTopToolbar = {
+      ...defaultToolBarOpt,
+      ...topToolbar,
+      enabled: !isGridDisabled && (topToolbar == null ? void 0 : topToolbar.enabled) !== false
+    };
+    const detectedColumnTypes = React.useMemo(() => {
+      if (!Array.isArray(data) || !safeData.length) return {};
+      const sample = safeData[0];
+      const map = {};
+      Object.keys(sample).forEach((key) => {
+        const v = sample[key];
+        if (isDateValue(v)) map[key] = "date";
+        else if (isNumericValue(v)) map[key] = "number";
+        else if (isBooleanValue(v)) map[key] = "boolean";
+        else map[key] = "string";
+      });
+      return map;
+    }, [safeData]);
+    const aggregates = React.useMemo(() => {
+      if (isLoading || safeData.length === 0 || safeColumns.length === 0) {
+        return {};
+      }
+      if (!Array.isArray(data) || data.length === 0) return {};
+      const result2 = {};
+      columns == null ? void 0 : columns.forEach((col) => {
+        if (!col.TotTyp) return;
+        let count = 0;
+        let sum = 0;
+        let min2 = Infinity;
+        let max2 = -Infinity;
+        for (const row of data) {
+          const val = Number(row[col.ColFields]);
+          if (isNaN(val)) continue;
+          count++;
+          sum += val;
+          if (val < min2) min2 = val;
+          if (val > max2) max2 = val;
+        }
+        switch (col.TotTyp) {
+          case "SUM":
+            result2[col.ColFields] = sum;
+            break;
+          case "AVG":
+            result2[col.ColFields] = count ? sum / count : 0;
+            break;
+          case "MIN":
+            result2[col.ColFields] = count ? min2 : "";
+            break;
+          case "MAX":
+            result2[col.ColFields] = count ? max2 : "";
+            break;
+          case "COUNT":
+            result2[col.ColFields] = count;
+            break;
+        }
+      });
+      return result2;
+    }, [safeData, safeColumns, isLoading]);
+    const fyOptions = React.useMemo(() => {
+      if (!Array.isArray(data)) return [];
+      const fyColumn = columns == null ? void 0 : columns.find(
+        (c) => c.ColDataType === "date" && c.DateMode === "financial"
+      );
+      if (!fyColumn) return [];
+      return [
+        ...new Set(
+          data.map((r2) => getFinancialYear(r2[fyColumn.ColFields])).filter(Boolean)
+        )
+      ];
+    }, [data, columns]);
+    const finalColumns = React.useMemo(() => {
+      if (safeColumns.length === 0) return [];
+      return safeColumns.sort((a, b) => a.ColOrder - b.ColOrder).map(
+        (col) => buildColumn(col, fyOptions, detectedColumnTypes, aggregates)
+      );
+    }, [safeColumns, fyOptions, detectedColumnTypes, aggregates]);
+    const columnPinning = React.useMemo(() => {
+      const left2 = [];
+      const right2 = [];
+      (safeColumns || []).forEach((col) => {
+        if (col.Pin === "left") left2.push(col.ColFields);
+        if (col.Pin === "right") right2.push(col.ColFields);
+      });
+      return { left: left2, right: right2 };
+    }, [safeColumns]);
+    const columnVisibility = React.useMemo(() => {
+      const visibility = {};
+      (safeColumns || []).forEach((col) => {
+        if (col.IsHidden === true) {
+          visibility[col.ColFields] = false;
+        }
+      });
+      return visibility;
+    }, [safeColumns]);
+    const hasValidColumns = safeColumns.length > 0;
+    const hasData = safeData.length > 0;
+    const disableAllActions = isLoading || !hasValidColumns || !hasData;
+    const safeFinalColumns = finalColumns.length ? finalColumns : [];
+    if (!hasValidColumns) {
+      return /* @__PURE__ */ jsxRuntimeExports.jsx(material.Box, { p: 3, textAlign: "center", color: "text.secondary", children: "No valid columns provided" });
+    }
+    const table = materialReactTable.useMaterialReactTable({
+      columns: safeFinalColumns,
+      data: safeData,
+      /* ===============================
+         CORE LAYOUT (🔥 MUST BE semantic)
+      ================================ */
+      layoutMode: "semantic",
+      getRowId: (row, index) => {
+        var _a;
+        return ((_a = row.id) == null ? void 0 : _a.toString()) ?? index.toString();
+      },
+      /* ===============================
+         FEATURES
+      ================================ */
+      enableTopToolbar: resolvedTopToolbar.enabled,
+      enableGlobalFilter: resolvedTopToolbar.globalSearch && !isGridDisabled,
+      enableColumnFilters: resolvedTopToolbar.columnFilters && !isGridDisabled,
+      enableDensityToggle: resolvedTopToolbar.densityToggle && !isGridDisabled,
+      enableFullScreenToggle: resolvedTopToolbar.fullscreenToggle && !isGridDisabled,
+      enableColumnOrdering: !isGridDisabled && (controls == null ? void 0 : controls.dragging),
+      enableColumnPinning: !isGridDisabled && controls.colPinning,
+      enablePagination: !isGridDisabled && controls.pagination,
+      enableColumnActions: !isGridDisabled && controls.columnActions,
+      enableRowSelection: !isGridDisabled && controls.rowSelection,
+      enableGrouping: !isGridDisabled && controls.grouping,
+      enableSorting: !isGridDisabled && controls.sorting,
+      enableEditing: !isGridDisabled && controls.editing,
+      editDisplayMode: "cell",
+      enableColumnResizing: !disableAllActions && (controls == null ? void 0 : controls.resizing),
+      enableRowVirtualization: !controls.rowPinning && true,
+      enableStickyHeader: true,
+      enableStickyFooter: true,
+      enableBottomToolbar: !disableAllActions && (controls == null ? void 0 : controls.pagination),
+      enableRowPinning: !disableAllActions && controls.rowPinning,
+      enableGlobalFilterRankedResults: false,
+      enableFilterMatchHighlighting: true,
+      rowVirtualizerOptions: {
+        overscan: 20
+      },
+      muiPaginationProps: {
+        showRowsPerPage: !isMobile,
+        // ✅ mobile = false, desktop = true
+        showFirstButton: !isMobile,
+        showLastButton: !isMobile,
+        sx: {
+          flexDirection: {
+            xs: "column",
+            sm: "row"
+          },
+          alignItems: {
+            xs: "flex-start",
+            sm: "center"
+          },
+          gap: 1
+        }
+      },
+      //render top menu
+      renderTopToolbar: ({ table: table2 }) => {
+        const [searchValue, setSearchValue] = React.useState(
+          table2.getState().globalFilter ?? ""
+        );
+        const disable = isGridDisabled;
+        React.useEffect(() => {
+          if (disable) return;
+          const timeout = setTimeout(() => {
+            table2.setGlobalFilter(searchValue || void 0);
+          }, 300);
+          return () => clearTimeout(timeout);
+        }, [searchValue, table2, disable]);
+        const exportData = table2.getFilteredRowModel().rows.map((row) => row.original);
+        return /* @__PURE__ */ jsxRuntimeExports.jsx(jsxRuntimeExports.Fragment, { children: /* @__PURE__ */ jsxRuntimeExports.jsx(material.Box, { sx: { px: 2, py: 2 }, children: /* @__PURE__ */ jsxRuntimeExports.jsxs(
+          material.Box,
+          {
+            sx: {
+              display: "grid",
+              gridTemplateColumns: {
+                xs: "1fr",
+                sm: "1fr auto"
+              },
+              gap: 2,
+              alignItems: "center",
+              width: "100%"
+            },
+            children: [
+              (topToolbar == null ? void 0 : topToolbar.globalSearch) && /* @__PURE__ */ jsxRuntimeExports.jsx(
+                material.TextField,
+                {
+                  size: "small",
+                  fullWidth: true,
+                  disabled: disable,
+                  placeholder: isLoading ? "Loading..." : safeColumns.length === 0 ? "No columns configured" : safeData.length === 0 ? "No data available" : "Search...",
+                  value: searchValue,
+                  onChange: (e) => setSearchValue(e.target.value),
+                  InputProps: {
+                    startAdornment: /* @__PURE__ */ jsxRuntimeExports.jsx(material.InputAdornment, { position: "start", children: /* @__PURE__ */ jsxRuntimeExports.jsx(SearchCheck, {}) })
+                  },
+                  sx: {
+                    "& .MuiOutlinedInput-root": {
+                      borderRadius: 1.5,
+                      "& fieldset": { borderColor: mergedTheme == null ? void 0 : mergedTheme.headerBg },
+                      "&:hover fieldset": { borderColor: mergedTheme == null ? void 0 : mergedTheme.headerBg },
+                      "&.Mui-focused fieldset": {
+                        borderColor: mergedTheme == null ? void 0 : mergedTheme.headerBg,
+                        borderWidth: 2
+                      }
+                    },
+                    "& .MuiOutlinedInput-input::placeholder": {
+                      opacity: 0.7
+                    },
+                    "& .MuiInputAdornment-root svg": {
+                      color: mergedTheme == null ? void 0 : mergedTheme.headerBg
+                    }
+                  }
+                }
+              ),
+              ((topToolbar == null ? void 0 : topToolbar.exportBtn) || (topToolbar == null ? void 0 : topToolbar.columnFilters) || (topToolbar == null ? void 0 : topToolbar.densityToggle) || (topToolbar == null ? void 0 : topToolbar.showHideColumnsBtn) || (topToolbar == null ? void 0 : topToolbar.fullscreenToggle)) && /* @__PURE__ */ jsxRuntimeExports.jsxs(
+                material.Paper,
+                {
+                  elevation: 3,
+                  sx: {
+                    justifySelf: "end",
+                    // ✅ THIS IS THE KEY
+                    display: "inline-flex",
+                    alignItems: "center",
+                    width: "fit-content",
+                    px: 1,
+                    py: 0.2,
+                    borderRadius: 2,
+                    bgcolor: "background.paper",
+                    border: `1px solid ${mergedTheme == null ? void 0 : mergedTheme.headerBg}`,
+                    whiteSpace: "nowrap",
+                    opacity: disable ? 0.6 : 1,
+                    pointerEvents: disable ? "none" : "auto"
+                  },
+                  children: [
+                    (topToolbar == null ? void 0 : topToolbar.exportBtn) && /* @__PURE__ */ jsxRuntimeExports.jsx(
+                      ExportButton,
+                      {
+                        data: exportData,
+                        color: mergedTheme == null ? void 0 : mergedTheme.headerBg,
+                        filename: "table-data",
+                        disabled: disable
+                      }
+                    ),
+                    (topToolbar == null ? void 0 : topToolbar.columnFilters) && /* @__PURE__ */ jsxRuntimeExports.jsx(materialReactTable.MRT_ToggleFiltersButton, { table: table2, disabled: disable }),
+                    (topToolbar == null ? void 0 : topToolbar.densityToggle) && /* @__PURE__ */ jsxRuntimeExports.jsx(materialReactTable.MRT_ToggleDensePaddingButton, { table: table2, disabled: disable }),
+                    (topToolbar == null ? void 0 : topToolbar.showHideColumnsBtn) && /* @__PURE__ */ jsxRuntimeExports.jsx(materialReactTable.MRT_ShowHideColumnsButton, { table: table2, disabled: disable }),
+                    (topToolbar == null ? void 0 : topToolbar.fullscreenToggle) && /* @__PURE__ */ jsxRuntimeExports.jsx(materialReactTable.MRT_ToggleFullScreenButton, { table: table2, disabled: disable })
+                  ]
+                }
+              )
+            ]
+          }
+        ) }) });
+      },
+      /* ===============================
+         INITIAL STATE
+      ================================ */
+      initialState: {
+        pagination: {
+          pageIndex: 0,
+          pageSize: 50
+        },
+        density: "comfortable",
+        columnPinning: (controls == null ? void 0 : controls.colPinning) ? columnPinning : { left: [], right: [] },
+        columnVisibility
+      },
+      paginationDisplayMode: paginationStyle,
+      /* ===============================
+         ROW SELECTION STATE
+      ================================ */
+      state: {
+        rowSelection,
+        isLoading,
+        showProgressBars: isLoading
+      },
+      onRowSelectionChange: (updater) => {
+        const next = typeof updater === "function" ? updater(rowSelection) : updater;
+        setRowSelection(next);
+        if (onRowSelectionChange) {
+          const selectedRows = Object.keys(next).map((rowId) => {
+            var _a;
+            return (_a = table.getRow(rowId)) == null ? void 0 : _a.original;
+          }).filter(Boolean);
+          onRowSelectionChange(selectedRows);
+        }
+      },
+      muiTableBodyProps: {
+        sx: {
+          "&.MuiTableBody-root": {
+            transform: "translateY(0px) !important"
+          }
+        }
+      },
+      /* ===============================
+         ROOT (TABLE WRAPPER)
+      ================================ */
+      muiTablePaperProps: {
+        elevation: 0,
+        sx: {
+          height: height2,
+          width: width2,
+          display: "flex",
+          flexDirection: "column",
+          border: `1px solid ${mergedTheme.border}`,
+          borderRadius: "6px",
+          backgroundColor: mergedTheme.bodyBg
+        }
+      },
+      /* ===============================
+         TOP TOOLBAR (STICKY)
+      ================================ */
+      muiTopToolbarProps: {
+        sx: {
+          position: "sticky",
+          top: 0,
+          zIndex: 4,
+          backgroundColor: mergedTheme.bodyBg,
+          borderBottom: `1px solid ${mergedTheme.border}`
+        }
+      },
+      /* ===============================
+         HEADER (PIN SAFE)
+      ================================ */
+      muiTableHeadCellProps: {
+        sx: {
+          backgroundColor: mergedTheme.headerBg,
+          color: mergedTheme.headerText,
+          fontWeight: 600,
+          borderRight: `1px solid ${mergedTheme.border}`,
+          /* =============================== FILTER INPUT (WHEN OPEN) ================================ */
+          "& .MuiInputBase-root": { color: mergedTheme.headerText },
+          "& .MuiInputBase-input": { color: mergedTheme.headerText },
+          "& .MuiInputBase-input::placeholder": { color: mergedTheme.headerText, opacity: 1 },
+          "& .MuiInput-underline:before": { borderBottomColor: mergedTheme.headerText },
+          "& .MuiInput-underline:hover:not(.Mui-disabled):before": { borderBottomColor: mergedTheme.headerText },
+          "& .MuiInput-underline:after": { borderBottomColor: mergedTheme.headerText },
+          '&[data-pinned="true"]': {
+            backgroundColor: mergedTheme.headerBg
+          },
+          "& .MuiTableSortLabel-root": {
+            color: `${mergedTheme.headerText} !important`
+          },
+          "& .MuiTableSortLabel-icon": {
+            color: `${mergedTheme.headerText} !important`,
+            opacity: "1 !important"
+          },
+          "& .MuiIconButton-root": {
+            color: `${mergedTheme.headerText} !important`
+          },
+          "& .MuiSvgIcon-root": {
+            color: `${mergedTheme.headerText} !important`,
+            fill: `${mergedTheme.headerText} !important`
+          },
+          /* =============================== DATE PICKER FILTER (MUI X) ================================ */
+          "& .MuiPickersInputBase-root": { color: mergedTheme.headerText },
+          "& .MuiPickersInputBase-input": { color: mergedTheme.headerText },
+          "& .MuiPickersSectionList-sectionContent": { color: mergedTheme.headerText },
+          "& .MuiPickersSectionList-sectionSeparator": { color: mergedTheme.headerText },
+          "& .MuiPickersInputAdornment-root .MuiIconButton-root": { color: mergedTheme.headerText },
+          "& .MuiPickersInputAdornment-root .MuiSvgIcon-root": { color: mergedTheme.headerText, fill: mergedTheme.headerText },
+          /* underline for filled/outlined pickers */
+          "& .MuiFilledInput-underline:before": { borderBottomColor: "rgba(255,255,255,0.6)" },
+          "& .MuiFilledInput-underline:hover:not(.Mui-disabled):before": { borderBottomColor: mergedTheme.headerText },
+          "& .MuiFilledInput-underline:after": { borderBottomColor: mergedTheme.headerText }
+        }
+      },
+      /* ===============================
+         BODY CONTAINER
+      ================================ */
+      muiTableContainerProps: {
+        sx: {
+          overflow: "auto"
+        }
+      },
+      /* ===============================
+         BODY CELLS (PIN SAFE)
+      ================================ */
+      muiTableBodyCellProps: ({ cell }) => {
+        var _a;
+        return {
+          title: (_a = cell.renderValue) == null ? void 0 : _a.call(cell),
+          sx: {
+            borderRight: `1px solid ${mergedTheme.border}`,
+            backgroundColor: mergedTheme.bodyBg,
+            "&.mrt-table-body-cell-pinned": {
+              backgroundColor: mergedTheme.bodyBg,
+              zIndex: 1
+            }
+          }
+        };
+      },
+      /* ===============================
+         ROW HOVER
+      ================================ */
+      muiTableBodyRowProps: {
+        sx: {
+          "&:hover .MuiTableCell-root::after": {
+            content: '""',
+            position: "absolute",
+            inset: 0,
+            backgroundColor: "rgba(0,0,0,0.03)",
+            pointerEvents: "none"
+          }
+        }
+      },
+      /* ===============================
+         FOOTER / PAGINATION (STICKY)
+      ================================ */
+      muiTableFooterRowProps: {
+        sx: {
+          backgroundColor: mergedTheme.bodyBg,
+          color: mergedTheme.headerText
+        }
+      },
+      muiBottomToolbarProps: {
+        sx: {
+          backgroundColor: mergedTheme.bodyBg,
+          borderTop: `1px solid ${mergedTheme.border}`
+        }
+      },
+      muiTablePaginationProps: {
+        rowsPerPageOptions: [25, 50, 100],
+        showFirstButton: true,
+        showLastButton: true
+      }
+    });
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(materialReactTable.MaterialReactTable, { table });
+  }
+  const ExportButton = ({
+    data,
+    filename = "data",
+    disabled = false
+  }) => {
+    const [anchorEl, setAnchorEl] = React.useState(null);
+    const [loading, setLoading] = React.useState(false);
+    const open = Boolean(anchorEl);
+    const handleOpen = (event) => {
+      if (!disabled && !loading) {
+        setAnchorEl(event.currentTarget);
+      }
+    };
+    const handleClose = () => {
+      setAnchorEl(null);
+    };
+    const downloadCSV = () => {
+      if (!data || data.length === 0) {
+        return;
+      }
+      const csvContent = [
+        Object.keys(data[0]).join(","),
+        ...data.map(
+          (row) => Object.values(row).map((v) => `"${v}"`).join(",")
+        )
+      ].join("\n");
+      const blob = new Blob([csvContent], {
+        type: "text/csv;charset=utf-8;"
+      });
+      const url = window.URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = `${filename}.csv`;
+      a.click();
+      window.URL.revokeObjectURL(url);
+    };
+    const downloadXLSX = () => {
+      if (!data || data.length === 0) {
+        return;
+      }
+      const worksheet = XLSX__namespace.utils.json_to_sheet(data);
+      const workbook = XLSX__namespace.utils.book_new();
+      XLSX__namespace.utils.book_append_sheet(workbook, worksheet, "Data");
+      XLSX__namespace.writeFile(workbook, `${filename}.xlsx`);
+    };
+    const handleExport = async (type) => {
+      handleClose();
+      setLoading(true);
+      setTimeout(() => {
+        try {
+          type === "csv" ? downloadCSV() : downloadXLSX();
+        } catch (err) {
+          console.error(err);
+        } finally {
+          setLoading(false);
+        }
+      }, 200);
+    };
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx(material.Tooltip, { title: loading ? "Exporting…" : "Export", children: /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+        material.IconButton,
+        {
+          onClick: handleOpen,
+          disabled: disabled || loading,
+          sx: {
+            width: 40,
+            height: 40
+          },
+          children: loading ? /* @__PURE__ */ jsxRuntimeExports.jsx(material.CircularProgress, { size: 20, color: "inherit" }) : /* @__PURE__ */ jsxRuntimeExports.jsx(Download, {})
+        }
+      ) }) }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs(
+        material.Menu,
+        {
+          anchorEl,
+          open,
+          onClose: handleClose,
+          anchorOrigin: { vertical: "bottom", horizontal: "right" },
+          transformOrigin: { vertical: "top", horizontal: "right" },
+          children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsxs(material.MenuItem, { onClick: () => handleExport("csv"), children: [
+              /* @__PURE__ */ jsxRuntimeExports.jsx(material.ListItemIcon, { children: /* @__PURE__ */ jsxRuntimeExports.jsx(Table, { color: "#3b74eeb2" }) }),
+              /* @__PURE__ */ jsxRuntimeExports.jsx(
+                material.ListItemText,
+                {
+                  primary: "Export as CSV",
+                  secondary: "Comma-separated values"
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxRuntimeExports.jsxs(material.MenuItem, { onClick: () => handleExport("xlsx"), children: [
+              /* @__PURE__ */ jsxRuntimeExports.jsx(material.ListItemIcon, { children: /* @__PURE__ */ jsxRuntimeExports.jsx(Sheet, { color: "#3bee86b2" }) }),
+              /* @__PURE__ */ jsxRuntimeExports.jsx(
+                material.ListItemText,
+                {
+                  primary: "Export as XLSX",
+                  secondary: "Excel spreadsheet"
+                }
+              )
+            ] })
+          ]
+        }
+      )
+    ] });
+  };
+  const SmartTable = (props) => /* @__PURE__ */ jsxRuntimeExports.jsx(xDatePickers.LocalizationProvider, { dateAdapter: AdapterDayjs, children: /* @__PURE__ */ jsxRuntimeExports.jsx(SmartGridTable, { ...props }) });
   exports2.MytekComboDropdown = ComboDropdown;
   exports2.MytekInputField = CustomInput;
   exports2.MytekLoader = Loader;
   exports2.MytekMessageBox = Mt_MessageBox;
   exports2.MytekPowerCombo = PowerDropdown;
   exports2.MytekRadioButton = RadioButton;
+  exports2.MytekSmartTable = SmartTable;
   exports2.MytekTab = DynamicTabs;
   exports2.MytekTable = MasterTable;
   exports2.MytekTooltip = Tooltip;