@unifiedsoftware/react-ui 1.0.0 → 1.0.1

package/dist/index.mjs

@@ -0,0 +1,2186 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// src/components/Button/Button.tsx
+import clsx from "clsx";
+import { forwardRef } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var prefixCls = "us-";
+var Button = forwardRef(
+  (_a, ref) => {
+    var _b = _a, { as: Component2 = "button", children, className, variant = "text", color = "primary", size = "md" } = _b, rest = __objRest(_b, ["as", "children", "className", "variant", "color", "size"]);
+    return /* @__PURE__ */ jsxs(
+      Component2,
+      __spreadProps(__spreadValues({
+        ref,
+        className: clsx(
+          `${prefixCls}button`,
+          {
+            [`${prefixCls}button--${variant}`]: variant,
+            [`${prefixCls}button--${color}`]: color,
+            [`${prefixCls}button--${size}`]: size
+          },
+          className
+        )
+      }, rest), {
+        children: [
+          /* @__PURE__ */ jsx("div", { className: `${prefixCls}button__elevation` }),
+          /* @__PURE__ */ jsx("div", { className: `${prefixCls}button__outline` }),
+          children
+        ]
+      })
+    );
+  }
+);
+
+// src/components/Tabs/Tab.tsx
+import clsx2 from "clsx";
+import mergeRefs from "merge-refs";
+import { forwardRef as forwardRef2, useEffect, useRef } from "react";
+
+// src/components/Tabs/TabsContext.ts
+import { createContext, useContext } from "react";
+var TabsContext = createContext(null);
+var useTabs = () => {
+  const context = useContext(TabsContext);
+  if (!context) {
+    throw new Error("`useTabs` must be used within a `<Tabs />`");
+  }
+  return context;
+};
+
+// src/components/Tabs/Tab.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var prefixCls2 = "us-";
+var Tab = forwardRef2(
+  (_a, ref) => {
+    var _b = _a, { as: Component2 = "div", children, className, value, onClick } = _b, rest = __objRest(_b, ["as", "children", "className", "value", "onClick"]);
+    const tabRef = useRef(null);
+    const tabs = useTabs();
+    const handleClick = (event) => {
+      const previousTab = tabs.previousTabRef.current;
+      const currentTab = tabRef.current;
+      if (!currentTab)
+        return;
+      if (previousTab) {
+        const previousIndicator = previousTab.querySelector(`.${prefixCls2}tab__indicator`);
+        const currentIndicator = currentTab.querySelector(`.${prefixCls2}tab__indicator`);
+        if (!previousIndicator || !currentIndicator)
+          return;
+        const from = {};
+        const fromRect = previousIndicator.getBoundingClientRect();
+        const fromPos = fromRect.left;
+        const fromWidth = fromRect.width;
+        const toRect = currentIndicator.getBoundingClientRect();
+        const toPos = toRect.left;
+        const toWidth = toRect.width;
+        const scale = fromWidth / toWidth;
+        if (scale) {
+          from["transform"] = `translateX(${(fromPos - toPos).toFixed(4)}px) scaleX(${scale.toFixed(4)})`;
+        } else {
+          from["opacity"] = 0;
+        }
+        const keyframes = [from, { transform: "none" }];
+        currentIndicator.animate(keyframes, {
+          duration: 250,
+          easing: "cubic-bezier(.3,0,0,1)"
+        });
+        tabs.previousTabRef.current = tabRef.current;
+      }
+      tabs.previousTabRef.current = tabRef.current;
+      tabs.onChange(value);
+      onClick == null ? void 0 : onClick(event);
+    };
+    useEffect(() => {
+      if (value === tabs.value) {
+        tabs.previousTabRef.current = tabRef.current;
+      }
+    }, []);
+    return /* @__PURE__ */ jsx2(
+      Component2,
+      __spreadProps(__spreadValues({
+        ref: mergeRefs(tabRef, ref),
+        className: clsx2(`${prefixCls2}tab`, { [`${prefixCls2}tab--selected`]: value === tabs.value }, className),
+        onClick: handleClick
+      }, rest), {
+        children: /* @__PURE__ */ jsxs2("div", { className: `${prefixCls2}tab__content`, children: [
+          children,
+          /* @__PURE__ */ jsx2("div", { className: `${prefixCls2}tab__indicator` })
+        ] })
+      })
+    );
+  }
+);
+
+// src/components/Tabs/Tabs.tsx
+import clsx3 from "clsx";
+import { useEffect as useEffect2, useRef as useRef2, useState } from "react";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var prefixCls3 = "us-";
+var Tabs = (_a) => {
+  var _b = _a, { children, className, value, defaultValue, onChange } = _b, rest = __objRest(_b, ["children", "className", "value", "defaultValue", "onChange"]);
+  const previousTabRef = useRef2(null);
+  const [selfValue, setSelfValue] = useState(value != null ? value : defaultValue);
+  const handleChange = (value2) => {
+    setSelfValue(value2);
+    onChange == null ? void 0 : onChange(value2);
+  };
+  useEffect2(() => {
+    if (value !== void 0) {
+      setSelfValue(value);
+    }
+  }, [value]);
+  return /* @__PURE__ */ jsxs3(TabsContext.Provider, { value: { previousTabRef, value: selfValue, onChange: handleChange }, children: [
+    /* @__PURE__ */ jsx3("div", __spreadProps(__spreadValues({ className: clsx3(`${prefixCls3}tabs`, className) }, rest), { children })),
+    /* @__PURE__ */ jsx3("div", { className: `${prefixCls3}divider` })
+  ] });
+};
+
+// src/components/DropdownEnumList.tsx
+import { DropDownList } from "@progress/kendo-react-dropdowns";
+import { useEffect as useEffect3, useState as useState2 } from "react";
+import { Fragment, jsx as jsx4 } from "react/jsx-runtime";
+function parsearDataForComboBox(array, key, text, itemAll = false) {
+  const dataForComboBox = [];
+  if (itemAll)
+    dataForComboBox.push({ key: "", text: "ALL" });
+  if (array !== void 0) {
+    array.map((a) => {
+      dataForComboBox.push({ key: a[key], text: a[text] });
+    });
+  }
+  return dataForComboBox;
+}
+function GetEnumDescription(key, typeEnum, description) {
+  const listLabel = description.get(typeEnum);
+  let label = void 0;
+  if (listLabel != void 0)
+    label = listLabel.get(parseInt(key));
+  if (label == void 0) {
+    label = typeEnum[key];
+    return label.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+  }
+  return label;
+}
+function EnumToArray(typeEnum, replaceGuionForSpace = true, description) {
+  const values = [];
+  for (const key in typeEnum) {
+    if (typeof typeEnum[key] === "string")
+      values.push({
+        value: Number(key),
+        label: replaceGuionForSpace ? GetEnumDescription(key, typeEnum, description) : typeEnum[key]
+      });
+  }
+  return values;
+}
+var DropEnumList = ({ dataEnum, description, onChange, width, defaultValue }) => {
+  const [value, setValue] = useState2("");
+  const [data, setData] = useState2([]);
+  useEffect3(() => {
+    setData(
+      parsearDataForComboBox(EnumToArray(dataEnum, true, description), "value", "label", false).sort(
+        (a, b) => Number(a.key) - Number(b.key)
+      )
+    );
+  }, []);
+  useEffect3(() => {
+    if (data.length > 0) {
+      setValue(data.filter((x) => x.key == defaultValue)[0]);
+    }
+  }, [data]);
+  const handleOptionClick = (e) => {
+    onChange(e);
+    setValue(e);
+  };
+  return /* @__PURE__ */ jsx4(Fragment, { children: /* @__PURE__ */ jsx4(
+    DropDownList,
+    {
+      className: "d-inline-block align-middle mr-2",
+      data,
+      dataItemKey: "key",
+      id: "cmbDisplay",
+      name: "cmbDisplay",
+      onChange: (event) => {
+        handleOptionClick(event.value);
+      },
+      textField: "text",
+      style: {
+        width: `${width}px`
+      },
+      defaultValue: value
+    }
+  ) });
+};
+
+// src/contexts/BreadCrumbContext.tsx
+import { createContext as createContext2, useState as useState4 } from "react";
+
+// src/hooks/useLocalStorage.tsx
+import { useCallback, useEffect as useEffect5, useState as useState3 } from "react";
+
+// src/hooks/useEventListener.tsx
+import { useRef as useRef3 } from "react";
+
+// src/hooks/useIsomorphicLayoutEffect.tsx
+import { useEffect as useEffect4, useLayoutEffect } from "react";
+var useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect4;
+var useIsomorphicLayoutEffect_default = useIsomorphicLayoutEffect;
+
+// src/hooks/useEventListener.tsx
+function useEventListener(handler) {
+  const savedHandler = useRef3(handler);
+  useIsomorphicLayoutEffect_default(() => {
+    savedHandler.current = handler;
+  }, [handler]);
+}
+var useEventListener_default = useEventListener;
+
+// src/hooks/useLocalStorage.tsx
+function useLocalStorage(key, initialValue) {
+  const readValue = useCallback(() => {
+    if (typeof window === "undefined") {
+      return initialValue;
+    }
+    try {
+      const item = window.localStorage.getItem(key);
+      return item ? parseJSON(item) : initialValue;
+    } catch (error) {
+      console.warn(`Error reading localStorage key \u201C${key}\u201D:`, error);
+      return initialValue;
+    }
+  }, [initialValue, key]);
+  const [storedValue, setStoredValue] = useState3(readValue);
+  const setValue = useCallback(
+    (value) => {
+      if (typeof window == "undefined") {
+        console.warn(`Tried setting localStorage key \u201C${key}\u201D even though environment is not a client`);
+      }
+      try {
+        const newValue = value instanceof Function ? value(storedValue) : value;
+        window.localStorage.setItem(key, JSON.stringify(newValue));
+        setStoredValue(newValue);
+        window.dispatchEvent(new Event("local-storage"));
+      } catch (error) {
+        console.warn(`Error setting localStorage key \u201C${key}\u201D:`, error);
+      }
+    },
+    [key, storedValue]
+  );
+  useEffect5(() => {
+    setStoredValue(readValue());
+  }, []);
+  const handleStorageChange = useCallback(() => {
+    setStoredValue(readValue());
+  }, [readValue]);
+  useEventListener_default("storage", handleStorageChange);
+  useEventListener_default("local-storage", handleStorageChange);
+  return [storedValue, setValue];
+}
+function parseJSON(value) {
+  try {
+    return value === "undefined" ? void 0 : JSON.parse(value != null ? value : "");
+  } catch (e) {
+    console.log("parsing error on", { value });
+    return void 0;
+  }
+}
+
+// src/contexts/BreadCrumbContext.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+var BreadCrumbContext = createContext2({});
+var BreadCrumbContextProvider = ({ children }) => {
+  const [active, setActive] = useLocalStorage("@active", "");
+  const [path, setPath] = useLocalStorage("@path", "/");
+  const [goBack, setGoBack] = useLocalStorage("@goBack", false);
+  const [pathChild, setPathChild] = useLocalStorage("@pathChild", "");
+  const [routes, setRoutes] = useState4([]);
+  return /* @__PURE__ */ jsx5(
+    BreadCrumbContext.Provider,
+    {
+      value: {
+        active,
+        setActive,
+        path,
+        setPath,
+        goBack,
+        setGoBack,
+        pathChild,
+        setPathChild,
+        routes,
+        setRoutes
+      },
+      children
+    }
+  );
+};
+
+// src/contexts/DrawerContext.tsx
+import { createContext as createContext3, useState as useState5 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var DrawerContext = createContext3({});
+var DrawerContextProvider = ({ children }) => {
+  const [active, setActive] = useState5(false);
+  return /* @__PURE__ */ jsx6(DrawerContext.Provider, { value: { active, setActive }, children });
+};
+
+// src/contexts/HistoryContext.tsx
+import { createContext as createContext4 } from "react";
+import { jsx as jsx7 } from "react/jsx-runtime";
+var HistoryContext = createContext4({});
+var HistoryContextProvider = ({ children }) => {
+  const [list, setList] = useLocalStorage("@list_paths", []);
+  const updateList = (value) => {
+    setList(
+      (prev) => prev.concat({
+        path: value.path,
+        name: value.name,
+        date: /* @__PURE__ */ new Date()
+      })
+    );
+  };
+  return /* @__PURE__ */ jsx7(HistoryContext.Provider, { value: { list, updateList }, children });
+};
+
+// src/contexts/SidebarMainContext.tsx
+import { createContext as createContext5, useState as useState6 } from "react";
+import { jsx as jsx8 } from "react/jsx-runtime";
+var SidebarMainContext = createContext5({});
+var SidebarMainContextProvider = ({ children }) => {
+  const [open, setOpen] = useState6(true);
+  return /* @__PURE__ */ jsx8(SidebarMainContext.Provider, { value: { open, setOpen }, children });
+};
+
+// src/contexts/GlobalProvider.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+function GlobalProvider({ children }) {
+  return /* @__PURE__ */ jsx9(HistoryContextProvider, { children: /* @__PURE__ */ jsx9(BreadCrumbContextProvider, { children: /* @__PURE__ */ jsx9(SidebarMainContextProvider, { children: /* @__PURE__ */ jsx9(DrawerContextProvider, { children }) }) }) });
+}
+
+// src/hooks/usePrevious.tsx
+import { useEffect as useEffect6, useRef as useRef4 } from "react";
+var usePrevious = (value) => {
+  const ref = useRef4();
+  useEffect6(() => {
+    ref.current = value;
+  });
+  return ref.current;
+};
+
+// src/hooks/useStep.tsx
+import { useCallback as useCallback2, useMemo, useState as useState7 } from "react";
+var useStep = (maxStep) => {
+  const [currentStep, setCurrentStep] = useState7(1);
+  const canGoToNextStep = useMemo(() => currentStep + 1 <= maxStep, [currentStep, maxStep]);
+  const canGoToPrevStep = useMemo(() => currentStep - 1 >= 1, [currentStep]);
+  const setStep = useCallback2(
+    (step) => {
+      const newStep = step instanceof Function ? step(currentStep) : step;
+      if (newStep >= 1 && newStep <= maxStep) {
+        setCurrentStep(newStep);
+        return;
+      }
+      throw new Error("Step not valid");
+    },
+    [maxStep, currentStep]
+  );
+  const goToNextStep = useCallback2(() => {
+    if (canGoToNextStep) {
+      setCurrentStep((step) => step + 1);
+    }
+  }, [canGoToNextStep]);
+  const goToPrevStep = useCallback2(() => {
+    if (canGoToPrevStep) {
+      setCurrentStep((step) => step - 1);
+    }
+  }, [canGoToPrevStep]);
+  const reset = useCallback2(() => {
+    setCurrentStep(1);
+  }, []);
+  return [
+    currentStep,
+    {
+      goToNextStep,
+      goToPrevStep,
+      canGoToNextStep,
+      canGoToPrevStep,
+      setStep,
+      reset
+    }
+  ];
+};
+
+// src/layout/AppBreadcrumb.tsx
+import { useContext as useContext4, useEffect as useEffect9 } from "react";
+import { MdClose } from "react-icons/md";
+import { VscChevronRight } from "react-icons/vsc";
+
+// ../../../node_modules/react-router-dom/dist/index.js
+import * as React2 from "react";
+
+// ../../../node_modules/react-router/dist/index.js
+import * as React from "react";
+
+// ../../../node_modules/@remix-run/router/dist/router.js
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+var Action;
+(function(Action2) {
+  Action2["Pop"] = "POP";
+  Action2["Push"] = "PUSH";
+  Action2["Replace"] = "REPLACE";
+})(Action || (Action = {}));
+function invariant(value, message) {
+  if (value === false || value === null || typeof value === "undefined") {
+    throw new Error(message);
+  }
+}
+function warning(cond, message) {
+  if (!cond) {
+    if (typeof console !== "undefined")
+      console.warn(message);
+    try {
+      throw new Error(message);
+    } catch (e) {
+    }
+  }
+}
+function createPath(_ref) {
+  let {
+    pathname = "/",
+    search = "",
+    hash = ""
+  } = _ref;
+  if (search && search !== "?")
+    pathname += search.charAt(0) === "?" ? search : "?" + search;
+  if (hash && hash !== "#")
+    pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
+  return pathname;
+}
+function parsePath(path) {
+  let parsedPath = {};
+  if (path) {
+    let hashIndex = path.indexOf("#");
+    if (hashIndex >= 0) {
+      parsedPath.hash = path.substr(hashIndex);
+      path = path.substr(0, hashIndex);
+    }
+    let searchIndex = path.indexOf("?");
+    if (searchIndex >= 0) {
+      parsedPath.search = path.substr(searchIndex);
+      path = path.substr(0, searchIndex);
+    }
+    if (path) {
+      parsedPath.pathname = path;
+    }
+  }
+  return parsedPath;
+}
+var ResultType;
+(function(ResultType2) {
+  ResultType2["data"] = "data";
+  ResultType2["deferred"] = "deferred";
+  ResultType2["redirect"] = "redirect";
+  ResultType2["error"] = "error";
+})(ResultType || (ResultType = {}));
+function convertRouteMatchToUiMatch(match, loaderData) {
+  let {
+    route,
+    pathname,
+    params
+  } = match;
+  return {
+    id: route.id,
+    pathname,
+    params,
+    data: loaderData[route.id],
+    handle: route.handle
+  };
+}
+function stripBasename(pathname, basename) {
+  if (basename === "/")
+    return pathname;
+  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {
+    return null;
+  }
+  let startIndex = basename.endsWith("/") ? basename.length - 1 : basename.length;
+  let nextChar = pathname.charAt(startIndex);
+  if (nextChar && nextChar !== "/") {
+    return null;
+  }
+  return pathname.slice(startIndex) || "/";
+}
+function resolvePath(to, fromPathname) {
+  if (fromPathname === void 0) {
+    fromPathname = "/";
+  }
+  let {
+    pathname: toPathname,
+    search = "",
+    hash = ""
+  } = typeof to === "string" ? parsePath(to) : to;
+  let pathname = toPathname ? toPathname.startsWith("/") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname;
+  return {
+    pathname,
+    search: normalizeSearch(search),
+    hash: normalizeHash(hash)
+  };
+}
+function resolvePathname(relativePath, fromPathname) {
+  let segments = fromPathname.replace(/\/+$/, "").split("/");
+  let relativeSegments = relativePath.split("/");
+  relativeSegments.forEach((segment) => {
+    if (segment === "..") {
+      if (segments.length > 1)
+        segments.pop();
+    } else if (segment !== ".") {
+      segments.push(segment);
+    }
+  });
+  return segments.length > 1 ? segments.join("/") : "/";
+}
+function getInvalidPathError(char, field, dest, path) {
+  return "Cannot include a '" + char + "' character in a manually specified " + ("`to." + field + "` field [" + JSON.stringify(path) + "].  Please separate it out to the ") + ("`to." + dest + "` field. Alternatively you may provide the full path as ") + 'a string in <Link to="..."> and the router will parse it for you.';
+}
+function getPathContributingMatches(matches) {
+  return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);
+}
+function resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {
+  if (isPathRelative === void 0) {
+    isPathRelative = false;
+  }
+  let to;
+  if (typeof toArg === "string") {
+    to = parsePath(toArg);
+  } else {
+    to = _extends({}, toArg);
+    invariant(!to.pathname || !to.pathname.includes("?"), getInvalidPathError("?", "pathname", "search", to));
+    invariant(!to.pathname || !to.pathname.includes("#"), getInvalidPathError("#", "pathname", "hash", to));
+    invariant(!to.search || !to.search.includes("#"), getInvalidPathError("#", "search", "hash", to));
+  }
+  let isEmptyPath = toArg === "" || to.pathname === "";
+  let toPathname = isEmptyPath ? "/" : to.pathname;
+  let from;
+  if (isPathRelative || toPathname == null) {
+    from = locationPathname;
+  } else {
+    let routePathnameIndex = routePathnames.length - 1;
+    if (toPathname.startsWith("..")) {
+      let toSegments = toPathname.split("/");
+      while (toSegments[0] === "..") {
+        toSegments.shift();
+        routePathnameIndex -= 1;
+      }
+      to.pathname = toSegments.join("/");
+    }
+    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
+  }
+  let path = resolvePath(to, from);
+  let hasExplicitTrailingSlash = toPathname && toPathname !== "/" && toPathname.endsWith("/");
+  let hasCurrentTrailingSlash = (isEmptyPath || toPathname === ".") && locationPathname.endsWith("/");
+  if (!path.pathname.endsWith("/") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {
+    path.pathname += "/";
+  }
+  return path;
+}
+var joinPaths = (paths) => paths.join("/").replace(/\/\/+/g, "/");
+var normalizeSearch = (search) => !search || search === "?" ? "" : search.startsWith("?") ? search : "?" + search;
+var normalizeHash = (hash) => !hash || hash === "#" ? "" : hash.startsWith("#") ? hash : "#" + hash;
+var validMutationMethodsArr = ["post", "put", "patch", "delete"];
+var validMutationMethods = new Set(validMutationMethodsArr);
+var validRequestMethodsArr = ["get", ...validMutationMethodsArr];
+var validRequestMethods = new Set(validRequestMethodsArr);
+var UNSAFE_DEFERRED_SYMBOL = Symbol("deferred");
+
+// ../../../node_modules/react-router/dist/index.js
+function _extends2() {
+  _extends2 = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends2.apply(this, arguments);
+}
+var DataRouterContext = /* @__PURE__ */ React.createContext(null);
+if (process.env.NODE_ENV !== "production") {
+  DataRouterContext.displayName = "DataRouter";
+}
+var DataRouterStateContext = /* @__PURE__ */ React.createContext(null);
+if (process.env.NODE_ENV !== "production") {
+  DataRouterStateContext.displayName = "DataRouterState";
+}
+var AwaitContext = /* @__PURE__ */ React.createContext(null);
+if (process.env.NODE_ENV !== "production") {
+  AwaitContext.displayName = "Await";
+}
+var NavigationContext = /* @__PURE__ */ React.createContext(null);
+if (process.env.NODE_ENV !== "production") {
+  NavigationContext.displayName = "Navigation";
+}
+var LocationContext = /* @__PURE__ */ React.createContext(null);
+if (process.env.NODE_ENV !== "production") {
+  LocationContext.displayName = "Location";
+}
+var RouteContext = /* @__PURE__ */ React.createContext({
+  outlet: null,
+  matches: [],
+  isDataRoute: false
+});
+if (process.env.NODE_ENV !== "production") {
+  RouteContext.displayName = "Route";
+}
+var RouteErrorContext = /* @__PURE__ */ React.createContext(null);
+if (process.env.NODE_ENV !== "production") {
+  RouteErrorContext.displayName = "RouteError";
+}
+function useHref(to, _temp) {
+  let {
+    relative
+  } = _temp === void 0 ? {} : _temp;
+  !useInRouterContext() ? process.env.NODE_ENV !== "production" ? invariant(
+    false,
+    // TODO: This error is probably because they somehow have 2 versions of the
+    // router loaded. We can help them understand how to avoid that.
+    "useHref() may be used only in the context of a <Router> component."
+  ) : invariant(false) : void 0;
+  let {
+    basename,
+    navigator
+  } = React.useContext(NavigationContext);
+  let {
+    hash,
+    pathname,
+    search
+  } = useResolvedPath(to, {
+    relative
+  });
+  let joinedPathname = pathname;
+  if (basename !== "/") {
+    joinedPathname = pathname === "/" ? basename : joinPaths([basename, pathname]);
+  }
+  return navigator.createHref({
+    pathname: joinedPathname,
+    search,
+    hash
+  });
+}
+function useInRouterContext() {
+  return React.useContext(LocationContext) != null;
+}
+function useLocation() {
+  !useInRouterContext() ? process.env.NODE_ENV !== "production" ? invariant(
+    false,
+    // TODO: This error is probably because they somehow have 2 versions of the
+    // router loaded. We can help them understand how to avoid that.
+    "useLocation() may be used only in the context of a <Router> component."
+  ) : invariant(false) : void 0;
+  return React.useContext(LocationContext).location;
+}
+var navigateEffectWarning = "You should call navigate() in a React.useEffect(), not when your component is first rendered.";
+function useIsomorphicLayoutEffect2(cb) {
+  let isStatic = React.useContext(NavigationContext).static;
+  if (!isStatic) {
+    React.useLayoutEffect(cb);
+  }
+}
+function useNavigate() {
+  let {
+    isDataRoute
+  } = React.useContext(RouteContext);
+  return isDataRoute ? useNavigateStable() : useNavigateUnstable();
+}
+function useNavigateUnstable() {
+  !useInRouterContext() ? process.env.NODE_ENV !== "production" ? invariant(
+    false,
+    // TODO: This error is probably because they somehow have 2 versions of the
+    // router loaded. We can help them understand how to avoid that.
+    "useNavigate() may be used only in the context of a <Router> component."
+  ) : invariant(false) : void 0;
+  let dataRouterContext = React.useContext(DataRouterContext);
+  let {
+    basename,
+    navigator
+  } = React.useContext(NavigationContext);
+  let {
+    matches
+  } = React.useContext(RouteContext);
+  let {
+    pathname: locationPathname
+  } = useLocation();
+  let routePathnamesJson = JSON.stringify(getPathContributingMatches(matches).map((match) => match.pathnameBase));
+  let activeRef = React.useRef(false);
+  useIsomorphicLayoutEffect2(() => {
+    activeRef.current = true;
+  });
+  let navigate = React.useCallback(function(to, options) {
+    if (options === void 0) {
+      options = {};
+    }
+    process.env.NODE_ENV !== "production" ? warning(activeRef.current, navigateEffectWarning) : void 0;
+    if (!activeRef.current)
+      return;
+    if (typeof to === "number") {
+      navigator.go(to);
+      return;
+    }
+    let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, options.relative === "path");
+    if (dataRouterContext == null && basename !== "/") {
+      path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
+    }
+    (!!options.replace ? navigator.replace : navigator.push)(path, options.state, options);
+  }, [basename, navigator, routePathnamesJson, locationPathname, dataRouterContext]);
+  return navigate;
+}
+function useResolvedPath(to, _temp2) {
+  let {
+    relative
+  } = _temp2 === void 0 ? {} : _temp2;
+  let {
+    matches
+  } = React.useContext(RouteContext);
+  let {
+    pathname: locationPathname
+  } = useLocation();
+  let routePathnamesJson = JSON.stringify(getPathContributingMatches(matches).map((match) => match.pathnameBase));
+  return React.useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, relative === "path"), [to, routePathnamesJson, locationPathname, relative]);
+}
+var DataRouterHook = /* @__PURE__ */ function(DataRouterHook3) {
+  DataRouterHook3["UseBlocker"] = "useBlocker";
+  DataRouterHook3["UseRevalidator"] = "useRevalidator";
+  DataRouterHook3["UseNavigateStable"] = "useNavigate";
+  return DataRouterHook3;
+}(DataRouterHook || {});
+var DataRouterStateHook = /* @__PURE__ */ function(DataRouterStateHook3) {
+  DataRouterStateHook3["UseBlocker"] = "useBlocker";
+  DataRouterStateHook3["UseLoaderData"] = "useLoaderData";
+  DataRouterStateHook3["UseActionData"] = "useActionData";
+  DataRouterStateHook3["UseRouteError"] = "useRouteError";
+  DataRouterStateHook3["UseNavigation"] = "useNavigation";
+  DataRouterStateHook3["UseRouteLoaderData"] = "useRouteLoaderData";
+  DataRouterStateHook3["UseMatches"] = "useMatches";
+  DataRouterStateHook3["UseRevalidator"] = "useRevalidator";
+  DataRouterStateHook3["UseNavigateStable"] = "useNavigate";
+  DataRouterStateHook3["UseRouteId"] = "useRouteId";
+  return DataRouterStateHook3;
+}(DataRouterStateHook || {});
+function getDataRouterConsoleError(hookName) {
+  return hookName + " must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.";
+}
+function useDataRouterContext(hookName) {
+  let ctx = React.useContext(DataRouterContext);
+  !ctx ? process.env.NODE_ENV !== "production" ? invariant(false, getDataRouterConsoleError(hookName)) : invariant(false) : void 0;
+  return ctx;
+}
+function useDataRouterState(hookName) {
+  let state = React.useContext(DataRouterStateContext);
+  !state ? process.env.NODE_ENV !== "production" ? invariant(false, getDataRouterConsoleError(hookName)) : invariant(false) : void 0;
+  return state;
+}
+function useRouteContext(hookName) {
+  let route = React.useContext(RouteContext);
+  !route ? process.env.NODE_ENV !== "production" ? invariant(false, getDataRouterConsoleError(hookName)) : invariant(false) : void 0;
+  return route;
+}
+function useCurrentRouteId(hookName) {
+  let route = useRouteContext(hookName);
+  let thisRoute = route.matches[route.matches.length - 1];
+  !thisRoute.route.id ? process.env.NODE_ENV !== "production" ? invariant(false, hookName + ' can only be used on routes that contain a unique "id"') : invariant(false) : void 0;
+  return thisRoute.route.id;
+}
+function useRouteId() {
+  return useCurrentRouteId(DataRouterStateHook.UseRouteId);
+}
+function useNavigation() {
+  let state = useDataRouterState(DataRouterStateHook.UseNavigation);
+  return state.navigation;
+}
+function useMatches() {
+  let {
+    matches,
+    loaderData
+  } = useDataRouterState(DataRouterStateHook.UseMatches);
+  return React.useMemo(() => matches.map((m) => convertRouteMatchToUiMatch(m, loaderData)), [matches, loaderData]);
+}
+function useNavigateStable() {
+  let {
+    router
+  } = useDataRouterContext(DataRouterHook.UseNavigateStable);
+  let id = useCurrentRouteId(DataRouterStateHook.UseNavigateStable);
+  let activeRef = React.useRef(false);
+  useIsomorphicLayoutEffect2(() => {
+    activeRef.current = true;
+  });
+  let navigate = React.useCallback(function(to, options) {
+    if (options === void 0) {
+      options = {};
+    }
+    process.env.NODE_ENV !== "production" ? warning(activeRef.current, navigateEffectWarning) : void 0;
+    if (!activeRef.current)
+      return;
+    if (typeof to === "number") {
+      router.navigate(to);
+    } else {
+      router.navigate(to, _extends2({
+        fromRouteId: id
+      }, options));
+    }
+  }, [router, id]);
+  return navigate;
+}
+var START_TRANSITION = "startTransition";
+var startTransitionImpl = React[START_TRANSITION];
+function Router(_ref5) {
+  let {
+    basename: basenameProp = "/",
+    children = null,
+    location: locationProp,
+    navigationType = Action.Pop,
+    navigator,
+    static: staticProp = false
+  } = _ref5;
+  !!useInRouterContext() ? process.env.NODE_ENV !== "production" ? invariant(false, "You cannot render a <Router> inside another <Router>. You should never have more than one in your app.") : invariant(false) : void 0;
+  let basename = basenameProp.replace(/^\/*/, "/");
+  let navigationContext = React.useMemo(() => ({
+    basename,
+    navigator,
+    static: staticProp
+  }), [basename, navigator, staticProp]);
+  if (typeof locationProp === "string") {
+    locationProp = parsePath(locationProp);
+  }
+  let {
+    pathname = "/",
+    search = "",
+    hash = "",
+    state = null,
+    key = "default"
+  } = locationProp;
+  let locationContext = React.useMemo(() => {
+    let trailingPathname = stripBasename(pathname, basename);
+    if (trailingPathname == null) {
+      return null;
+    }
+    return {
+      location: {
+        pathname: trailingPathname,
+        search,
+        hash,
+        state,
+        key
+      },
+      navigationType
+    };
+  }, [basename, pathname, search, hash, state, key, navigationType]);
+  process.env.NODE_ENV !== "production" ? warning(locationContext != null, '<Router basename="' + basename + '"> is not able to match the URL ' + ('"' + pathname + search + hash + '" because it does not start with the ') + "basename, so the <Router> won't render anything.") : void 0;
+  if (locationContext == null) {
+    return null;
+  }
+  return /* @__PURE__ */ React.createElement(NavigationContext.Provider, {
+    value: navigationContext
+  }, /* @__PURE__ */ React.createElement(LocationContext.Provider, {
+    children,
+    value: locationContext
+  }));
+}
+var neverSettledPromise = new Promise(() => {
+});
+
+// ../../../node_modules/react-router-dom/dist/index.js
+function _extends3() {
+  _extends3 = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends3.apply(this, arguments);
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null)
+    return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0)
+      continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+var defaultMethod = "get";
+var defaultEncType = "application/x-www-form-urlencoded";
+function isHtmlElement(object) {
+  return object != null && typeof object.tagName === "string";
+}
+function isButtonElement(object) {
+  return isHtmlElement(object) && object.tagName.toLowerCase() === "button";
+}
+function isFormElement(object) {
+  return isHtmlElement(object) && object.tagName.toLowerCase() === "form";
+}
+function isInputElement(object) {
+  return isHtmlElement(object) && object.tagName.toLowerCase() === "input";
+}
+function isModifiedEvent(event) {
+  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);
+}
+function shouldProcessLinkClick(event, target) {
+  return event.button === 0 && // Ignore everything but left clicks
+  (!target || target === "_self") && // Let browser handle "target=_blank" etc.
+  !isModifiedEvent(event);
+}
+var _formDataSupportsSubmitter = null;
+function isFormDataSubmitterSupported() {
+  if (_formDataSupportsSubmitter === null) {
+    try {
+      new FormData(
+        document.createElement("form"),
+        // @ts-expect-error if FormData supports the submitter parameter, this will throw
+        0
+      );
+      _formDataSupportsSubmitter = false;
+    } catch (e) {
+      _formDataSupportsSubmitter = true;
+    }
+  }
+  return _formDataSupportsSubmitter;
+}
+var supportedFormEncTypes = /* @__PURE__ */ new Set(["application/x-www-form-urlencoded", "multipart/form-data", "text/plain"]);
+function getFormEncType(encType) {
+  if (encType != null && !supportedFormEncTypes.has(encType)) {
+    process.env.NODE_ENV !== "production" ? warning(false, '"' + encType + '" is not a valid `encType` for `<Form>`/`<fetcher.Form>` ' + ('and will default to "' + defaultEncType + '"')) : void 0;
+    return null;
+  }
+  return encType;
+}
+function getFormSubmissionInfo(target, basename) {
+  let method;
+  let action;
+  let encType;
+  let formData;
+  let body;
+  if (isFormElement(target)) {
+    let attr = target.getAttribute("action");
+    action = attr ? stripBasename(attr, basename) : null;
+    method = target.getAttribute("method") || defaultMethod;
+    encType = getFormEncType(target.getAttribute("enctype")) || defaultEncType;
+    formData = new FormData(target);
+  } else if (isButtonElement(target) || isInputElement(target) && (target.type === "submit" || target.type === "image")) {
+    let form = target.form;
+    if (form == null) {
+      throw new Error('Cannot submit a <button> or <input type="submit"> without a <form>');
+    }
+    let attr = target.getAttribute("formaction") || form.getAttribute("action");
+    action = attr ? stripBasename(attr, basename) : null;
+    method = target.getAttribute("formmethod") || form.getAttribute("method") || defaultMethod;
+    encType = getFormEncType(target.getAttribute("formenctype")) || getFormEncType(form.getAttribute("enctype")) || defaultEncType;
+    formData = new FormData(form, target);
+    if (!isFormDataSubmitterSupported()) {
+      let {
+        name,
+        type,
+        value
+      } = target;
+      if (type === "image") {
+        let prefix = name ? name + "." : "";
+        formData.append(prefix + "x", "0");
+        formData.append(prefix + "y", "0");
+      } else if (name) {
+        formData.append(name, value);
+      }
+    }
+  } else if (isHtmlElement(target)) {
+    throw new Error('Cannot submit element that is not <form>, <button>, or <input type="submit|image">');
+  } else {
+    method = defaultMethod;
+    action = null;
+    encType = defaultEncType;
+    body = target;
+  }
+  if (formData && encType === "text/plain") {
+    body = formData;
+    formData = void 0;
+  }
+  return {
+    action,
+    method: method.toLowerCase(),
+    encType,
+    formData,
+    body
+  };
+}
+var _excluded = ["onClick", "relative", "reloadDocument", "replace", "state", "target", "to", "preventScrollReset"];
+var _excluded2 = ["aria-current", "caseSensitive", "className", "end", "style", "to", "children"];
+var _excluded3 = ["reloadDocument", "replace", "state", "method", "action", "onSubmit", "submit", "relative", "preventScrollReset"];
+var START_TRANSITION2 = "startTransition";
+var startTransitionImpl2 = React2[START_TRANSITION2];
+function HistoryRouter(_ref3) {
+  let {
+    basename,
+    children,
+    future,
+    history
+  } = _ref3;
+  let [state, setStateImpl] = React2.useState({
+    action: history.action,
+    location: history.location
+  });
+  let {
+    v7_startTransition
+  } = future || {};
+  let setState = React2.useCallback((newState) => {
+    v7_startTransition && startTransitionImpl2 ? startTransitionImpl2(() => setStateImpl(newState)) : setStateImpl(newState);
+  }, [setStateImpl, v7_startTransition]);
+  React2.useLayoutEffect(() => history.listen(setState), [history, setState]);
+  return /* @__PURE__ */ React2.createElement(Router, {
+    basename,
+    children,
+    location: state.location,
+    navigationType: state.action,
+    navigator: history
+  });
+}
+if (process.env.NODE_ENV !== "production") {
+  HistoryRouter.displayName = "unstable_HistoryRouter";
+}
+var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
+var ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+var Link = /* @__PURE__ */ React2.forwardRef(function LinkWithRef(_ref4, ref) {
+  let {
+    onClick,
+    relative,
+    reloadDocument,
+    replace,
+    state,
+    target,
+    to,
+    preventScrollReset
+  } = _ref4, rest = _objectWithoutPropertiesLoose(_ref4, _excluded);
+  let {
+    basename
+  } = React2.useContext(NavigationContext);
+  let absoluteHref;
+  let isExternal = false;
+  if (typeof to === "string" && ABSOLUTE_URL_REGEX.test(to)) {
+    absoluteHref = to;
+    if (isBrowser) {
+      try {
+        let currentUrl = new URL(window.location.href);
+        let targetUrl = to.startsWith("//") ? new URL(currentUrl.protocol + to) : new URL(to);
+        let path = stripBasename(targetUrl.pathname, basename);
+        if (targetUrl.origin === currentUrl.origin && path != null) {
+          to = path + targetUrl.search + targetUrl.hash;
+        } else {
+          isExternal = true;
+        }
+      } catch (e) {
+        process.env.NODE_ENV !== "production" ? warning(false, '<Link to="' + to + '"> contains an invalid URL which will probably break when clicked - please update to a valid URL path.') : void 0;
+      }
+    }
+  }
+  let href = useHref(to, {
+    relative
+  });
+  let internalOnClick = useLinkClickHandler(to, {
+    replace,
+    state,
+    target,
+    preventScrollReset,
+    relative
+  });
+  function handleClick(event) {
+    if (onClick)
+      onClick(event);
+    if (!event.defaultPrevented) {
+      internalOnClick(event);
+    }
+  }
+  return (
+    // eslint-disable-next-line jsx-a11y/anchor-has-content
+    /* @__PURE__ */ React2.createElement("a", _extends3({}, rest, {
+      href: absoluteHref || href,
+      onClick: isExternal || reloadDocument ? onClick : handleClick,
+      ref,
+      target
+    }))
+  );
+});
+if (process.env.NODE_ENV !== "production") {
+  Link.displayName = "Link";
+}
+var NavLink = /* @__PURE__ */ React2.forwardRef(function NavLinkWithRef(_ref5, ref) {
+  let {
+    "aria-current": ariaCurrentProp = "page",
+    caseSensitive = false,
+    className: classNameProp = "",
+    end = false,
+    style: styleProp,
+    to,
+    children
+  } = _ref5, rest = _objectWithoutPropertiesLoose(_ref5, _excluded2);
+  let path = useResolvedPath(to, {
+    relative: rest.relative
+  });
+  let location = useLocation();
+  let routerState = React2.useContext(DataRouterStateContext);
+  let {
+    navigator
+  } = React2.useContext(NavigationContext);
+  let toPathname = navigator.encodeLocation ? navigator.encodeLocation(path).pathname : path.pathname;
+  let locationPathname = location.pathname;
+  let nextLocationPathname = routerState && routerState.navigation && routerState.navigation.location ? routerState.navigation.location.pathname : null;
+  if (!caseSensitive) {
+    locationPathname = locationPathname.toLowerCase();
+    nextLocationPathname = nextLocationPathname ? nextLocationPathname.toLowerCase() : null;
+    toPathname = toPathname.toLowerCase();
+  }
+  let isActive = locationPathname === toPathname || !end && locationPathname.startsWith(toPathname) && locationPathname.charAt(toPathname.length) === "/";
+  let isPending = nextLocationPathname != null && (nextLocationPathname === toPathname || !end && nextLocationPathname.startsWith(toPathname) && nextLocationPathname.charAt(toPathname.length) === "/");
+  let ariaCurrent = isActive ? ariaCurrentProp : void 0;
+  let className;
+  if (typeof classNameProp === "function") {
+    className = classNameProp({
+      isActive,
+      isPending
+    });
+  } else {
+    className = [classNameProp, isActive ? "active" : null, isPending ? "pending" : null].filter(Boolean).join(" ");
+  }
+  let style = typeof styleProp === "function" ? styleProp({
+    isActive,
+    isPending
+  }) : styleProp;
+  return /* @__PURE__ */ React2.createElement(Link, _extends3({}, rest, {
+    "aria-current": ariaCurrent,
+    className,
+    ref,
+    style,
+    to
+  }), typeof children === "function" ? children({
+    isActive,
+    isPending
+  }) : children);
+});
+if (process.env.NODE_ENV !== "production") {
+  NavLink.displayName = "NavLink";
+}
+var Form = /* @__PURE__ */ React2.forwardRef((props, ref) => {
+  let submit = useSubmit();
+  return /* @__PURE__ */ React2.createElement(FormImpl, _extends3({}, props, {
+    submit,
+    ref
+  }));
+});
+if (process.env.NODE_ENV !== "production") {
+  Form.displayName = "Form";
+}
+var FormImpl = /* @__PURE__ */ React2.forwardRef((_ref6, forwardedRef) => {
+  let {
+    reloadDocument,
+    replace,
+    state,
+    method = defaultMethod,
+    action,
+    onSubmit,
+    submit,
+    relative,
+    preventScrollReset
+  } = _ref6, props = _objectWithoutPropertiesLoose(_ref6, _excluded3);
+  let formMethod = method.toLowerCase() === "get" ? "get" : "post";
+  let formAction = useFormAction(action, {
+    relative
+  });
+  let submitHandler = (event) => {
+    onSubmit && onSubmit(event);
+    if (event.defaultPrevented)
+      return;
+    event.preventDefault();
+    let submitter = event.nativeEvent.submitter;
+    let submitMethod = (submitter == null ? void 0 : submitter.getAttribute("formmethod")) || method;
+    submit(submitter || event.currentTarget, {
+      method: submitMethod,
+      replace,
+      state,
+      relative,
+      preventScrollReset
+    });
+  };
+  return /* @__PURE__ */ React2.createElement("form", _extends3({
+    ref: forwardedRef,
+    method: formMethod,
+    action: formAction,
+    onSubmit: reloadDocument ? onSubmit : submitHandler
+  }, props));
+});
+if (process.env.NODE_ENV !== "production") {
+  FormImpl.displayName = "FormImpl";
+}
+function ScrollRestoration(_ref7) {
+  let {
+    getKey,
+    storageKey
+  } = _ref7;
+  useScrollRestoration({
+    getKey,
+    storageKey
+  });
+  return null;
+}
+if (process.env.NODE_ENV !== "production") {
+  ScrollRestoration.displayName = "ScrollRestoration";
+}
+var DataRouterHook2;
+(function(DataRouterHook3) {
+  DataRouterHook3["UseScrollRestoration"] = "useScrollRestoration";
+  DataRouterHook3["UseSubmit"] = "useSubmit";
+  DataRouterHook3["UseSubmitFetcher"] = "useSubmitFetcher";
+  DataRouterHook3["UseFetcher"] = "useFetcher";
+})(DataRouterHook2 || (DataRouterHook2 = {}));
+var DataRouterStateHook2;
+(function(DataRouterStateHook3) {
+  DataRouterStateHook3["UseFetchers"] = "useFetchers";
+  DataRouterStateHook3["UseScrollRestoration"] = "useScrollRestoration";
+})(DataRouterStateHook2 || (DataRouterStateHook2 = {}));
+function getDataRouterConsoleError2(hookName) {
+  return hookName + " must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.";
+}
+function useDataRouterContext2(hookName) {
+  let ctx = React2.useContext(DataRouterContext);
+  !ctx ? process.env.NODE_ENV !== "production" ? invariant(false, getDataRouterConsoleError2(hookName)) : invariant(false) : void 0;
+  return ctx;
+}
+function useDataRouterState2(hookName) {
+  let state = React2.useContext(DataRouterStateContext);
+  !state ? process.env.NODE_ENV !== "production" ? invariant(false, getDataRouterConsoleError2(hookName)) : invariant(false) : void 0;
+  return state;
+}
+function useLinkClickHandler(to, _temp) {
+  let {
+    target,
+    replace: replaceProp,
+    state,
+    preventScrollReset,
+    relative
+  } = _temp === void 0 ? {} : _temp;
+  let navigate = useNavigate();
+  let location = useLocation();
+  let path = useResolvedPath(to, {
+    relative
+  });
+  return React2.useCallback((event) => {
+    if (shouldProcessLinkClick(event, target)) {
+      event.preventDefault();
+      let replace = replaceProp !== void 0 ? replaceProp : createPath(location) === createPath(path);
+      navigate(to, {
+        replace,
+        state,
+        preventScrollReset,
+        relative
+      });
+    }
+  }, [location, navigate, path, replaceProp, state, target, to, preventScrollReset, relative]);
+}
+function validateClientSideSubmission() {
+  if (typeof document === "undefined") {
+    throw new Error("You are calling submit during the server render. Try calling submit within a `useEffect` or callback instead.");
+  }
+}
+function useSubmit() {
+  let {
+    router
+  } = useDataRouterContext2(DataRouterHook2.UseSubmit);
+  let {
+    basename
+  } = React2.useContext(NavigationContext);
+  let currentRouteId = useRouteId();
+  return React2.useCallback(function(target, options) {
+    if (options === void 0) {
+      options = {};
+    }
+    validateClientSideSubmission();
+    let {
+      action,
+      method,
+      encType,
+      formData,
+      body
+    } = getFormSubmissionInfo(target, basename);
+    router.navigate(options.action || action, {
+      preventScrollReset: options.preventScrollReset,
+      formData,
+      body,
+      formMethod: options.method || method,
+      formEncType: options.encType || encType,
+      replace: options.replace,
+      state: options.state,
+      fromRouteId: currentRouteId
+    });
+  }, [router, basename, currentRouteId]);
+}
+function useFormAction(action, _temp2) {
+  let {
+    relative
+  } = _temp2 === void 0 ? {} : _temp2;
+  let {
+    basename
+  } = React2.useContext(NavigationContext);
+  let routeContext = React2.useContext(RouteContext);
+  !routeContext ? process.env.NODE_ENV !== "production" ? invariant(false, "useFormAction must be used inside a RouteContext") : invariant(false) : void 0;
+  let [match] = routeContext.matches.slice(-1);
+  let path = _extends3({}, useResolvedPath(action ? action : ".", {
+    relative
+  }));
+  let location = useLocation();
+  if (action == null) {
+    path.search = location.search;
+    if (match.route.index) {
+      let params = new URLSearchParams(path.search);
+      params.delete("index");
+      path.search = params.toString() ? "?" + params.toString() : "";
+    }
+  }
+  if ((!action || action === ".") && match.route.index) {
+    path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index";
+  }
+  if (basename !== "/") {
+    path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
+  }
+  return createPath(path);
+}
+var SCROLL_RESTORATION_STORAGE_KEY = "react-router-scroll-positions";
+var savedScrollPositions = {};
+function useScrollRestoration(_temp3) {
+  let {
+    getKey,
+    storageKey
+  } = _temp3 === void 0 ? {} : _temp3;
+  let {
+    router
+  } = useDataRouterContext2(DataRouterHook2.UseScrollRestoration);
+  let {
+    restoreScrollPosition,
+    preventScrollReset
+  } = useDataRouterState2(DataRouterStateHook2.UseScrollRestoration);
+  let {
+    basename
+  } = React2.useContext(NavigationContext);
+  let location = useLocation();
+  let matches = useMatches();
+  let navigation = useNavigation();
+  React2.useEffect(() => {
+    window.history.scrollRestoration = "manual";
+    return () => {
+      window.history.scrollRestoration = "auto";
+    };
+  }, []);
+  usePageHide(React2.useCallback(() => {
+    if (navigation.state === "idle") {
+      let key = (getKey ? getKey(location, matches) : null) || location.key;
+      savedScrollPositions[key] = window.scrollY;
+    }
+    sessionStorage.setItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY, JSON.stringify(savedScrollPositions));
+    window.history.scrollRestoration = "auto";
+  }, [storageKey, getKey, navigation.state, location, matches]));
+  if (typeof document !== "undefined") {
+    React2.useLayoutEffect(() => {
+      try {
+        let sessionPositions = sessionStorage.getItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY);
+        if (sessionPositions) {
+          savedScrollPositions = JSON.parse(sessionPositions);
+        }
+      } catch (e) {
+      }
+    }, [storageKey]);
+    React2.useLayoutEffect(() => {
+      let getKeyWithoutBasename = getKey && basename !== "/" ? (location2, matches2) => getKey(
+        // Strip the basename to match useLocation()
+        _extends3({}, location2, {
+          pathname: stripBasename(location2.pathname, basename) || location2.pathname
+        }),
+        matches2
+      ) : getKey;
+      let disableScrollRestoration = router == null ? void 0 : router.enableScrollRestoration(savedScrollPositions, () => window.scrollY, getKeyWithoutBasename);
+      return () => disableScrollRestoration && disableScrollRestoration();
+    }, [router, basename, getKey]);
+    React2.useLayoutEffect(() => {
+      if (restoreScrollPosition === false) {
+        return;
+      }
+      if (typeof restoreScrollPosition === "number") {
+        window.scrollTo(0, restoreScrollPosition);
+        return;
+      }
+      if (location.hash) {
+        let el = document.getElementById(decodeURIComponent(location.hash.slice(1)));
+        if (el) {
+          el.scrollIntoView();
+          return;
+        }
+      }
+      if (preventScrollReset === true) {
+        return;
+      }
+      window.scrollTo(0, 0);
+    }, [location, restoreScrollPosition, preventScrollReset]);
+  }
+}
+function usePageHide(callback, options) {
+  let {
+    capture
+  } = options || {};
+  React2.useEffect(() => {
+    let opts = capture != null ? {
+      capture
+    } : void 0;
+    window.addEventListener("pagehide", callback, opts);
+    return () => {
+      window.removeEventListener("pagehide", callback, opts);
+    };
+  }, [callback, capture]);
+}
+
+// src/styled-components/breadcrumb.ts
+import styled from "styled-components";
+var Breadcrumb = styled.div`
+	font-family: 'Inter', sans-serif;
+	padding: 10px 0px;
+	text-transform: uppercase;
+	font-weight: bold;
+	font-size: 0.9rem;
+	color: #92190e;
+	display: flex;
+	justify-content: space-between;
+	align-items: center;
+	background-color: white;
+	align-items: center;
+
+	.link {
+		color: #92190e;
+		&:hover {
+			color: #92190e;
+			cursor: pointer;
+		}
+	}
+`;
+var BreadCrumbTitle = styled.div`
+	font-family: 'Inter', sans-serif;
+	font-weight: bold;
+	font-size: 1.2rem !important;
+	color: #92190e;
+	margin-top: 15px;
+`;
+var TitlePage = styled.div`
+	font-family: 'Inter', sans-serif;
+	font-weight: bold;
+	font-size: 1.2rem !important;
+	color: #92190e;
+	margin-top: 15px;
+`;
+
+// src/styled-components/menu.ts
+import styled2 from "styled-components";
+var MenuItem = styled2(Link)`
+	text-decoration: none;
+	color: black;
+	display: flex;
+	justify-content: ${(props) => props.type === "col" ? "center" : "flex-start"};
+	align-items: center;
+	flex-direction: ${(props) => props.type === "col" ? "column" : "row"};
+	border: 1px solid transparent;
+	width: ${(props) => props.width ? props.width : "100px"};
+	padding: 10px;
+	text-decoration: none !important;
+	&:hover {
+		box-shadow: rgba(99, 99, 99, 0.2) 0px 2px 8px 0px;
+	}
+
+	.icon {
+		width: 30px;
+		text-decoration: none;
+	}
+	.text {
+		text-align: center;
+		font-size: 12px;
+		text-decoration: none !important;
+		color: black;
+		margin-top: ${(props) => props.type === "col" ? "0px" : "15px"};
+		&:hover {
+			text-decoration: none !important;
+		}
+	}
+`;
+var MenuTitle = styled2.p`
+	font-size: 16px;
+	font-weight: bold !important;
+`;
+
+// src/styled-components/navbar.ts
+import styled3 from "styled-components";
+var Navbar = styled3.nav`
+	background: ${(props) => {
+  return !props.gradient ? ` linear-gradient( 90.03deg, #92190e 80.71%, #f0b92c 107.21% ) !important` : `#92190e`;
+}};
+	z-index: 10;
+	width: 100%;
+	max-width: 100vw;
+	display: flex;
+	justify-content: space-between;
+	padding-top: 10px;
+	padding-bottom: 10px;
+	position: sticky;
+	top: 0px;
+	height: 40px;
+	.input {
+		border-radius: 2px !important;
+		padding: 2px !important;
+		font-size: 12px !important;
+		height: 20px !important;
+		border: none;
+		&:focus {
+			outline: none !important;
+		}
+		::placeholder {
+			color: #92190e;
+		}
+		@media (max-width: 470px) {
+			display: none;
+		}
+	}
+	.dialog {
+		z-index: 20000 !important;
+		position: absolute;
+		width: 400px;
+		height: 500px;
+		min-height: 500px;
+		overflow: scroll;
+		overflow-x: hidden;
+		min-width: 400px;
+		max-width: 400px;
+		background-color: white;
+		border-radius: 20px;
+		top: 50%;
+		left: 50%;
+		transform: translate(-50%, -50%);
+	}
+`;
+
+// src/styled-components/options.ts
+import styled4 from "styled-components";
+var MenuOptions = styled4.div`
+	font-size: bold;
+	display: flex;
+	width: 100%;
+	gap: 10px;
+	justify-content: flex-start;
+	border-bottom: 1px solid #e6e6e6;
+	background-color: white;
+	flex-wrap: wrap;
+	.button-option {
+		display: flex;
+		flex-direction: row;
+		justify-content: space-between;
+		align-items: center;
+		gap: 5px;
+		padding: 10px 20px;
+		font-weight: bold;
+		background-color: white !important;
+		border: none;
+		.icon {
+			color: #92190e;
+		}
+		.text {
+			@media (max-width: 470px) {
+				display: none;
+			}
+		}
+	}
+`;
+
+// src/styled-components/sidebar.ts
+import styled5 from "styled-components";
+var ItemSidebar = styled5.div`
+	padding: 10px 25px;
+	display: flex;
+	align-items: center;
+	gap: 30px;
+	font-family: 'Inter', sans-serif;
+	&:hover {
+		color: white !important;
+		text-decoration: none;
+		background: #92190e;
+		.icon-sidebar {
+			color: white !important;
+		}
+	}
+	&:active {
+		color: white !important;
+		text-decoration: none;
+		background: #92190e;
+		.icon-sidebar {
+			color: white !important;
+		}
+	}
+`;
+var SidebarNavigation = styled5.nav`
+	position: ${({ fixed = true }) => fixed ? "fixed" : "static"};
+	top: 0;
+	left: 0;
+	min-height: 100vh;
+	box-shadow: 7px 0px 14px 1px rgba(145, 141, 141, 0.51);
+	-webkit-box-shadow: 7px 0px 14px 1px rgba(145, 141, 141, 0.51);
+	-moz-box-shadow: 7px 0px 14px 1px rgba(145, 141, 141, 0.51);
+	background: white;
+	font-family: 'Inter', sans-serif;
+	padding: 0;
+	width: ${({ fixed = true, active = true }) => fixed ? active ? "270px" : "0px" : "auto"};
+	z-index: 11;
+	transition: width 0.2s ease-in-out;
+
+	overflow: hidden;
+	height: 100vh;
+	overflow-y: auto;
+	box-shadow: ${({ shadow = true }) => shadow ? "rgba(99, 99, 99, 0.2) 0px 2px 8px 0px" : "none"};
+
+	&::-webkit-scrollbar {
+		display: none !important;
+	}
+	.nav {
+		flex-wrap: nowrap;
+		flex-direction: column;
+		font-size: 12px;
+
+		.nav-item {
+			.collapse {
+				z-index: 999;
+			}
+
+			.collapse.show,
+			.collapsing {
+				background: rgba(0, 0, 0);
+			}
+
+			.nav-link {
+				align-items: center;
+				display: flex;
+				padding-left: 40px;
+				white-space: nowrap;
+
+				color: #92190e;
+				i {
+					margin-right: 20px;
+				}
+				.menu-title {
+					color: inherit;
+					display: inline-block;
+					line-height: 1;
+					color: black;
+					vertical-align: middle;
+					cursor: pointer;
+				}
+			}
+
+			&.active {
+				> .nav-link {
+					color: white;
+				}
+
+				&.not-navigation-link {
+					position: relative;
+				}
+			}
+
+			&:not(.sub-menu) {
+				> .nav-item {
+					&:hover {
+						&:not(.nav-profile) {
+							> .nav-link {
+								background: $sidebar-light-menu-hover-bg;
+								color: $sidebar-light-menu-hover-color;
+							}
+						}
+					}
+				}
+			}
+
+			&.sub-menu {
+				margin-bottom: 0;
+				padding: $sidebar-submenu-padding;
+
+				.rtl & {
+					padding: 0 4rem 0 0;
+				}
+
+				.nav-item {
+					.nav-link {
+						color: $sidebar-light-submenu-color;
+						padding: $sidebar-submenu-item-padding;
+						font-size: $sidebar-submenu-font-size;
+						line-height: 1;
+						height: auto;
+
+						&.active {
+							color: $sidebar-light-menu-active-color;
+							background: transparent;
+
+							&:before {
+								background: $sidebar-light-menu-active-color;
+							}
+						}
+					}
+
+					&:hover {
+						> .nav-link {
+							background: $sidebar-light-submenu-hover-bg;
+							color: $sidebar-light-submenu-hover-color;
+
+							&:before {
+								background: $sidebar-light-submenu-hover-color;
+							}
+						}
+					}
+				}
+			}
+
+			&.sub-menu2 {
+				margin-bottom: 0;
+				padding: $sidebar-submenu2-padding;
+
+				.rtl & {
+					padding: 0 4rem 0 0;
+				}
+
+				.nav-item {
+					.nav-link {
+						color: $sidebar-light-submenu-color;
+						padding: $sidebar-submenu-item-padding;
+						font-size: $sidebar-submenu-font-size;
+						line-height: 1;
+						height: auto;
+
+						&.active {
+							color: $sidebar-light-menu-active-color;
+							background: transparent;
+
+							&:before {
+								background: $sidebar-light-menu-active-color;
+							}
+						}
+					}
+
+					&:hover {
+						> .nav-link {
+							background: $sidebar-light-submenu-hover-bg;
+							color: $sidebar-light-submenu-hover-color;
+
+							&:before {
+								background: $sidebar-light-submenu-hover-color;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+`;
+var ConfigurationOption = styled5.nav`
+	position: fixed;
+	top: 50px;
+	right: 0;
+	min-height: 100vh;
+	box-shadow: 7px 0px 14px 1px rgba(201, 196, 196, 0.51);
+	-webkit-box-shadow: 7px 0px 14px 1px rgba(201, 196, 196, 0.51);
+	-moz-box-shadow: 7px 0px 14px 1px rgba(201, 196, 196, 0.51);
+	min-height: calc(100vh);
+
+	font-family: 'Inter', sans-serif;
+	padding: 0;
+	width: ${(props) => props.active ? "300px" : "0px"};
+	z-index: 11;
+	transition: width 0.2s ease-in-out;
+	overflow: hidden !important;
+`;
+var ItemLinkSidebar = styled5(Link)`
+	padding: 10px 25px;
+	display: flex;
+	align-items: center;
+	gap: 30px;
+	color: #343a40;
+	text-decoration: none;
+	font-family: 'Inter', sans-serif;
+	&:hover {
+		color: white !important;
+		text-decoration: none;
+		background: #92190e;
+		.icon-sidebar {
+			color: white !important;
+		}
+	}
+`;
+
+// src/styled-components/template.ts
+import styled6 from "styled-components";
+var Main = styled6.main`
+	width: 100%;
+	min-height: 90vh;
+	display: flex;
+	flex-direction: column;
+	justify-content: space-between;
+	background-color: white;
+	padding: 10px 60px;
+	position: relative;
+	padding-left: ${(props) => {
+  return props.activeDrawer ? `300px` : `30px`;
+}};
+	@media (max-width: 470px) {
+		padding: 10px 10px;
+	}
+`;
+var CloseIcon = styled6.button`
+	color: black;
+	text-decoration: none;
+	border: none;
+	padding: 10px 10px;
+	background-color: white;
+	border-radius: 50%;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	cursor: pointer;
+	top: 10px;
+	right: 10px;
+	text-align: center;
+	&:hover {
+		color: black;
+		text-decoration: none;
+		background-color: #e8e8e8;
+	}
+`;
+
+// src/layout/AppBreadcrumb.tsx
+import { jsx as jsx10, jsxs as jsxs4 } from "react/jsx-runtime";
+var AppBreadCrumb = ({ title, paths }) => {
+  const { setRoutes } = useContext4(BreadCrumbContext);
+  useEffect9(() => {
+    if (!(paths == null ? void 0 : paths.length))
+      return;
+    setRoutes(paths != null ? paths : []);
+  }, []);
+  return /* @__PURE__ */ jsx10(BreadCrumbTitle, { children: title != null ? title : "Home" });
+};
+var AppBreadCrumbNav = ({ paths }) => {
+  const { active, path, routes, setRoutes } = useContext4(BreadCrumbContext);
+  const navigate = useNavigate();
+  const { updateList } = useContext4(HistoryContext);
+  useEffect9(() => {
+    updateList({ name: active, path });
+  }, [path, active]);
+  useEffect9(() => {
+    setRoutes(paths != null ? paths : []);
+  }, [paths]);
+  return /* @__PURE__ */ jsxs4(Breadcrumb, { children: [
+    /* @__PURE__ */ jsxs4("div", { className: "d-flex align-items-center", children: [
+      /* @__PURE__ */ jsx10(Link, { to: "/", className: "link", children: "HOME" }),
+      routes.length > 0 && /* @__PURE__ */ jsx10(VscChevronRight, { color: "black" }),
+      routes.length > 0 ? routes.map((i, idx, arr) => {
+        if (i.route === -1) {
+          return /* @__PURE__ */ jsxs4("span", { className: "link", onClick: () => navigate(-1), children: [
+            i.title,
+            " ",
+            idx + 1 === arr.length ? "" : /* @__PURE__ */ jsx10(VscChevronRight, { color: "black" })
+          ] }, idx);
+        }
+        return /* @__PURE__ */ jsxs4(Link, { to: i.route, className: "link", children: [
+          i.title,
+          " ",
+          idx + 1 === arr.length ? "" : /* @__PURE__ */ jsx10(VscChevronRight, { color: "black" })
+        ] }, idx);
+      }) : ""
+    ] }),
+    /* @__PURE__ */ jsx10(
+      CloseIcon,
+      {
+        onClick: () => {
+          if ((routes == null ? void 0 : routes.length) === 1) {
+            navigate("/");
+            setRoutes([]);
+            return;
+          }
+          navigate(`${routes && routes[(routes == null ? void 0 : routes.length) - 2].route}`);
+        },
+        children: /* @__PURE__ */ jsx10(MdClose, { fontSize: 20 })
+      }
+    )
+  ] });
+};
+
+// src/layout/AppLoader.tsx
+import { useEffect as useEffect10 } from "react";
+import ReactDOM from "react-dom";
+import { jsx as jsx11, jsxs as jsxs5 } from "react/jsx-runtime";
+var LoaderGrid = () => {
+  const Loader = /* @__PURE__ */ jsxs5("div", { className: "k-loading-mask", children: [
+    /* @__PURE__ */ jsx11("span", { className: "k-loading-text", children: "Loading" }),
+    /* @__PURE__ */ jsx11("div", { className: "k-loading-image" }),
+    /* @__PURE__ */ jsx11("div", { className: "k-loading-color" })
+  ] });
+  const gridContent = document && document.querySelector(".k-grid-content");
+  const reportContent = document && document.querySelector(".loading-report");
+  return gridContent ? ReactDOM.createPortal(Loader, gridContent) : reportContent ? ReactDOM.createPortal(Loader, reportContent) : Loader;
+};
+var AppLoader = (props) => {
+  const { type = "grid", parent, minDuration } = props;
+  const parentEl = type === "grid" ? document.querySelector(parent != null ? parent : ".k-grid-container") : parent ? document.querySelector(parent) : null;
+  const Loading = /* @__PURE__ */ jsxs5("div", { className: `${type}-loading k-loading-mask`, children: [
+    /* @__PURE__ */ jsx11("span", { className: "k-loading-text", children: "Loading" }),
+    /* @__PURE__ */ jsx11("div", { className: "k-loading-image" }),
+    /* @__PURE__ */ jsx11("div", { className: "k-loading-color" })
+  ] });
+  useEffect10(() => {
+    if (type === "button") {
+      const loadingEl = document.createElement("div");
+      loadingEl.className = "icon button-loading k-loading-mask";
+      loadingEl.innerHTML = `
+            <div class="k-loading-image"></div>
+        `;
+      if (parentEl) {
+        const button = parentEl;
+        button.classList.add("btn-loading");
+        button.disabled = true;
+        button.insertBefore(loadingEl, button.firstChild);
+      }
+      return () => {
+        if (parentEl) {
+          if (minDuration) {
+            setTimeout(() => {
+              const button = parentEl;
+              button.classList.remove("btn-loading");
+              button.removeChild(loadingEl);
+              button.disabled = false;
+            }, minDuration);
+          } else {
+            const button = parentEl;
+            button.classList.remove("btn-loading");
+            button.removeChild(loadingEl);
+            button.disabled = false;
+          }
+        }
+      };
+    }
+  }, []);
+  return type === "button" ? null : parentEl ? ReactDOM.createPortal(Loading, parentEl) : Loading;
+};
+
+// src/layout/NavOptions.tsx
+import { Dropdown } from "react-bootstrap";
+import { BsArrowsFullscreen } from "react-icons/bs";
+import { FiCheckCircle, FiFilter, FiPlusSquare, FiRefreshCcw, FiSave } from "react-icons/fi";
+import { jsx as jsx12, jsxs as jsxs6 } from "react/jsx-runtime";
+var NavOptions = ({
+  exportExcel,
+  customButtons,
+  onCreate,
+  onRefresh,
+  onSelect,
+  onClear,
+  onExpandScreen
+}) => {
+  return /* @__PURE__ */ jsxs6(MenuOptions, { children: [
+    onCreate && /* @__PURE__ */ jsxs6("button", { className: "button-option", onClick: onCreate, children: [
+      /* @__PURE__ */ jsx12(FiPlusSquare, { className: "icon" }),
+      " ",
+      /* @__PURE__ */ jsx12("span", { className: "text", children: "New" })
+    ] }),
+    onRefresh && /* @__PURE__ */ jsxs6("button", { className: "button-option", onClick: onRefresh, children: [
+      /* @__PURE__ */ jsx12(FiRefreshCcw, { className: "icon" }),
+      " ",
+      /* @__PURE__ */ jsx12("span", { className: "text", children: "Refresh" })
+    ] }),
+    exportExcel && exportExcel.length > 0 && /* @__PURE__ */ jsxs6(Dropdown, { className: "button-option", children: [
+      /* @__PURE__ */ jsxs6(
+        Dropdown.Toggle,
+        {
+          id: "btnExport",
+          className: "p-2 bg-light text-dark border-0 font-weight-bold",
+          title: "Export to Excel",
+          children: [
+            /* @__PURE__ */ jsx12(FiSave, { className: "icon" }),
+            /* @__PURE__ */ jsx12(
+              "span",
+              {
+                style: {
+                  fontSize: "13px",
+                  fontFamily: '"Inter", sans-serif'
+                },
+                className: "text",
+                children: "Export"
+              }
+            )
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx12(Dropdown.Menu, { children: exportExcel.map((item, index) => {
+        return /* @__PURE__ */ jsxs6(Dropdown.Item, { onClick: item.onAction, children: [
+          /* @__PURE__ */ jsx12("i", { className: `${item.classNameIcon}   mr-2` }),
+          " ",
+          item.title
+        ] }, index);
+      }) })
+    ] }),
+    onSelect && /* @__PURE__ */ jsxs6("button", { className: "button-option", onClick: onSelect, children: [
+      /* @__PURE__ */ jsx12(FiCheckCircle, { className: "icon" }),
+      " ",
+      /* @__PURE__ */ jsx12("span", { className: "text", children: "Select All" })
+    ] }),
+    onClear && /* @__PURE__ */ jsxs6("button", { className: "button-option", onClick: onClear, children: [
+      /* @__PURE__ */ jsx12(FiFilter, { className: "icon" }),
+      " ",
+      /* @__PURE__ */ jsx12("span", { className: "text", children: "Clear Filters" })
+    ] }),
+    onExpandScreen && /* @__PURE__ */ jsxs6("button", { className: "button-option", onClick: onExpandScreen, children: [
+      /* @__PURE__ */ jsx12(BsArrowsFullscreen, { className: "icon" }),
+      " ",
+      /* @__PURE__ */ jsx12("span", { className: "text", children: "Full Page" })
+    ] }),
+    customButtons == null ? void 0 : customButtons.map((custom, index) => {
+      if (custom.render) {
+        return custom.render;
+      }
+      return /* @__PURE__ */ jsxs6("button", { className: "button-option", onClick: custom.onAction, children: [
+        custom.Icon !== void 0 && /* @__PURE__ */ jsx12(custom.Icon, { className: "icon" }),
+        /* @__PURE__ */ jsx12("span", { className: "text", children: custom.title })
+      ] }, index);
+    })
+  ] });
+};
+
+// src/layout/title.tsx
+import { jsx as jsx13 } from "react/jsx-runtime";
+var Title = ({ title }) => {
+  return /* @__PURE__ */ jsx13(TitlePage, { children: title != null ? title : "Home" });
+};
+export {
+  AppBreadCrumb,
+  AppBreadCrumbNav,
+  AppLoader,
+  BreadCrumbContext,
+  BreadCrumbContextProvider,
+  BreadCrumbTitle,
+  Breadcrumb,
+  Button,
+  CloseIcon,
+  DrawerContext,
+  DrawerContextProvider,
+  DropEnumList,
+  GlobalProvider,
+  HistoryContext,
+  HistoryContextProvider,
+  ItemLinkSidebar,
+  ItemSidebar,
+  LoaderGrid,
+  Main,
+  MenuItem,
+  MenuOptions,
+  MenuTitle,
+  NavOptions,
+  Navbar,
+  SidebarMainContext,
+  SidebarMainContextProvider,
+  SidebarNavigation,
+  Tab,
+  Tabs,
+  Title,
+  useLocalStorage,
+  usePrevious,
+  useStep
+};
+/*! Bundled license information:
+
+@remix-run/router/dist/router.js:
+  (**
+   * @remix-run/router v1.9.0
+   *
+   * Copyright (c) Remix Software Inc.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE.md file in the root directory of this source tree.
+   *
+   * @license MIT
+   *)
+
+react-router/dist/index.js:
+  (**
+   * React Router v6.16.0
+   *
+   * Copyright (c) Remix Software Inc.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE.md file in the root directory of this source tree.
+   *
+   * @license MIT
+   *)
+
+react-router-dom/dist/index.js:
+  (**
+   * React Router DOM v6.16.0
+   *
+   * Copyright (c) Remix Software Inc.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE.md file in the root directory of this source tree.
+   *
+   * @license MIT
+   *)
+*/