@duskmoon-dev/components 0.1.2

package/dist/components/dm-pro-table/index.js

@@ -0,0 +1,3076 @@
+"use client";
+
+// ../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
+function r(e) {
+  var t, f, n = "";
+  if (typeof e == "string" || typeof e == "number")
+    n += e;
+  else if (typeof e == "object")
+    if (Array.isArray(e)) {
+      var o = e.length;
+      for (t = 0;t < o; t++)
+        e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+    } else
+      for (f in e)
+        e[f] && (n && (n += " "), n += f);
+  return n;
+}
+function clsx() {
+  for (var e, t, f = 0, n = "", o = arguments.length;f < o; f++)
+    (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
+
+// src/utils/cn.ts
+function cn(...inputs) {
+  return clsx(inputs);
+}
+// src/classes/button.ts
+var buttonBaseClass = "btn";
+var buttonColorClasses = {
+  primary: "btn-primary",
+  secondary: "btn-secondary",
+  tertiary: "btn-tertiary",
+  info: "btn-info",
+  success: "btn-success",
+  warning: "btn-warning",
+  error: "btn-error"
+};
+var buttonAppearanceClasses = {
+  filled: "",
+  outline: "btn-outline",
+  tonal: "btn-tonal",
+  ghost: "btn-ghost",
+  text: "btn-text"
+};
+var buttonShapeClasses = {
+  rect: "",
+  circle: "btn-circle",
+  square: "btn-square"
+};
+var buttonSizeClasses = {
+  xs: "btn-xs",
+  sm: "btn-sm",
+  md: "btn-md",
+  lg: "btn-lg"
+};
+var buttonBlockClass = "btn-block";
+var buttonIsLoadingClass = "btn-loading";
+function getButtonClasses({
+  color = "primary",
+  appearance = "filled",
+  shape = "rect",
+  size = "md",
+  block,
+  isLoading,
+  className
+}) {
+  return cn(buttonBaseClass, buttonColorClasses[color], buttonAppearanceClasses[appearance], buttonShapeClasses[shape], buttonSizeClasses[size], block && buttonBlockClass, isLoading && buttonIsLoadingClass, className);
+}
+
+// src/components/button/Button.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function Button({
+  color = "primary",
+  appearance = "filled",
+  shape = "rect",
+  size = "md",
+  block,
+  isLoading,
+  leftIcon,
+  rightIcon,
+  className,
+  children,
+  disabled,
+  ref,
+  ...props
+}) {
+  const classes = getButtonClasses({
+    color,
+    appearance,
+    shape,
+    size,
+    block,
+    isLoading,
+    className
+  });
+  return /* @__PURE__ */ jsxs("button", {
+    ref,
+    className: classes,
+    disabled: disabled || isLoading,
+    "aria-busy": isLoading,
+    "aria-disabled": disabled || isLoading,
+    ...props,
+    children: [
+      isLoading && /* @__PURE__ */ jsx("span", {
+        className: "btn-spinner"
+      }),
+      !isLoading && leftIcon && /* @__PURE__ */ jsx("span", {
+        className: "btn-icon-left",
+        children: leftIcon
+      }),
+      /* @__PURE__ */ jsx("span", {
+        className: "btn-content",
+        children
+      }),
+      !isLoading && rightIcon && /* @__PURE__ */ jsx("span", {
+        className: "btn-icon-right",
+        children: rightIcon
+      })
+    ]
+  });
+}
+// src/classes/card.ts
+var cardBaseClass = "card";
+var cardAppearanceClasses = {
+  elevated: "card-elevated",
+  outline: "card-outline",
+  filled: "card-filled"
+};
+var cardPaddingClasses = {
+  none: "card-padding-none",
+  sm: "card-padding-sm",
+  md: "card-padding-md",
+  lg: "card-padding-lg"
+};
+function getCardClasses({
+  appearance = "elevated",
+  padding = "md",
+  className
+}) {
+  return cn(cardBaseClass, cardAppearanceClasses[appearance], cardPaddingClasses[padding], className);
+}
+
+// src/components/card/Card.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function Card({
+  appearance = "elevated",
+  padding = "md",
+  className,
+  children,
+  ref,
+  ...props
+}) {
+  const classes = getCardClasses({
+    appearance,
+    padding,
+    className
+  });
+  return /* @__PURE__ */ jsx2("div", {
+    ref,
+    className: classes,
+    ...props,
+    children
+  });
+}
+// src/components/date-picker/DatePicker.tsx
+import { forwardRef, useMemo, useState } from "react";
+
+// src/classes/date-picker.ts
+var datePickerBaseClass = "datepicker";
+var datePickerInputClass = "datepicker-input";
+var datePickerIconClass = "datepicker-icon";
+var datePickerDropdownClass = "datepicker-dropdown";
+var datePickerDropdownOpenClass = "datepicker-dropdown-open";
+var datePickerFooterClass = "datepicker-footer";
+var datePickerPresetClass = "datepicker-preset";
+var datePickerRangeClass = "datepicker-range";
+var datePickerSeparatorClass = "datepicker-range-separator";
+var datePickerClearClass = "datepicker-clear";
+var datePickerSizeClasses = {
+  sm: "datepicker-sm",
+  md: "",
+  lg: "datepicker-lg"
+};
+var datePickerStatusClasses = {
+  error: "datepicker-error",
+  success: "datepicker-success"
+};
+var datePickerPickerClasses = {
+  date: "",
+  week: "datepicker-week",
+  month: "datepicker-month-picker",
+  quarter: "datepicker-quarter-picker",
+  year: "datepicker-year-picker",
+  time: "datepicker-time-picker"
+};
+function getDatePickerClasses({
+  size = "md",
+  status,
+  picker = "date",
+  open,
+  disabled,
+  range,
+  className
+}) {
+  return cn(datePickerBaseClass, datePickerSizeClasses[size], status && datePickerStatusClasses[status], datePickerPickerClasses[picker], open && "datepicker-open", disabled && "datepicker-disabled", range && datePickerRangeClass, className);
+}
+function getDatePickerDropdownClasses({
+  open,
+  className
+}) {
+  return cn(datePickerDropdownClass, open && datePickerDropdownOpenClass, className);
+}
+
+// src/components/date-picker/DatePicker.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function todayValue(picker) {
+  const today = new Date;
+  const year = today.getFullYear();
+  const month = String(today.getMonth() + 1).padStart(2, "0");
+  const day = String(today.getDate()).padStart(2, "0");
+  if (picker === "month")
+    return `${year}-${month}`;
+  if (picker === "year")
+    return String(year);
+  if (picker === "time")
+    return "00:00";
+  return `${year}-${month}-${day}`;
+}
+function inputTypeForPicker(picker) {
+  if (picker === "month")
+    return "month";
+  if (picker === "week")
+    return "week";
+  if (picker === "time")
+    return "time";
+  return picker === "year" || picker === "quarter" ? "text" : "date";
+}
+function placeholderForPicker(picker) {
+  if (picker === "month")
+    return "Select month";
+  if (picker === "week")
+    return "Select week";
+  if (picker === "quarter")
+    return "Select quarter";
+  if (picker === "year")
+    return "Select year";
+  if (picker === "time")
+    return "Select time";
+  return "Select date";
+}
+function normalizeDateValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+var DatePickerRoot = forwardRef(({
+  allowClear,
+  className,
+  defaultOpen,
+  defaultValue,
+  disabled,
+  disabledDate,
+  onBlur,
+  onChange,
+  onFocus,
+  onOpenChange,
+  open,
+  picker = "date",
+  placeholder,
+  presets,
+  showNow,
+  size = "md",
+  status,
+  value,
+  ...props
+}, ref) => {
+  const isValueControlled = value !== undefined;
+  const isOpenControlled = open !== undefined;
+  const [innerValue, setInnerValue] = useState(() => normalizeDateValue(defaultValue));
+  const [innerOpen, setInnerOpen] = useState(Boolean(defaultOpen));
+  const currentValue = isValueControlled ? normalizeDateValue(value) : innerValue;
+  const visible = isOpenControlled ? Boolean(open) : innerOpen;
+  const inputType = inputTypeForPicker(picker);
+  function setVisible(nextOpen) {
+    if (!isOpenControlled) {
+      setInnerOpen(nextOpen);
+    }
+    onOpenChange?.(nextOpen);
+  }
+  function emitChange(nextValue) {
+    if (nextValue && disabledDate?.(nextValue)) {
+      return;
+    }
+    if (!isValueControlled) {
+      setInnerValue(nextValue);
+    }
+    onChange?.(nextValue, nextValue ?? "");
+  }
+  const presetItems = useMemo(() => presets ?? [], [presets]);
+  return /* @__PURE__ */ jsxs2("div", {
+    ...props,
+    ref,
+    className: getDatePickerClasses({
+      size,
+      status,
+      picker,
+      open: visible,
+      disabled,
+      className
+    }),
+    children: [
+      /* @__PURE__ */ jsx3("input", {
+        className: datePickerInputClass,
+        disabled,
+        type: inputType,
+        value: currentValue ?? "",
+        placeholder: placeholder ?? placeholderForPicker(picker),
+        onFocus: (event) => {
+          onFocus?.(event);
+          setVisible(true);
+        },
+        onBlur: (event) => {
+          onBlur?.(event);
+          setVisible(false);
+        },
+        onChange: (event) => emitChange(event.currentTarget.value || undefined)
+      }),
+      allowClear && currentValue && !disabled ? /* @__PURE__ */ jsx3("button", {
+        type: "button",
+        className: datePickerClearClass,
+        "aria-label": "Clear date",
+        onMouseDown: (event) => event.preventDefault(),
+        onClick: () => emitChange(undefined),
+        children: "x"
+      }) : null,
+      /* @__PURE__ */ jsx3("span", {
+        className: datePickerIconClass,
+        "aria-hidden": "true",
+        children: "calendar"
+      }),
+      (presetItems.length > 0 || showNow) && visible ? /* @__PURE__ */ jsxs2("div", {
+        className: getDatePickerDropdownClasses({ open: visible }),
+        children: [
+          presetItems.map((preset, index) => /* @__PURE__ */ jsx3("button", {
+            type: "button",
+            className: datePickerPresetClass,
+            onMouseDown: (event) => event.preventDefault(),
+            onClick: () => emitChange(preset.value),
+            children: preset.label
+          }, index)),
+          showNow ? /* @__PURE__ */ jsx3("div", {
+            className: datePickerFooterClass,
+            children: /* @__PURE__ */ jsx3("button", {
+              type: "button",
+              onMouseDown: (event) => event.preventDefault(),
+              onClick: () => emitChange(todayValue(picker)),
+              children: "Now"
+            })
+          }) : null
+        ]
+      }) : null
+    ]
+  });
+});
+DatePickerRoot.displayName = "DatePicker";
+var RangePicker = forwardRef(({
+  allowClear,
+  className,
+  defaultValue,
+  disabled,
+  disabledDate,
+  onChange,
+  picker = "date",
+  placeholder,
+  separator = "-",
+  size = "md",
+  status,
+  value,
+  ...props
+}, ref) => {
+  const isControlled = value !== undefined;
+  const [innerValue, setInnerValue] = useState(defaultValue ?? [undefined, undefined]);
+  const currentValue = isControlled ? value : innerValue;
+  const inputType = inputTypeForPicker(picker);
+  function emitChange(nextValue) {
+    if (nextValue.some((item) => item !== undefined && Boolean(disabledDate?.(item)))) {
+      return;
+    }
+    if (!isControlled) {
+      setInnerValue(nextValue);
+    }
+    onChange?.(nextValue, [nextValue[0] ?? "", nextValue[1] ?? ""]);
+  }
+  function updateIndex(index, nextItem) {
+    emitChange(index === 0 ? [nextItem, currentValue?.[1]] : [currentValue?.[0], nextItem]);
+  }
+  return /* @__PURE__ */ jsxs2("div", {
+    ...props,
+    ref,
+    className: getDatePickerClasses({
+      size,
+      status,
+      picker,
+      disabled,
+      range: true,
+      className
+    }),
+    children: [
+      /* @__PURE__ */ jsx3("input", {
+        className: datePickerInputClass,
+        disabled,
+        type: inputType,
+        value: currentValue?.[0] ?? "",
+        placeholder: Array.isArray(placeholder) ? placeholder[0] : "Start date",
+        onChange: (event) => updateIndex(0, event.currentTarget.value || undefined)
+      }),
+      /* @__PURE__ */ jsx3("span", {
+        className: datePickerSeparatorClass,
+        children: separator
+      }),
+      /* @__PURE__ */ jsx3("input", {
+        className: datePickerInputClass,
+        disabled,
+        type: inputType,
+        value: currentValue?.[1] ?? "",
+        placeholder: Array.isArray(placeholder) ? placeholder[1] : "End date",
+        onChange: (event) => updateIndex(1, event.currentTarget.value || undefined)
+      }),
+      allowClear && (currentValue?.[0] || currentValue?.[1]) && !disabled ? /* @__PURE__ */ jsx3("button", {
+        type: "button",
+        className: datePickerClearClass,
+        "aria-label": "Clear date range",
+        onClick: () => emitChange([undefined, undefined]),
+        children: "x"
+      }) : null
+    ]
+  });
+});
+RangePicker.displayName = "DatePicker.RangePicker";
+function withPicker(picker, displayName) {
+  const Picker = forwardRef((props, ref) => /* @__PURE__ */ jsx3(DatePickerRoot, {
+    ...props,
+    ref,
+    picker
+  }));
+  Picker.displayName = displayName;
+  return Picker;
+}
+var DatePicker = Object.assign(DatePickerRoot, {
+  RangePicker,
+  WeekPicker: withPicker("week", "DatePicker.WeekPicker"),
+  MonthPicker: withPicker("month", "DatePicker.MonthPicker"),
+  QuarterPicker: withPicker("quarter", "DatePicker.QuarterPicker"),
+  YearPicker: withPicker("year", "DatePicker.YearPicker")
+});
+// src/components/dropdown/Dropdown.tsx
+import {
+  cloneElement,
+  forwardRef as forwardRef2,
+  isValidElement,
+  useId,
+  useState as useState2
+} from "react";
+
+// src/classes/dropdown.ts
+var dropdownWrapperClass = "dropdown-wrapper";
+var dropdownBaseClass = "popover dropdown";
+var dropdownOpenClass = "popover-show dropdown-open";
+var dropdownArrowClass = "popover-arrow dropdown-arrow";
+var dropdownMenuClass = "menu dropdown-menu";
+var dropdownButtonClass = "dropdown-button";
+var dropdownPlacementClasses = {
+  top: "popover-top dropdown-top",
+  bottom: "popover-bottom dropdown-bottom",
+  left: "popover-left dropdown-left",
+  right: "popover-right dropdown-right",
+  topLeft: "popover-top dropdown-top-left",
+  topRight: "popover-top dropdown-top-right",
+  bottomLeft: "popover-bottom dropdown-bottom-left",
+  bottomRight: "popover-bottom dropdown-bottom-right"
+};
+function getDropdownClasses({
+  placement = "bottomLeft",
+  open,
+  arrow,
+  className
+}) {
+  return cn(dropdownBaseClass, dropdownPlacementClasses[placement], open && dropdownOpenClass, !arrow && "popover-no-arrow dropdown-no-arrow", className);
+}
+
+// src/classes/menu.ts
+var menuBaseClass = "menu";
+var menuShowClass = "menu-show";
+var menuItemClass = "menu-item";
+var menuItemActiveClass = "menu-item-active";
+var menuItemDisabledClass = "menu-item-disabled";
+var menuItemIconClass = "menu-item-icon";
+var menuItemTrailingClass = "menu-item-trailing";
+var menuItemSubmenuClass = "menu-item-submenu";
+var menuDividerClass = "menu-divider";
+var menuLabelClass = "menu-label";
+var menuSubmenuClass = "menu-submenu";
+var menuCompactClass = "menu-compact";
+var menuWideClass = "menu-wide";
+var menuModeClasses = {
+  vertical: "menu-vertical",
+  horizontal: "menu-horizontal",
+  inline: "menu-inline"
+};
+var menuThemeClasses = {
+  light: "",
+  dark: "menu-dark menu-surface-container-highest"
+};
+var menuSizeClasses = {
+  sm: menuCompactClass,
+  md: "",
+  lg: menuWideClass
+};
+function getMenuClasses({
+  mode = "vertical",
+  theme = "light",
+  size = "md",
+  inlineCollapsed,
+  disabled,
+  className
+}) {
+  return cn(menuBaseClass, menuShowClass, menuModeClasses[mode], menuThemeClasses[theme], menuSizeClasses[size], inlineCollapsed && "menu-inline-collapsed", disabled && menuItemDisabledClass, className);
+}
+function getMenuItemClasses({
+  active,
+  disabled,
+  danger,
+  submenu,
+  className
+}) {
+  return cn(menuItemClass, active && menuItemActiveClass, disabled && menuItemDisabledClass, danger && "menu-item-danger", submenu && menuItemSubmenuClass, className);
+}
+
+// src/components/dropdown/Dropdown.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function hasTrigger(triggers, trigger) {
+  return (triggers ?? ["hover"]).includes(trigger);
+}
+function callHandler(handler, event) {
+  handler?.(event);
+}
+function renderMenuItem(item, onClick, close) {
+  if (item.type === "divider") {
+    return /* @__PURE__ */ jsx4("li", {
+      className: menuDividerClass
+    }, String(item.key));
+  }
+  return /* @__PURE__ */ jsx4("li", {
+    children: /* @__PURE__ */ jsxs3("button", {
+      type: "button",
+      className: cn(menuItemClass, item.danger && "menu-item-danger", item.className),
+      disabled: item.disabled,
+      onClick: (event) => {
+        onClick?.({ key: String(item.key), item, domEvent: event });
+        close();
+      },
+      children: [
+        item.icon ? /* @__PURE__ */ jsx4("span", {
+          className: "menu-item-icon",
+          children: item.icon
+        }) : null,
+        /* @__PURE__ */ jsx4("span", {
+          children: item.label
+        })
+      ]
+    })
+  }, String(item.key));
+}
+var DropdownRoot = forwardRef2(({
+  arrow,
+  children,
+  className,
+  defaultOpen,
+  destroyPopupOnHide,
+  disabled,
+  dropdownRender,
+  menu,
+  onContextMenu,
+  onClick,
+  onMouseEnter,
+  onMouseLeave,
+  onOpenChange,
+  open,
+  overlay,
+  placement = "bottomLeft",
+  trigger = ["hover"],
+  ...props
+}, ref) => {
+  const [internalOpen, setInternalOpen] = useState2(Boolean(defaultOpen));
+  const isControlled = open !== undefined;
+  const visible = isControlled ? open : internalOpen;
+  const overlayId = useId();
+  function setVisible(nextOpen) {
+    if (disabled)
+      return;
+    if (!isControlled) {
+      setInternalOpen(nextOpen);
+    }
+    onOpenChange?.(nextOpen);
+  }
+  const close = () => setVisible(false);
+  const toggleVisible = () => setVisible(!visible);
+  const menuNode = overlay ?? (menu?.items ? /* @__PURE__ */ jsx4("ul", {
+    className: dropdownMenuClass,
+    children: menu.items.map((item) => renderMenuItem(item, menu.onClick, close))
+  }) : null);
+  const popup = dropdownRender ? dropdownRender(menuNode) : menuNode;
+  const shouldRenderPopup = !destroyPopupOnHide || visible;
+  const triggerProps = {
+    "aria-controls": visible ? overlayId : undefined,
+    "aria-expanded": visible || undefined,
+    onMouseEnter: hasTrigger(trigger, "hover") ? () => setVisible(true) : undefined,
+    onMouseLeave: hasTrigger(trigger, "hover") ? () => setVisible(false) : undefined,
+    onClick: hasTrigger(trigger, "click") ? toggleVisible : undefined,
+    onContextMenu: hasTrigger(trigger, "contextMenu") ? (event) => {
+      event.preventDefault();
+      toggleVisible();
+    } : undefined
+  };
+  const triggerNode = isValidElement(children) ? cloneElement(children, {
+    "aria-controls": triggerProps["aria-controls"] ?? children.props["aria-controls"],
+    "aria-expanded": triggerProps["aria-expanded"] ?? children.props["aria-expanded"],
+    onMouseEnter: (event) => {
+      callHandler(children.props.onMouseEnter, event);
+      triggerProps.onMouseEnter?.();
+      onMouseEnter?.(event);
+    },
+    onMouseLeave: (event) => {
+      callHandler(children.props.onMouseLeave, event);
+      triggerProps.onMouseLeave?.();
+      onMouseLeave?.(event);
+    },
+    onClick: (event) => {
+      callHandler(children.props.onClick, event);
+      triggerProps.onClick?.();
+      onClick?.(event);
+    },
+    onContextMenu: (event) => {
+      callHandler(children.props.onContextMenu, event);
+      triggerProps.onContextMenu?.(event);
+      onContextMenu?.(event);
+    }
+  }) : /* @__PURE__ */ jsx4("span", {
+    role: "button",
+    tabIndex: disabled ? -1 : 0,
+    "aria-disabled": disabled || undefined,
+    "aria-controls": triggerProps["aria-controls"],
+    "aria-expanded": triggerProps["aria-expanded"],
+    onMouseEnter: (event) => {
+      triggerProps.onMouseEnter?.();
+      onMouseEnter?.(event);
+    },
+    onMouseLeave: (event) => {
+      triggerProps.onMouseLeave?.();
+      onMouseLeave?.(event);
+    },
+    onClick: (event) => {
+      triggerProps.onClick?.();
+      onClick?.(event);
+    },
+    onKeyDown: (event) => {
+      if (event.key === "Enter" || event.key === " ") {
+        event.preventDefault();
+        triggerProps.onClick?.();
+      }
+    },
+    onContextMenu: (event) => {
+      triggerProps.onContextMenu?.(event);
+      onContextMenu?.(event);
+    },
+    children
+  });
+  return /* @__PURE__ */ jsxs3("span", {
+    ...props,
+    ref,
+    className: dropdownWrapperClass,
+    children: [
+      triggerNode,
+      shouldRenderPopup ? /* @__PURE__ */ jsxs3("span", {
+        id: overlayId,
+        role: "menu",
+        className: getDropdownClasses({
+          placement,
+          open: visible,
+          arrow,
+          className
+        }),
+        children: [
+          popup,
+          arrow ? /* @__PURE__ */ jsx4("span", {
+            className: dropdownArrowClass
+          }) : null
+        ]
+      }) : null
+    ]
+  });
+});
+DropdownRoot.displayName = "Dropdown";
+var DropdownButton = forwardRef2(({
+  buttonsRender,
+  children,
+  disabled,
+  menu,
+  onClick,
+  trigger = ["click"],
+  ...props
+}, ref) => {
+  const buttons = [
+    /* @__PURE__ */ jsx4(Button, {
+      disabled,
+      onClick,
+      children
+    }, "primary"),
+    /* @__PURE__ */ jsx4(Button, {
+      "aria-label": "Open dropdown",
+      disabled,
+      children: "v"
+    }, "trigger")
+  ];
+  const renderedButtons = buttonsRender ? buttonsRender(buttons) : buttons;
+  return /* @__PURE__ */ jsx4(DropdownRoot, {
+    ...props,
+    ref,
+    menu,
+    trigger,
+    disabled,
+    children: /* @__PURE__ */ jsx4("span", {
+      className: dropdownButtonClass,
+      children: renderedButtons
+    })
+  });
+});
+DropdownButton.displayName = "Dropdown.Button";
+var Dropdown = Object.assign(DropdownRoot, {
+  Button: DropdownButton
+});
+// src/components/dm-toolbar/DmToolbar.tsx
+import { useMemo as useMemo2 } from "react";
+
+// src/classes/dm-toolbar.ts
+var dmToolbarBaseClass = "dm-toolbar";
+var dmToolbarItemClass = "dm-toolbar-item";
+var dmToolbarPrimaryItemClass = "dm-toolbar-primary-item";
+var dmToolbarSecondaryItemClass = "dm-toolbar-secondary-item";
+var dmToolbarMoreClass = "dm-toolbar-more";
+function getDmToolbarClasses({
+  className
+}) {
+  return cn(dmToolbarBaseClass, className);
+}
+function getDmToolbarItemClasses({
+  primary,
+  className
+}) {
+  return cn(dmToolbarItemClass, primary ? dmToolbarPrimaryItemClass : dmToolbarSecondaryItemClass, className);
+}
+
+// src/components/dm-toolbar/DmToolbar.tsx
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function isPrimary(item) {
+  return item.type === "primary";
+}
+function renderToolbarItem(item, index) {
+  const {
+    title,
+    menu,
+    type,
+    htmlType = "button",
+    color,
+    appearance,
+    ...buttonPropsWithKey
+  } = item;
+  const buttonProps = { ...buttonPropsWithKey };
+  delete buttonProps.key;
+  const button = /* @__PURE__ */ jsx5(Button, {
+    ...buttonProps,
+    type: htmlType,
+    color: color ?? (type === "primary" ? "primary" : "secondary"),
+    appearance: appearance ?? (type === "primary" ? "filled" : "outline"),
+    children: title
+  });
+  if (!menu?.items?.length)
+    return button;
+  return /* @__PURE__ */ jsx5(Dropdown, {
+    trigger: ["click"],
+    menu,
+    children: button
+  }, `dropdown-${index}`);
+}
+function toOverflowMenu(items) {
+  return {
+    items: items.map((item, index) => ({
+      key: item.key ?? index,
+      label: item.title,
+      disabled: item.disabled
+    })),
+    onClick: ({ key, domEvent }) => {
+      const target = items.find((item, index) => String(item.key ?? index) === key);
+      target?.onClick?.(domEvent);
+    }
+  };
+}
+function DmToolbar({
+  items = [],
+  className,
+  style,
+  moreText = "More",
+  maxVisibleSecondaryItems
+}) {
+  const { visibleSecondaryItems, overflowSecondaryItems, primaryItems } = useMemo2(() => {
+    const primaryItems2 = items.filter(isPrimary);
+    const secondaryItems = items.filter((item) => !isPrimary(item));
+    const visibleLimit = maxVisibleSecondaryItems === undefined ? secondaryItems.length : Math.max(0, maxVisibleSecondaryItems);
+    const visibleSecondaryItems2 = visibleLimit === 0 ? [] : secondaryItems.slice(-visibleLimit);
+    const overflowSecondaryItems2 = visibleLimit >= secondaryItems.length ? [] : secondaryItems.slice(0, secondaryItems.length - visibleLimit);
+    return { visibleSecondaryItems: visibleSecondaryItems2, overflowSecondaryItems: overflowSecondaryItems2, primaryItems: primaryItems2 };
+  }, [items, maxVisibleSecondaryItems]);
+  const showMore = overflowSecondaryItems.length > 0;
+  return /* @__PURE__ */ jsxs4("div", {
+    className: getDmToolbarClasses({ className }),
+    style,
+    children: [
+      visibleSecondaryItems.map((item, index) => /* @__PURE__ */ jsx5("span", {
+        className: getDmToolbarItemClasses({}),
+        children: renderToolbarItem(item, index)
+      }, item.key ?? `secondary-${index}`)),
+      showMore ? /* @__PURE__ */ jsx5(Dropdown, {
+        trigger: ["click"],
+        menu: toOverflowMenu(overflowSecondaryItems),
+        children: /* @__PURE__ */ jsx5(Button, {
+          type: "button",
+          className: dmToolbarMoreClass,
+          color: "secondary",
+          appearance: "outline",
+          children: moreText
+        })
+      }) : null,
+      primaryItems.map((item, index) => /* @__PURE__ */ jsx5("span", {
+        className: getDmToolbarItemClasses({ primary: true }),
+        children: renderToolbarItem(item, index)
+      }, item.key ?? `primary-${index}`))
+    ]
+  });
+}
+DmToolbar.displayName = "DmToolbar";
+// src/components/pagination/Pagination.tsx
+import {
+  forwardRef as forwardRef3,
+  useMemo as useMemo3,
+  useState as useState3
+} from "react";
+
+// src/classes/pagination.ts
+var paginationBaseClass = "pagination";
+var paginationItemClass = "pagination-item";
+var paginationItemActiveClass = "pagination-item-active";
+var paginationItemDisabledClass = "pagination-item-disabled";
+var paginationPrevClass = "pagination-prev";
+var paginationNextClass = "pagination-next";
+var paginationEllipsisClass = "pagination-ellipsis";
+var paginationCompactClass = "pagination-compact";
+var paginationInfoClass = "pagination-info";
+var paginationInfoTextClass = "pagination-info-text";
+var paginationInputClass = "pagination-input";
+var paginationResponsiveClass = "pagination-responsive";
+var paginationSizeClasses = {
+  sm: "pagination-sm",
+  md: "",
+  lg: "pagination-lg"
+};
+function getPaginationClasses({
+  size = "md",
+  compact,
+  className
+}) {
+  return cn(paginationBaseClass, paginationResponsiveClass, paginationSizeClasses[size], compact && paginationCompactClass, className);
+}
+function getPaginationItemClasses({
+  active,
+  disabled
+}) {
+  return cn(paginationItemClass, active && paginationItemActiveClass, disabled && paginationItemDisabledClass);
+}
+
+// src/components/pagination/Pagination.tsx
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+var defaultPageSizeOptions = [10, 20, 50, 100];
+function toPositiveInteger(value, fallback) {
+  if (!Number.isFinite(value) || value === undefined) {
+    return fallback;
+  }
+  return Math.max(1, Math.floor(value));
+}
+function clampPage(page, pageCount) {
+  return Math.min(pageCount, Math.max(1, Math.floor(page)));
+}
+function getPageCount(total, pageSize) {
+  return Math.max(1, Math.ceil(Math.max(0, total) / pageSize));
+}
+function getRange(current, pageSize, total) {
+  if (total <= 0) {
+    return [0, 0];
+  }
+  const start = (current - 1) * pageSize + 1;
+  const end = Math.min(total, current * pageSize);
+  return [start, end];
+}
+function getPageTokens(current, pageCount) {
+  if (pageCount <= 7) {
+    return Array.from({ length: pageCount }, (_, index) => index + 1);
+  }
+  const pages = new Set([1, pageCount, current - 1, current, current + 1]);
+  if (current <= 4) {
+    [2, 3, 4, 5].forEach((page) => pages.add(page));
+  }
+  if (current >= pageCount - 3) {
+    [pageCount - 4, pageCount - 3, pageCount - 2, pageCount - 1].forEach((page) => pages.add(page));
+  }
+  const sortedPages = Array.from(pages).filter((page) => page >= 1 && page <= pageCount).sort((first, second) => first - second);
+  return sortedPages.reduce((tokens, page) => {
+    const previous = tokens[tokens.length - 1];
+    if (typeof previous === "number") {
+      const gap = page - previous;
+      if (gap === 2) {
+        tokens.push(previous + 1);
+      } else if (gap > 2) {
+        tokens.push("ellipsis");
+      }
+    }
+    tokens.push(page);
+    return tokens;
+  }, []);
+}
+function getSizeOptions(pageSize) {
+  return Array.from(new Set([...defaultPageSizeOptions, pageSize])).sort((first, second) => first - second);
+}
+var Pagination = forwardRef3(({
+  current,
+  defaultCurrent = 1,
+  pageSize,
+  defaultPageSize = 10,
+  total = 0,
+  onChange,
+  disabled,
+  simple,
+  showSizeChanger,
+  showQuickJumper,
+  showTotal,
+  size = "md",
+  className,
+  ...props
+}, ref) => {
+  const isCurrentControlled = current !== undefined;
+  const isPageSizeControlled = pageSize !== undefined;
+  const [internalCurrent, setInternalCurrent] = useState3(defaultCurrent);
+  const [internalPageSize, setInternalPageSize] = useState3(defaultPageSize);
+  const [quickJumpValue, setQuickJumpValue] = useState3("");
+  const mergedPageSize = toPositiveInteger(pageSize ?? internalPageSize, defaultPageSize);
+  const pageCount = getPageCount(total, mergedPageSize);
+  const mergedCurrent = clampPage(toPositiveInteger(current ?? internalCurrent, defaultCurrent), pageCount);
+  const pageTokens = useMemo3(() => getPageTokens(mergedCurrent, pageCount), [mergedCurrent, pageCount]);
+  const range = getRange(mergedCurrent, mergedPageSize, total);
+  function changePage(nextPage, nextPageSize = mergedPageSize) {
+    const nextPageCount = getPageCount(total, nextPageSize);
+    const normalizedPage = clampPage(nextPage, nextPageCount);
+    if (!isCurrentControlled) {
+      setInternalCurrent(normalizedPage);
+    }
+    if (!isPageSizeControlled) {
+      setInternalPageSize(nextPageSize);
+    }
+    onChange?.(normalizedPage, nextPageSize);
+  }
+  function handlePageSizeChange(event) {
+    const nextPageSize = toPositiveInteger(Number(event.currentTarget.value), mergedPageSize);
+    const nextPage = clampPage(mergedCurrent, getPageCount(total, nextPageSize));
+    changePage(nextPage, nextPageSize);
+  }
+  function jumpToInputPage(value) {
+    const nextPage = Number(value);
+    if (!Number.isFinite(nextPage)) {
+      return;
+    }
+    changePage(nextPage);
+    setQuickJumpValue("");
+  }
+  function handleQuickJumpKeyDown(event) {
+    if (event.key !== "Enter") {
+      return;
+    }
+    jumpToInputPage(event.currentTarget.value);
+  }
+  const previousDisabled = disabled || mergedCurrent <= 1;
+  const nextDisabled = disabled || mergedCurrent >= pageCount;
+  return /* @__PURE__ */ jsxs5("nav", {
+    ...props,
+    ref,
+    className: getPaginationClasses({ size, compact: simple, className }),
+    children: [
+      showTotal ? /* @__PURE__ */ jsx6("div", {
+        className: paginationInfoClass,
+        children: /* @__PURE__ */ jsx6("span", {
+          className: paginationInfoTextClass,
+          children: showTotal(total, range)
+        })
+      }) : null,
+      /* @__PURE__ */ jsx6("button", {
+        type: "button",
+        className: paginationPrevClass,
+        disabled: previousDisabled,
+        "aria-label": "Previous page",
+        onClick: () => changePage(mergedCurrent - 1),
+        children: "Prev"
+      }),
+      simple ? /* @__PURE__ */ jsxs5("div", {
+        className: paginationInputClass,
+        children: [
+          /* @__PURE__ */ jsx6("input", {
+            "aria-label": "Current page",
+            type: "number",
+            min: 1,
+            max: pageCount,
+            value: quickJumpValue || String(mergedCurrent),
+            disabled,
+            onChange: (event) => setQuickJumpValue(event.currentTarget.value),
+            onKeyDown: handleQuickJumpKeyDown,
+            onBlur: (event) => {
+              if (event.currentTarget.value !== String(mergedCurrent)) {
+                jumpToInputPage(event.currentTarget.value);
+              }
+            }
+          }),
+          /* @__PURE__ */ jsxs5("span", {
+            className: paginationInfoTextClass,
+            children: [
+              "/ ",
+              pageCount
+            ]
+          })
+        ]
+      }) : pageTokens.map((pageToken, index) => pageToken === "ellipsis" ? /* @__PURE__ */ jsx6("span", {
+        "aria-hidden": "true",
+        className: paginationEllipsisClass
+      }, `ellipsis-${index}`) : /* @__PURE__ */ jsx6("button", {
+        type: "button",
+        className: getPaginationItemClasses({
+          active: pageToken === mergedCurrent,
+          disabled
+        }),
+        disabled,
+        "aria-current": pageToken === mergedCurrent ? "page" : undefined,
+        "aria-label": `Page ${pageToken}`,
+        onClick: () => changePage(pageToken),
+        children: pageToken
+      }, pageToken)),
+      /* @__PURE__ */ jsx6("button", {
+        type: "button",
+        className: paginationNextClass,
+        disabled: nextDisabled,
+        "aria-label": "Next page",
+        onClick: () => changePage(mergedCurrent + 1),
+        children: "Next"
+      }),
+      showSizeChanger ? /* @__PURE__ */ jsx6("div", {
+        className: paginationInputClass,
+        children: /* @__PURE__ */ jsx6("select", {
+          "aria-label": "Page size",
+          value: mergedPageSize,
+          disabled,
+          onChange: handlePageSizeChange,
+          children: getSizeOptions(mergedPageSize).map((option) => /* @__PURE__ */ jsxs5("option", {
+            value: option,
+            children: [
+              option,
+              " / page"
+            ]
+          }, option))
+        })
+      }) : null,
+      showQuickJumper && !simple ? /* @__PURE__ */ jsx6("div", {
+        className: paginationInputClass,
+        children: /* @__PURE__ */ jsx6("input", {
+          "aria-label": "Jump to page",
+          type: "number",
+          min: 1,
+          max: pageCount,
+          value: quickJumpValue,
+          disabled,
+          onChange: (event) => setQuickJumpValue(event.currentTarget.value),
+          onKeyDown: handleQuickJumpKeyDown
+        })
+      }) : null
+    ]
+  });
+});
+Pagination.displayName = "Pagination";
+// src/components/dm-pagination/DmPagination.tsx
+import {
+  forwardRef as forwardRef4,
+  useEffect,
+  useMemo as useMemo4,
+  useRef,
+  useState as useState4
+} from "react";
+
+// src/classes/dm-pagination.ts
+var dmPaginationBaseClass = "dm-pagination";
+var dmPaginationHiddenClass = "dm-pagination-hidden";
+var dmPaginationPagerClass = "dm-pagination-pager";
+var dmPaginationRefreshClass = "dm-pagination-refresh";
+var dmPaginationRefreshLoadingClass = "dm-pagination-refresh-loading";
+var dmPaginationSelectedClass = "dm-pagination-selected";
+var dmPaginationAlignClasses = {
+  left: "dm-pagination-left",
+  center: "dm-pagination-center",
+  right: "dm-pagination-right"
+};
+function getDmPaginationClasses({
+  align = "right",
+  hidden,
+  className
+}) {
+  return cn(dmPaginationBaseClass, dmPaginationAlignClasses[align], hidden && dmPaginationHiddenClass, className);
+}
+function getDmPaginationRefreshClasses({
+  loading,
+  className
+}) {
+  return cn(dmPaginationRefreshClass, loading && dmPaginationRefreshLoadingClass, className);
+}
+
+// src/components/dm-pagination/DmPagination.tsx
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+var defaultLocale = {
+  refresh: "Refresh",
+  showTotal: (total, range) => `${range[0]}-${range[1]} of ${total}`,
+  showTotalSimple: (total, range) => `${range[0]}-${range[1]} / ${total}`,
+  selected: (selectedTotal) => `, ${selectedTotal} selected`
+};
+function getResponsiveSimple({
+  width,
+  total,
+  showRefresh,
+  showSizeChanger
+}) {
+  let reservedWidth = 0;
+  if (!showRefresh)
+    reservedWidth += 100;
+  if (!showSizeChanger)
+    reservedWidth += 100;
+  if (width < 900 - reservedWidth)
+    return total >= 100;
+  if (width < 1100 - reservedWidth)
+    return total >= 1000;
+  if (width < 1220 - reservedWidth)
+    return total >= 99999;
+  if (width < 1300 - reservedWidth)
+    return total >= 999999;
+  if (width < 1450 - reservedWidth)
+    return total >= 9999999;
+  return false;
+}
+function useElementWidth() {
+  const ref = useRef(null);
+  const [width, setWidth] = useState4(1000);
+  useEffect(() => {
+    const element = ref.current;
+    if (!element || typeof ResizeObserver === "undefined")
+      return;
+    const observer = new ResizeObserver(([entry]) => {
+      setWidth(entry?.contentRect.width || element.getBoundingClientRect().width);
+    });
+    observer.observe(element);
+    return () => observer.disconnect();
+  }, []);
+  return [ref, width];
+}
+function renderSelected(selectedTotal, locale) {
+  if (!selectedTotal)
+    return null;
+  return /* @__PURE__ */ jsx7("span", {
+    className: dmPaginationSelectedClass,
+    children: locale.selected(selectedTotal)
+  });
+}
+var DmPagination = forwardRef4(({
+  selectedTotal = 0,
+  loading = false,
+  total = 0,
+  showRefresh = true,
+  showPagination = true,
+  wrapperStyle,
+  className,
+  align = "right",
+  showTotalFullMessage = false,
+  showSizeChanger = true,
+  responsiveSimple = true,
+  refresh,
+  simple,
+  showQuickJumper,
+  showTotal,
+  locale,
+  ...props
+}, ref) => {
+  const [measureRef, width] = useElementWidth();
+  const mergedLocale = useMemo4(() => ({ ...defaultLocale, ...locale }), [locale]);
+  const isRefreshVisible = showRefresh && Boolean(refresh);
+  const shouldRender = showPagination || isRefreshVisible;
+  const responsiveSimpleMode = responsiveSimple ? getResponsiveSimple({
+    width,
+    total,
+    showRefresh,
+    showSizeChanger
+  }) : false;
+  const mergedSimple = simple ?? responsiveSimpleMode;
+  const mergedShowQuickJumper = showQuickJumper ?? !mergedSimple;
+  const totalRenderer = useMemo4(() => {
+    if (showTotal)
+      return showTotal;
+    return (nextTotal, range) => {
+      if (Number(nextTotal) === 0)
+        return "";
+      const selected = renderSelected(selectedTotal, mergedLocale);
+      const message = mergedSimple && !showTotalFullMessage ? mergedLocale.showTotalSimple(nextTotal, range, selectedTotal) : mergedLocale.showTotal(nextTotal, range, selectedTotal);
+      return /* @__PURE__ */ jsxs6("span", {
+        title: `${mergedLocale.showTotal(nextTotal, range, selectedTotal)}${selectedTotal ? mergedLocale.selected(selectedTotal) : ""}`,
+        children: [
+          message,
+          selected
+        ]
+      });
+    };
+  }, [
+    mergedLocale,
+    mergedSimple,
+    selectedTotal,
+    showTotal,
+    showTotalFullMessage
+  ]);
+  if (!shouldRender)
+    return null;
+  return /* @__PURE__ */ jsxs6("div", {
+    ref: (element) => {
+      measureRef.current = element;
+      if (typeof ref === "function") {
+        ref(element);
+      } else if (ref) {
+        ref.current = element;
+      }
+    },
+    className: getDmPaginationClasses({ align, className }),
+    style: wrapperStyle,
+    children: [
+      showPagination ? /* @__PURE__ */ jsx7("div", {
+        className: dmPaginationPagerClass,
+        children: /* @__PURE__ */ jsx7(Pagination, {
+          ...props,
+          total,
+          simple: mergedSimple,
+          showQuickJumper: mergedShowQuickJumper,
+          showSizeChanger,
+          showTotal: totalRenderer
+        })
+      }) : null,
+      isRefreshVisible ? /* @__PURE__ */ jsxs6("button", {
+        type: "button",
+        className: getDmPaginationRefreshClasses({ loading }),
+        disabled: loading || props.disabled,
+        "aria-busy": loading || undefined,
+        onClick: refresh,
+        children: [
+          /* @__PURE__ */ jsx7("span", {
+            "aria-hidden": "true",
+            children: "Reload"
+          }),
+          /* @__PURE__ */ jsx7("span", {
+            children: mergedLocale.refresh
+          })
+        ]
+      }) : null
+    ]
+  });
+});
+DmPagination.displayName = "DmPagination";
+// src/components/input/Input.tsx
+import {
+  forwardRef as forwardRef5,
+  useImperativeHandle,
+  useRef as useRef2,
+  useState as useState5
+} from "react";
+
+// src/classes/input.ts
+var inputBaseClass = "input";
+var inputWrapperClass = "input-wrapper";
+var inputAffixWrapperClass = "input-affix-wrapper";
+var inputPrefixClass = "input-prefix";
+var inputSuffixClass = "input-suffix";
+var inputClearClass = "input-clear";
+var inputSearchClass = "input-search";
+var inputSearchButtonClass = "input-search-button";
+var inputPasswordClass = "input-password";
+var inputPasswordToggleClass = "input-password-toggle";
+var inputGroupClass = "input-group";
+var textAreaBaseClass = "textarea";
+var textAreaWrapperClass = "textarea-wrapper";
+var textAreaCountClass = "textarea-counter";
+var textAreaCountExceededClass = "textarea-counter-exceeded";
+var textAreaAutoSizeClass = "textarea-auto-resize";
+var inputVariantClasses = {
+  filled: "input-filled",
+  outlined: "input-outlined"
+};
+var inputSizeClasses = {
+  sm: "input-sm",
+  md: "input-md",
+  lg: "input-lg"
+};
+var inputStatusClasses = {
+  error: "input-error",
+  success: "input-success"
+};
+var textAreaVariantClasses = {
+  filled: "textarea-filled",
+  outlined: "textarea-outlined"
+};
+var textAreaSizeClasses = {
+  sm: "textarea-sm",
+  md: "",
+  lg: "textarea-lg"
+};
+var textAreaStatusClasses = {
+  error: "textarea-error",
+  success: "textarea-success"
+};
+var textAreaResizeClasses = {
+  none: "textarea-resize-none",
+  both: "textarea-resize-both",
+  horizontal: "textarea-resize-horizontal",
+  vertical: "textarea-resize-vertical"
+};
+function getInputClasses({
+  size = "md",
+  status,
+  variant = "outlined",
+  className
+}) {
+  return cn(inputBaseClass, inputVariantClasses[variant], inputSizeClasses[size], status && inputStatusClasses[status], className);
+}
+function getInputWrapperClasses({
+  affixed,
+  className
+}) {
+  return cn(inputWrapperClass, affixed && inputAffixWrapperClass, className);
+}
+function getSearchWrapperClasses({ className }) {
+  return cn(inputSearchClass, className);
+}
+function getPasswordWrapperClasses({
+  className
+}) {
+  return cn(inputPasswordClass, className);
+}
+function getTextAreaClasses({
+  size = "md",
+  status,
+  variant = "outlined",
+  resize = "vertical",
+  autoSize,
+  className
+}) {
+  return cn(textAreaBaseClass, textAreaVariantClasses[variant], textAreaSizeClasses[size], status && textAreaStatusClasses[status], textAreaResizeClasses[resize], autoSize && textAreaAutoSizeClass, className);
+}
+function getTextAreaCountClasses({ exceeded }) {
+  return cn(textAreaCountClass, exceeded && textAreaCountExceededClass);
+}
+
+// src/components/input/Input.tsx
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+function toTextValue(value) {
+  if (Array.isArray(value)) {
+    return value.join(",");
+  }
+  return value == null ? "" : String(value);
+}
+var InputRoot = forwardRef5(({
+  allowClear,
+  className,
+  defaultValue,
+  disabled,
+  onChange,
+  prefix,
+  size = "md",
+  status,
+  suffix,
+  type = "text",
+  value,
+  variant = "outlined",
+  ...props
+}, ref) => {
+  const inputRef = useRef2(null);
+  const [internalValue, setInternalValue] = useState5(() => toTextValue(defaultValue));
+  const isControlled = value !== undefined;
+  const currentValue = isControlled ? toTextValue(value) : internalValue;
+  const hasAffix = prefix != null || suffix != null || allowClear;
+  useImperativeHandle(ref, () => inputRef.current);
+  function handleChange(event) {
+    if (!isControlled) {
+      setInternalValue(event.currentTarget.value);
+    }
+    onChange?.(event);
+  }
+  function handleClear() {
+    const input = inputRef.current;
+    if (!input || disabled) {
+      return;
+    }
+    input.value = "";
+    if (!isControlled) {
+      setInternalValue("");
+    }
+    onChange?.({
+      currentTarget: input,
+      target: input,
+      type: "change"
+    });
+    input.focus();
+  }
+  const control = /* @__PURE__ */ jsx8("input", {
+    ...props,
+    ref: inputRef,
+    type,
+    className: getInputClasses({ size, status, variant, className }),
+    disabled,
+    value: currentValue,
+    onChange: handleChange
+  });
+  if (!hasAffix) {
+    return control;
+  }
+  const showClear = allowClear && !disabled && currentValue.length > 0;
+  return /* @__PURE__ */ jsxs7("span", {
+    className: getInputWrapperClasses({ affixed: hasAffix }),
+    children: [
+      prefix != null ? /* @__PURE__ */ jsx8("span", {
+        className: inputPrefixClass,
+        children: prefix
+      }) : null,
+      control,
+      showClear ? /* @__PURE__ */ jsx8("button", {
+        type: "button",
+        className: inputClearClass,
+        "aria-label": "Clear input",
+        onClick: handleClear,
+        children: "x"
+      }) : null,
+      suffix != null ? /* @__PURE__ */ jsx8("span", {
+        className: inputSuffixClass,
+        children: suffix
+      }) : null
+    ]
+  });
+});
+InputRoot.displayName = "Input";
+var Search = forwardRef5(({
+  className,
+  disabled,
+  enterButton,
+  loading,
+  onKeyDown,
+  onSearch,
+  ...props
+}, ref) => {
+  const inputRef = useRef2(null);
+  useImperativeHandle(ref, () => inputRef.current);
+  function emitSearch(event) {
+    onSearch?.(inputRef.current?.value ?? "", event);
+  }
+  function handleKeyDown(event) {
+    onKeyDown?.(event);
+    if (!event.defaultPrevented && event.key === "Enter") {
+      emitSearch(event);
+    }
+  }
+  const buttonContent = enterButton === true ? "Search" : enterButton ?? "Search";
+  return /* @__PURE__ */ jsxs7("span", {
+    className: getSearchWrapperClasses({ className }),
+    children: [
+      /* @__PURE__ */ jsx8(InputRoot, {
+        ...props,
+        ref: inputRef,
+        disabled,
+        onKeyDown: handleKeyDown
+      }),
+      enterButton || loading ? /* @__PURE__ */ jsx8("button", {
+        type: "button",
+        className: inputSearchButtonClass,
+        disabled: disabled || loading,
+        "aria-busy": loading || undefined,
+        onClick: emitSearch,
+        children: loading ? "Loading" : buttonContent
+      }) : null
+    ]
+  });
+});
+Search.displayName = "Input.Search";
+var Password = forwardRef5(({ className, disabled, visibilityToggle = true, ...props }, ref) => {
+  const [visible, setVisible] = useState5(false);
+  const type = visible ? "text" : "password";
+  const toggle = visibilityToggle ? /* @__PURE__ */ jsx8("button", {
+    type: "button",
+    className: inputPasswordToggleClass,
+    disabled,
+    "aria-label": visible ? "Hide password" : "Show password",
+    onClick: () => {
+      setVisible((current) => !current);
+    },
+    children: visible ? "Hide" : "Show"
+  }) : undefined;
+  return /* @__PURE__ */ jsx8("span", {
+    className: getPasswordWrapperClasses({ className }),
+    children: /* @__PURE__ */ jsx8(InputRoot, {
+      ...props,
+      ref,
+      disabled,
+      type,
+      suffix: toggle
+    })
+  });
+});
+Password.displayName = "Input.Password";
+var TextArea = forwardRef5(({
+  autoSize,
+  className,
+  defaultValue,
+  maxLength,
+  onChange,
+  resize = "vertical",
+  showCount,
+  size = "md",
+  status,
+  value,
+  variant = "outlined",
+  ...props
+}, ref) => {
+  const [internalValue, setInternalValue] = useState5(() => toTextValue(defaultValue));
+  const isControlled = value !== undefined;
+  const currentValue = isControlled ? toTextValue(value) : internalValue;
+  const count = currentValue.length;
+  const exceeded = maxLength !== undefined && count > maxLength;
+  function handleChange(event) {
+    if (!isControlled) {
+      setInternalValue(event.currentTarget.value);
+    }
+    onChange?.(event);
+  }
+  const control = /* @__PURE__ */ jsx8("textarea", {
+    ...props,
+    ref,
+    className: getTextAreaClasses({
+      size,
+      status,
+      variant,
+      resize,
+      autoSize: Boolean(autoSize),
+      className
+    }),
+    maxLength,
+    value: currentValue,
+    onChange: handleChange
+  });
+  if (!showCount) {
+    return control;
+  }
+  return /* @__PURE__ */ jsxs7("span", {
+    className: textAreaWrapperClass,
+    children: [
+      control,
+      /* @__PURE__ */ jsxs7("span", {
+        className: getTextAreaCountClasses({ exceeded }),
+        children: [
+          count,
+          maxLength !== undefined ? ` / ${maxLength}` : null
+        ]
+      })
+    ]
+  });
+});
+TextArea.displayName = "Input.TextArea";
+var Group = forwardRef5(({ className, children, ...props }, ref) => /* @__PURE__ */ jsx8("div", {
+  ...props,
+  ref,
+  className: cn(inputGroupClass, className),
+  children
+}));
+Group.displayName = "Input.Group";
+var Input = Object.assign(InputRoot, {
+  Search,
+  Password,
+  TextArea,
+  Group
+});
+// src/components/select/Select.tsx
+import React7, { forwardRef as forwardRef6, useMemo as useMemo5, useState as useState6 } from "react";
+
+// src/classes/select.ts
+var selectContainerClass = "select-container";
+var selectBaseClass = "select";
+var selectIconClass = "select-icon";
+var selectOpenClass = "select-open";
+var selectLoadingClass = "select-loading";
+var selectFullClass = "select-full";
+var selectOptionClass = "select-option";
+var selectOptionSelectedClass = "select-option-selected";
+var selectOptionDisabledClass = "select-option-disabled";
+var selectDropdownClass = "select-dropdown";
+var selectSearchClass = "select-search";
+var selectSelectionClass = "select-selection";
+var selectTagClass = "select-tag";
+var selectClearClass = "select-clear";
+var selectPlaceholderClass = "select-placeholder";
+var selectEmptyClass = "select-empty";
+var selectGroupClass = "select-group";
+var selectGroupLabelClass = "select-group-label";
+var selectSizeClasses = {
+  sm: "select-sm",
+  md: "",
+  lg: "select-lg"
+};
+var selectStatusClasses = {
+  error: "select-error",
+  success: "select-success"
+};
+function getSelectContainerClasses({
+  open,
+  loading,
+  disabled,
+  full,
+  className
+}) {
+  return cn(selectContainerClass, open && selectOpenClass, loading && selectLoadingClass, disabled && "select-disabled", full && selectFullClass, className);
+}
+function getSelectClasses({
+  size = "md",
+  status,
+  disabled,
+  className
+}) {
+  return cn(selectBaseClass, selectSizeClasses[size], status && selectStatusClasses[status], disabled && "select-disabled", className);
+}
+function getSelectOptionClasses({
+  selected,
+  disabled,
+  className
+}) {
+  return cn(selectOptionClass, selected && selectOptionSelectedClass, disabled && selectOptionDisabledClass, className);
+}
+
+// src/components/select/Select.tsx
+import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+function isGroup(option) {
+  return "options" in option;
+}
+function optionLabel(option) {
+  return option.label ?? option.value;
+}
+function valueKey(value) {
+  return String(value);
+}
+function normalizeSingleValue(value) {
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return typeof value === "string" || typeof value === "number" ? value : undefined;
+}
+function normalizeMultiValue(value) {
+  if (Array.isArray(value)) {
+    return value.filter((item) => typeof item === "string" || typeof item === "number");
+  }
+  const single = normalizeSingleValue(value);
+  return single === undefined ? [] : [single];
+}
+function optionsFromChildren(children) {
+  const result = [];
+  React7.Children.forEach(children, (child) => {
+    if (!React7.isValidElement(child)) {
+      return;
+    }
+    if (child.type === Option) {
+      const props = child.props;
+      result.push({
+        value: props.value,
+        label: props.children,
+        disabled: props.disabled,
+        className: props.className
+      });
+      return;
+    }
+    if (child.type === OptGroup) {
+      const props = child.props;
+      result.push({
+        label: props.label,
+        className: props.className,
+        options: optionsFromChildren(props.children).filter((option) => !isGroup(option))
+      });
+    }
+  });
+  return result;
+}
+function flattenOptions(options) {
+  return options.flatMap((option) => isGroup(option) ? option.options : option);
+}
+function matchesOption(option, searchValue, filterOption) {
+  if (!searchValue || filterOption === false) {
+    return true;
+  }
+  if (typeof filterOption === "function") {
+    return filterOption(searchValue, option);
+  }
+  const label = optionLabel(option);
+  const text = typeof label === "string" || typeof label === "number" ? String(label) : String(option.value);
+  return text.toLowerCase().includes(searchValue.toLowerCase());
+}
+function filterOptions(options, searchValue, filterOption) {
+  return options.map((option) => {
+    if (!isGroup(option)) {
+      return matchesOption(option, searchValue, filterOption) ? option : null;
+    }
+    const groupOptions = option.options.filter((child) => matchesOption(child, searchValue, filterOption));
+    return groupOptions.length > 0 ? { ...option, options: groupOptions } : null;
+  }).filter((option) => option !== null);
+}
+function renderValue(option) {
+  return option ? optionLabel(option) : null;
+}
+var Option = forwardRef6(({ children, ...props }, ref) => /* @__PURE__ */ jsx9("div", {
+  ...props,
+  ref,
+  children
+}));
+Option.displayName = "Select.Option";
+var OptGroup = forwardRef6(({ children, ...props }, ref) => /* @__PURE__ */ jsx9("div", {
+  ...props,
+  ref,
+  children
+}));
+OptGroup.displayName = "Select.OptGroup";
+var SelectRoot = forwardRef6(({
+  allowClear,
+  children,
+  className,
+  defaultValue,
+  disabled,
+  filterOption,
+  loading,
+  mode,
+  onChange,
+  options,
+  placeholder,
+  showSearch,
+  size = "md",
+  status,
+  value,
+  ...props
+}, ref) => {
+  const multiple = mode === "multiple" || mode === "tags";
+  const sourceOptions = useMemo5(() => options ?? optionsFromChildren(children), [children, options]);
+  const flatOptions = useMemo5(() => flattenOptions(sourceOptions), [sourceOptions]);
+  const [open, setOpen] = useState6(false);
+  const [searchValue, setSearchValue] = useState6("");
+  const [internalValue, setInternalValue] = useState6(multiple ? normalizeMultiValue(defaultValue) : normalizeSingleValue(defaultValue));
+  const controlled = value !== undefined;
+  const currentValue = controlled ? value : internalValue;
+  const selectedValues = multiple ? normalizeMultiValue(currentValue) : normalizeSingleValue(currentValue) === undefined ? [] : [normalizeSingleValue(currentValue)];
+  const selectedKeys = new Set(selectedValues.map(valueKey));
+  const selectedOptions = selectedValues.map((selectedValue) => flatOptions.find((option) => option.value === selectedValue) ?? {
+    value: selectedValue,
+    label: selectedValue
+  });
+  const visibleOptions = filterOptions(sourceOptions, searchValue, filterOption);
+  const hasValue = selectedValues.length > 0;
+  const searchable = showSearch || mode === "tags";
+  function emitChange(nextValue) {
+    if (!controlled) {
+      setInternalValue(nextValue);
+    }
+    const nextValues = Array.isArray(nextValue) ? nextValue : nextValue === undefined ? [] : [nextValue];
+    const nextOptions = nextValues.map((next) => flatOptions.find((option) => option.value === next) ?? {
+      value: next,
+      label: next
+    });
+    onChange?.(nextValue, multiple ? nextOptions : nextOptions[0]);
+  }
+  function selectOption(option) {
+    if (disabled || loading || option.disabled) {
+      return;
+    }
+    if (multiple) {
+      const optionKey = valueKey(option.value);
+      const nextValues = selectedKeys.has(optionKey) ? selectedValues.filter((item) => valueKey(item) !== optionKey) : [...selectedValues, option.value];
+      emitChange(nextValues);
+    } else {
+      emitChange(option.value);
+      setOpen(false);
+    }
+    setSearchValue("");
+  }
+  function clearValue(event) {
+    event.stopPropagation();
+    if (disabled || loading) {
+      return;
+    }
+    emitChange(multiple ? [] : undefined);
+    setSearchValue("");
+  }
+  function addTag() {
+    const tag = searchValue.trim();
+    if (mode !== "tags" || tag.length === 0) {
+      return;
+    }
+    if (!selectedKeys.has(tag)) {
+      emitChange([...selectedValues, tag]);
+    }
+    setSearchValue("");
+  }
+  function renderOption(option) {
+    const selected = selectedKeys.has(valueKey(option.value));
+    return /* @__PURE__ */ jsx9("button", {
+      type: "button",
+      role: "option",
+      "aria-selected": selected,
+      disabled: disabled || option.disabled,
+      className: getSelectOptionClasses({
+        selected,
+        disabled: disabled || option.disabled,
+        className: option.className
+      }),
+      onClick: () => selectOption(option),
+      children: optionLabel(option)
+    }, valueKey(option.value));
+  }
+  function renderOptions(optionItems) {
+    return optionItems.map((option, index) => {
+      if (!isGroup(option)) {
+        return renderOption(option);
+      }
+      return /* @__PURE__ */ jsxs8("div", {
+        className: cn(selectGroupClass, option.className),
+        role: "group",
+        children: [
+          /* @__PURE__ */ jsx9("div", {
+            className: selectGroupLabelClass,
+            children: option.label
+          }),
+          option.options.map(renderOption)
+        ]
+      }, `group-${index}`);
+    });
+  }
+  const selection = multiple ? selectedOptions.map((option) => /* @__PURE__ */ jsx9("span", {
+    className: selectTagClass,
+    children: renderValue(option)
+  }, valueKey(option.value))) : renderValue(selectedOptions[0]);
+  return /* @__PURE__ */ jsxs8("div", {
+    ...props,
+    ref,
+    className: getSelectContainerClasses({
+      open,
+      loading,
+      disabled,
+      full: true,
+      className
+    }),
+    children: [
+      /* @__PURE__ */ jsxs8("button", {
+        type: "button",
+        className: getSelectClasses({ size, status, disabled }),
+        disabled: disabled || loading,
+        "aria-haspopup": "listbox",
+        "aria-expanded": open,
+        onClick: () => setOpen((current) => !current),
+        children: [
+          /* @__PURE__ */ jsx9("span", {
+            className: selectSelectionClass,
+            children: hasValue ? selection : /* @__PURE__ */ jsx9("span", {
+              className: selectPlaceholderClass,
+              children: placeholder
+            })
+          }),
+          /* @__PURE__ */ jsx9("span", {
+            className: selectIconClass,
+            "aria-hidden": "true",
+            children: "v"
+          })
+        ]
+      }),
+      allowClear && hasValue && !disabled && !loading ? /* @__PURE__ */ jsx9("button", {
+        type: "button",
+        className: selectClearClass,
+        "aria-label": "Clear selection",
+        onClick: clearValue,
+        children: "x"
+      }) : null,
+      open ? /* @__PURE__ */ jsxs8("div", {
+        className: selectDropdownClass,
+        role: "listbox",
+        "aria-multiselectable": multiple || undefined,
+        children: [
+          searchable ? /* @__PURE__ */ jsx9("input", {
+            className: selectSearchClass,
+            value: searchValue,
+            placeholder: typeof placeholder === "string" ? placeholder : undefined,
+            onChange: (event) => setSearchValue(event.currentTarget.value),
+            onKeyDown: (event) => {
+              if (event.key === "Enter") {
+                event.preventDefault();
+                addTag();
+              }
+            }
+          }) : null,
+          visibleOptions.length > 0 ? renderOptions(visibleOptions) : /* @__PURE__ */ jsx9("div", {
+            className: selectEmptyClass,
+            children: "No data"
+          })
+        ]
+      }) : null
+    ]
+  });
+});
+SelectRoot.displayName = "Select";
+var Select = SelectRoot;
+Select.Option = Option;
+Select.OptGroup = OptGroup;
+// src/components/dm-search/DmSearch.tsx
+import {
+  forwardRef as forwardRef7,
+  useEffect as useEffect2,
+  useImperativeHandle as useImperativeHandle2,
+  useMemo as useMemo6,
+  useState as useState7
+} from "react";
+
+// src/classes/dm-search.ts
+var dmSearchBaseClass = "dm-search";
+var dmSearchCompactClass = "dm-search-compact";
+var dmSearchCollapsedClass = "dm-search-collapsed";
+var dmSearchFieldsClass = "dm-search-fields";
+var dmSearchFieldClass = "dm-search-field";
+var dmSearchActionsClass = "dm-search-actions";
+var dmSearchFastFilterClass = "dm-search-fast-filter";
+function getDmSearchClasses({
+  compact,
+  collapsed,
+  className
+}) {
+  return cn(dmSearchBaseClass, compact && dmSearchCompactClass, collapsed && dmSearchCollapsedClass, className);
+}
+
+// src/components/dm-search/DmSearch.tsx
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+function initialValues(items, searchParams, useSearchParams = true) {
+  return items.reduce((acc, item) => {
+    const defaultValue = item.search.extraProps?.value ?? item.search.formProps?.initialValue;
+    acc[item.dataIndex] = useSearchParams && searchParams && item.dataIndex in searchParams ? searchParams[item.dataIndex] : defaultValue;
+    return acc;
+  }, {});
+}
+function optionList(extraProps) {
+  return Array.isArray(extraProps?.options) ? extraProps.options : [];
+}
+function renderField({
+  item,
+  value,
+  setValue,
+  loading,
+  enableDefaultPlaceHolder
+}) {
+  const extraProps = item.search.extraProps ?? {};
+  const placeholder = extraProps.placeholder ?? (enableDefaultPlaceHolder ? item.search.type === "select" ? "Please select" : "Please enter" : undefined);
+  if (item.search.type === "custom") {
+    return item.search.render?.(value, setValue, item) ?? null;
+  }
+  if (item.search.type === "select") {
+    return /* @__PURE__ */ jsx10(Select, {
+      ...extraProps,
+      disabled: Boolean(loading || extraProps.disabled),
+      value,
+      placeholder,
+      onChange: (nextValue) => setValue(nextValue)
+    });
+  }
+  if (item.search.type === "dateRange") {
+    return /* @__PURE__ */ jsx10(DatePicker.RangePicker, {
+      ...extraProps,
+      value,
+      onChange: (nextValue) => setValue(nextValue)
+    });
+  }
+  if (item.search.type === "date") {
+    return /* @__PURE__ */ jsx10(DatePicker, {
+      ...extraProps,
+      value,
+      onChange: (nextValue) => setValue(nextValue)
+    });
+  }
+  if (item.search.type === "radio" || item.search.type === "checkbox") {
+    return /* @__PURE__ */ jsx10("div", {
+      role: item.search.type === "radio" ? "radiogroup" : "group",
+      children: optionList(extraProps).map((option) => /* @__PURE__ */ jsxs9("label", {
+        children: [
+          /* @__PURE__ */ jsx10("input", {
+            type: item.search.type,
+            disabled: loading,
+            checked: item.search.type === "checkbox" ? Array.isArray(value) && value.includes(option.value) : value === option.value,
+            onChange: (event) => {
+              if (item.search.type === "radio") {
+                setValue(option.value);
+                return;
+              }
+              const current = Array.isArray(value) ? value : [];
+              setValue(event.currentTarget.checked ? [...current, option.value] : current.filter((entry) => entry !== option.value));
+            }
+          }),
+          option.label ?? option.value
+        ]
+      }, String(option.value)))
+    });
+  }
+  return /* @__PURE__ */ jsx10(Input, {
+    ...extraProps,
+    type: item.search.type === "input-number" ? "number" : "text",
+    disabled: Boolean(loading || extraProps.disabled),
+    placeholder,
+    value: value == null ? "" : String(value),
+    onChange: (event) => setValue(event.currentTarget.value),
+    onKeyDown: (event) => {
+      if (event.key === "Enter") {
+        event.currentTarget.form?.requestSubmit();
+      }
+    }
+  });
+}
+var DmSearch = forwardRef7(({
+  items = [],
+  onSearch,
+  extra,
+  fastFilterItem,
+  defaultCollapsed = true,
+  hideCollapseBtn = false,
+  compact = false,
+  searchParams,
+  loading = false,
+  enableDefaultPlaceHolder = false,
+  className
+}, ref) => {
+  const allItems = useMemo6(() => fastFilterItem ? [fastFilterItem, ...items] : items, [fastFilterItem, items]);
+  const [collapsed, setCollapsed] = useState7(defaultCollapsed);
+  const [values, setValues] = useState7(() => initialValues(allItems, searchParams));
+  const visibleItems = collapsed ? allItems.slice(0, 1) : allItems;
+  useEffect2(() => {
+    setValues(initialValues(allItems, searchParams));
+  }, [allItems, searchParams]);
+  function reset(useSearchParams = false) {
+    const nextValues = initialValues(allItems, searchParams, useSearchParams);
+    setValues(nextValues);
+    return nextValues;
+  }
+  useImperativeHandle2(ref, () => ({
+    onReset: () => {
+      reset(false);
+    }
+  }));
+  return /* @__PURE__ */ jsxs9("form", {
+    id: "searchForm",
+    className: getDmSearchClasses({ compact, collapsed, className }),
+    onSubmit: (event) => {
+      event.preventDefault();
+      onSearch?.(values);
+    },
+    children: [
+      fastFilterItem ? /* @__PURE__ */ jsx10("div", {
+        className: dmSearchFastFilterClass,
+        children: fastFilterItem.title
+      }) : null,
+      /* @__PURE__ */ jsx10("div", {
+        className: dmSearchFieldsClass,
+        children: visibleItems.map((item) => /* @__PURE__ */ jsxs9("label", {
+          className: dmSearchFieldClass,
+          children: [
+            compact ? null : /* @__PURE__ */ jsx10("span", {
+              children: item.title
+            }),
+            renderField({
+              item,
+              value: values[item.dataIndex],
+              loading,
+              enableDefaultPlaceHolder,
+              setValue: (value) => setValues((current) => ({ ...current, [item.dataIndex]: value }))
+            })
+          ]
+        }, item.key))
+      }),
+      /* @__PURE__ */ jsxs9("div", {
+        className: dmSearchActionsClass,
+        children: [
+          /* @__PURE__ */ jsx10(Button, {
+            type: "submit",
+            isLoading: loading,
+            children: "Search"
+          }),
+          /* @__PURE__ */ jsx10(Button, {
+            type: "button",
+            color: "secondary",
+            appearance: "outline",
+            onClick: () => onSearch?.(reset(false)),
+            children: "Reset"
+          }),
+          !hideCollapseBtn && allItems.length > 1 ? /* @__PURE__ */ jsx10(Button, {
+            type: "button",
+            color: "secondary",
+            appearance: "text",
+            onClick: () => {
+              setCollapsed((current) => !current);
+              setValues(initialValues(allItems, searchParams));
+            },
+            children: collapsed ? "Expand" : "Collapse"
+          }) : null,
+          extra
+        ]
+      })
+    ]
+  });
+});
+DmSearch.displayName = "DmSearch";
+// src/components/table/Table.tsx
+import React9, {
+  forwardRef as forwardRef8,
+  useMemo as useMemo7,
+  useState as useState8
+} from "react";
+
+// src/classes/table.ts
+var tableWrapperClass = "table-wrapper";
+var tableBaseClass = "table";
+var tableBorderedClass = "table-bordered";
+var tableLoadingClass = "table-loading";
+var tableSmallClass = "table-sm";
+var tableLargeClass = "table-lg";
+var tableHeaderCellClass = "table-header-cell";
+var tableCellClass = "table-cell";
+var tableRowClass = "table-row";
+var tableRowSelectedClass = "table-row-selected";
+var tableRowExpandedClass = "table-row-expanded";
+var tableEmptyClass = "table-empty";
+var tableLoadingIndicatorClass = "table-loading-indicator";
+var tableSorterClass = "table-sorter";
+var tableSorterActiveClass = "table-sorter-active";
+var tableFilterClass = "table-filter";
+var tableSelectionCellClass = "table-selection-cell";
+var tableExpandCellClass = "table-expand-cell";
+var tableExpandButtonClass = "table-expand-button";
+var tablePaginationClass = "table-pagination";
+var tablePaginationButtonClass = "table-pagination-button";
+var tablePaginationInfoClass = "table-pagination-info";
+function getTableWrapperClasses({
+  loading,
+  className
+}) {
+  return cn(tableWrapperClass, loading && tableLoadingClass, className);
+}
+function getTableClasses({
+  bordered,
+  size
+}) {
+  return cn(tableBaseClass, bordered && tableBorderedClass, size === "small" && tableSmallClass, size === "large" && tableLargeClass);
+}
+function getTableRowClasses({
+  selected,
+  expanded,
+  className
+}) {
+  return cn(tableRowClass, selected && tableRowSelectedClass, expanded && tableRowExpandedClass, className);
+}
+function getTableSorterClasses(active) {
+  return cn(tableSorterClass, active && tableSorterActiveClass);
+}
+
+// src/components/table/Table.tsx
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+import { createElement } from "react";
+var defaultPageSize = 10;
+var defaultSortDirections = ["ascend", "descend", null];
+function hasNode(node) {
+  return node !== undefined && node !== null && node !== false;
+}
+function textFromNode(node, fallback) {
+  return typeof node === "string" || typeof node === "number" ? String(node) : fallback;
+}
+function dataIndexKey(dataIndex) {
+  if (dataIndex === undefined) {
+    return;
+  }
+  return typeof dataIndex === "string" || typeof dataIndex === "number" ? dataIndex : Array.from(dataIndex).join(".");
+}
+function getValue(record, dataIndex) {
+  if (dataIndex === undefined) {
+    return;
+  }
+  const path = Array.isArray(dataIndex) ? dataIndex : [dataIndex];
+  return path.reduce((current, key) => {
+    if (current === null || current === undefined) {
+      return;
+    }
+    return current[key];
+  }, record);
+}
+function getRecordKey(record, index, rowKey) {
+  if (typeof rowKey === "function") {
+    return rowKey(record, index);
+  }
+  if (rowKey) {
+    const key2 = record[rowKey];
+    return typeof key2 === "string" || typeof key2 === "number" ? key2 : index;
+  }
+  const key = record.key;
+  return typeof key === "string" || typeof key === "number" ? key : index;
+}
+function normalizeKeys(keys) {
+  return keys?.map(String) ?? [];
+}
+function normalizeColumns(columns, prefix = "column") {
+  return columns.map((column, index) => {
+    const rawKey = column.key ?? dataIndexKey(column.dataIndex) ?? `${prefix}-${index}`;
+    return {
+      ...column,
+      columnKey: rawKey,
+      children: column.children ? normalizeColumns(column.children, String(rawKey)) : undefined
+    };
+  });
+}
+function leafColumns(columns) {
+  return columns.flatMap((column) => column.children?.length ? leafColumns(column.children) : [column]);
+}
+function getDepth(columns) {
+  if (columns.length === 0) {
+    return 1;
+  }
+  return Math.max(...columns.map((column) => column.children?.length ? 1 + getDepth(column.children) : 1));
+}
+function getLeafCount(column) {
+  return column.children?.length ? column.children.reduce((count, child) => count + getLeafCount(child), 0) : 1;
+}
+function buildHeaderRows(columns, depth, level = 0, rows = []) {
+  rows[level] ??= [];
+  columns.forEach((column) => {
+    const grouped = Boolean(column.children?.length);
+    rows[level].push({
+      column,
+      colSpan: grouped ? getLeafCount(column) : 1,
+      rowSpan: grouped ? 1 : depth - level
+    });
+    if (column.children?.length) {
+      buildHeaderRows(column.children, depth, level + 1, rows);
+    }
+  });
+  return rows;
+}
+function optionValues(filters) {
+  return (filters ?? []).flatMap((filter) => [
+    filter,
+    ...filter.children ?? []
+  ]);
+}
+function sortCompare(sorter) {
+  if (typeof sorter === "function") {
+    return sorter;
+  }
+  if (typeof sorter === "object" && sorter.compare) {
+    return sorter.compare;
+  }
+  return;
+}
+function sortOrderFor(column, sortStates) {
+  if (column.sortOrder !== undefined) {
+    return column.sortOrder;
+  }
+  return sortStates[String(column.columnKey)] ?? column.defaultSortOrder;
+}
+function filterValueFor(column, filterStates) {
+  if (column.filteredValue !== undefined) {
+    return column.filteredValue;
+  }
+  const state = filterStates[String(column.columnKey)];
+  return state !== undefined ? state : column.defaultFilteredValue;
+}
+function nextSortOrder(column, current) {
+  const directions = column.sortDirections ?? defaultSortDirections;
+  const index = directions.findIndex((order) => order === (current ?? null));
+  return directions[(index + 1) % directions.length] ?? null;
+}
+function selectedRowsForKeys(data, keys, rowKey) {
+  const keySet = new Set(normalizeKeys(keys));
+  return data.filter((record, index) => keySet.has(String(getRecordKey(record, index, rowKey))));
+}
+var Column = forwardRef8(() => null);
+Column.displayName = "Table.Column";
+var ColumnGroup = forwardRef8(() => null);
+ColumnGroup.displayName = "Table.ColumnGroup";
+var SummaryRow = forwardRef8((props, ref) => /* @__PURE__ */ jsx11("tr", {
+  ...props,
+  ref
+}));
+SummaryRow.displayName = "Table.Summary.Row";
+var SummaryCell = forwardRef8(({ index, ...props }, ref) => {
+  return /* @__PURE__ */ jsx11("td", {
+    ...props,
+    ref
+  });
+});
+SummaryCell.displayName = "Table.Summary.Cell";
+var Summary = Object.assign(forwardRef8(({ fixed, ...props }, ref) => {
+  return /* @__PURE__ */ jsx11("tfoot", {
+    ...props,
+    ref
+  });
+}), {
+  Row: SummaryRow,
+  Cell: SummaryCell
+});
+Summary.displayName = "Table.Summary";
+function columnsFromChildren(children) {
+  return React9.Children.toArray(children).flatMap((child) => {
+    if (!React9.isValidElement(child)) {
+      return [];
+    }
+    if (child.type === Column) {
+      const props = child.props;
+      const { children: columnChildren, ...column } = props;
+      return [column];
+    }
+    if (child.type === ColumnGroup) {
+      const props = child.props;
+      const { children: groupChildren, ...column } = props;
+      return [
+        {
+          ...column,
+          children: columnsFromChildren(groupChildren)
+        }
+      ];
+    }
+    return [];
+  });
+}
+function renderSummary(summary, pageData, colSpan) {
+  if (!summary) {
+    return null;
+  }
+  const node = summary(pageData);
+  if (React9.isValidElement(node) && node.type === Summary) {
+    return node;
+  }
+  return /* @__PURE__ */ jsx11("tfoot", {
+    children: /* @__PURE__ */ jsx11("tr", {
+      children: /* @__PURE__ */ jsx11("td", {
+        className: tableCellClass,
+        colSpan,
+        children: node
+      })
+    })
+  });
+}
+function resolvePagination(pagination, total) {
+  if (pagination === false) {
+    return null;
+  }
+  const config = pagination ?? {};
+  return {
+    current: config.current,
+    defaultCurrent: config.defaultCurrent ?? 1,
+    pageSize: config.pageSize,
+    defaultPageSize: config.defaultPageSize ?? defaultPageSize,
+    total: config.total ?? total,
+    disabled: config.disabled,
+    hideOnSinglePage: config.hideOnSinglePage,
+    showTotal: config.showTotal,
+    onChange: config.onChange
+  };
+}
+function TableRoot({
+  columns,
+  dataSource = [],
+  rowKey,
+  loading,
+  bordered,
+  size = "middle",
+  pagination,
+  rowSelection,
+  expandable,
+  summary,
+  locale,
+  tableLayout,
+  scroll,
+  onChange,
+  children,
+  className,
+  ...props
+}, ref) {
+  const childColumns = useMemo7(() => columnsFromChildren(children), [children]);
+  const normalizedColumns = useMemo7(() => normalizeColumns(columns ?? childColumns), [childColumns, columns]);
+  const leaves = useMemo7(() => leafColumns(normalizedColumns), [normalizedColumns]);
+  const headerRows = useMemo7(() => buildHeaderRows(normalizedColumns, getDepth(normalizedColumns)), [normalizedColumns]);
+  const [sortStates, setSortStates] = useState8({});
+  const [filterStates, setFilterStates] = useState8({});
+  const [internalCurrent, setInternalCurrent] = useState8(1);
+  const [internalPageSize, setInternalPageSize] = useState8(defaultPageSize);
+  const [internalSelectedKeys, setInternalSelectedKeys] = useState8(rowSelection?.defaultSelectedRowKeys ?? []);
+  const [internalExpandedKeys, setInternalExpandedKeys] = useState8(expandable?.defaultExpandedRowKeys ?? []);
+  const spinning = typeof loading === "object" ? loading.spinning : Boolean(loading);
+  const activeFilters = useMemo7(() => {
+    return leaves.reduce((result, column) => {
+      const value = filterValueFor(column, filterStates) ?? null;
+      if (value !== null) {
+        result[String(column.columnKey)] = value;
+      }
+      return result;
+    }, {});
+  }, [filterStates, leaves]);
+  const activeSorter = useMemo7(() => {
+    const column = leaves.find((item) => sortOrderFor(item, sortStates));
+    if (!column) {
+      return {};
+    }
+    return {
+      column,
+      columnKey: column.columnKey,
+      field: column.dataIndex,
+      order: sortOrderFor(column, sortStates) ?? null
+    };
+  }, [leaves, sortStates]);
+  const filteredData = useMemo7(() => {
+    return leaves.reduce((records, column) => {
+      const values = filterValueFor(column, filterStates);
+      if (!values?.length || !column.onFilter) {
+        return records;
+      }
+      return records.filter((record) => values.some((value) => column.onFilter?.(value, record)));
+    }, dataSource);
+  }, [dataSource, filterStates, leaves]);
+  const sortedData = useMemo7(() => {
+    const sorterColumn = leaves.find((column) => sortOrderFor(column, sortStates));
+    const order = sorterColumn ? sortOrderFor(sorterColumn, sortStates) : null;
+    const compare = sorterColumn ? sortCompare(sorterColumn.sorter) : undefined;
+    if (!sorterColumn || !order || !compare) {
+      return filteredData;
+    }
+    return [...filteredData].sort((first, second) => {
+      const result = compare(first, second);
+      return order === "descend" ? -result : result;
+    });
+  }, [filteredData, leaves, sortStates]);
+  const paginationConfig = resolvePagination(pagination, sortedData.length);
+  const pageSize = Math.max(1, Math.floor(paginationConfig?.pageSize ?? (internalPageSize === defaultPageSize ? paginationConfig?.defaultPageSize : internalPageSize) ?? defaultPageSize));
+  const pageCount = paginationConfig ? Math.max(1, Math.ceil(Math.max(0, paginationConfig.total ?? sortedData.length) / pageSize)) : 1;
+  const current = paginationConfig ? Math.min(pageCount, Math.max(1, Math.floor(paginationConfig.current ?? internalCurrent ?? paginationConfig.defaultCurrent ?? 1))) : 1;
+  const pageData = paginationConfig ? sortedData.slice((current - 1) * pageSize, current * pageSize) : sortedData;
+  const selectedKeys = rowSelection?.selectedRowKeys ?? internalSelectedKeys;
+  const selectedKeySet = new Set(normalizeKeys(selectedKeys));
+  const expandedKeys = expandable?.expandedRowKeys ?? internalExpandedKeys;
+  const expandedKeySet = new Set(normalizeKeys(expandedKeys));
+  const hasSelection = Boolean(rowSelection);
+  const hasExpandable = Boolean(expandable?.expandedRowRender);
+  const structuralColumnCount = leaves.length + (hasSelection ? 1 : 0) + (hasExpandable ? 1 : 0);
+  const bodyEmpty = pageData.length === 0;
+  function emitTableChange(nextPagination, nextFilters, nextSorter, action) {
+    onChange?.(nextPagination, nextFilters, nextSorter, {
+      currentDataSource: sortedData,
+      action
+    });
+  }
+  function changePage(nextPage, nextPageSize = pageSize) {
+    if (!paginationConfig || paginationConfig.disabled) {
+      return;
+    }
+    const nextPageCount = Math.max(1, Math.ceil((paginationConfig.total ?? sortedData.length) / nextPageSize));
+    const normalizedPage = Math.min(nextPageCount, Math.max(1, nextPage));
+    if (paginationConfig.current === undefined) {
+      setInternalCurrent(normalizedPage);
+    }
+    if (paginationConfig.pageSize === undefined) {
+      setInternalPageSize(nextPageSize);
+    }
+    paginationConfig.onChange?.(normalizedPage, nextPageSize);
+    emitTableChange({ ...paginationConfig, current: normalizedPage, pageSize: nextPageSize }, activeFilters, activeSorter, "paginate");
+  }
+  function changeSorter(column) {
+    if (!column.sorter) {
+      return;
+    }
+    const nextOrder = nextSortOrder(column, sortOrderFor(column, sortStates));
+    const nextSortStates = { [String(column.columnKey)]: nextOrder };
+    const nextSorter = nextOrder ? {
+      column,
+      columnKey: column.columnKey,
+      field: column.dataIndex,
+      order: nextOrder
+    } : {};
+    setSortStates(nextSortStates);
+    setInternalCurrent(1);
+    emitTableChange({ ...paginationConfig ?? {}, current: 1, pageSize }, activeFilters, nextSorter, "sort");
+  }
+  function changeFilter(column, event) {
+    const selected = Array.from(event.currentTarget.selectedOptions).map((option) => option.value).filter((value) => value !== "");
+    const nextValue = selected.length > 0 ? selected : null;
+    const nextFilters = {
+      ...activeFilters,
+      [String(column.columnKey)]: nextValue
+    };
+    if (nextValue === null) {
+      delete nextFilters[String(column.columnKey)];
+    }
+    setFilterStates((currentFilters) => ({
+      ...currentFilters,
+      [String(column.columnKey)]: nextValue
+    }));
+    setInternalCurrent(1);
+    emitTableChange({ ...paginationConfig ?? {}, current: 1, pageSize }, nextFilters, activeSorter, "filter");
+  }
+  function commitSelection(nextKeys, nativeEvent, changedRecord, selected, changedRows) {
+    if (!rowSelection) {
+      return;
+    }
+    const normalizedNextKeys = Array.from(new Set(nextKeys.map(String)));
+    const originalKeys = normalizedNextKeys.map((key) => {
+      const index = dataSource.findIndex((record, itemIndex) => String(getRecordKey(record, itemIndex, rowKey)) === key);
+      return index >= 0 ? getRecordKey(dataSource[index], index, rowKey) : key;
+    });
+    const selectedRows = selectedRowsForKeys(dataSource, originalKeys, rowKey);
+    if (rowSelection.selectedRowKeys === undefined) {
+      setInternalSelectedKeys(originalKeys);
+    }
+    rowSelection.onChange?.(originalKeys, selectedRows);
+    if (changedRecord && selected !== undefined) {
+      rowSelection.onSelect?.(changedRecord, selected, selectedRows, nativeEvent);
+    }
+    if (changedRows) {
+      rowSelection.onSelectAll?.(Boolean(selected), selectedRows, changedRows);
+    }
+  }
+  function toggleRowSelection(record, index, event) {
+    if (!rowSelection) {
+      return;
+    }
+    const key = getRecordKey(record, index, rowKey);
+    const keyString = String(key);
+    const checked = event.currentTarget.checked;
+    const nextKeys = rowSelection.type === "radio" ? checked ? [key] : [] : checked ? [...selectedKeys, key] : selectedKeys.filter((selectedKey) => String(selectedKey) !== keyString);
+    commitSelection(nextKeys, event.nativeEvent, record, checked);
+  }
+  function toggleAllRows(event) {
+    if (!rowSelection) {
+      return;
+    }
+    const checked = event.currentTarget.checked;
+    const selectableRows = pageData.filter((record, index) => {
+      const checkboxProps = rowSelection.getCheckboxProps?.(record);
+      return !checkboxProps?.disabled && getRecordKey(record, index, rowKey) !== undefined;
+    });
+    const pageKeys = selectableRows.map((record, index) => getRecordKey(record, index, rowKey));
+    const pageKeySet = new Set(normalizeKeys(pageKeys));
+    const nextKeys = checked ? [...selectedKeys, ...pageKeys] : selectedKeys.filter((key) => !pageKeySet.has(String(key)));
+    commitSelection(nextKeys, event.nativeEvent, undefined, checked, selectableRows);
+  }
+  function toggleExpand(record, index) {
+    if (!expandable?.expandedRowRender) {
+      return;
+    }
+    const key = getRecordKey(record, index, rowKey);
+    const keyString = String(key);
+    const expanded = !expandedKeySet.has(keyString);
+    const nextKeys = expanded ? [...expandedKeys, key] : expandedKeys.filter((expandedKey) => String(expandedKey) !== keyString);
+    if (expandable.expandedRowKeys === undefined) {
+      setInternalExpandedKeys(nextKeys);
+    }
+    expandable.onExpand?.(expanded, record);
+    expandable.onExpandedRowsChange?.(nextKeys);
+  }
+  function renderSelectionHeader() {
+    if (!rowSelection) {
+      return null;
+    }
+    if (rowSelection.type === "radio" || rowSelection.hideSelectAll) {
+      return /* @__PURE__ */ jsx11("th", {
+        className: cn(tableHeaderCellClass, tableSelectionCellClass),
+        children: rowSelection.columnTitle
+      });
+    }
+    const pageKeys = pageData.map((record, index) => getRecordKey(record, index, rowKey));
+    const allSelected = pageKeys.length > 0 && pageKeys.every((key) => selectedKeySet.has(String(key)));
+    return /* @__PURE__ */ jsx11("th", {
+      className: cn(tableHeaderCellClass, tableSelectionCellClass),
+      children: /* @__PURE__ */ jsxs10("label", {
+        children: [
+          /* @__PURE__ */ jsx11("input", {
+            type: "checkbox",
+            "aria-label": "Select all rows",
+            checked: allSelected,
+            onChange: toggleAllRows
+          }),
+          hasNode(rowSelection.columnTitle) ? rowSelection.columnTitle : null
+        ]
+      })
+    });
+  }
+  function renderHeaderCell(cell, index) {
+    const { column } = cell;
+    const title = column.title ?? dataIndexKey(column.dataIndex) ?? index + 1;
+    const sortOrder = sortOrderFor(column, sortStates);
+    const headerProps = column.onHeaderCell?.(column) ?? {};
+    return /* @__PURE__ */ createElement("th", {
+      ...headerProps,
+      key: String(column.columnKey),
+      className: cn(tableHeaderCellClass, column.className, headerProps.className),
+      colSpan: cell.colSpan,
+      rowSpan: cell.rowSpan,
+      style: {
+        width: column.width,
+        textAlign: column.align,
+        ...headerProps.style
+      }
+    }, /* @__PURE__ */ jsx11("span", {
+      children: title
+    }), column.sorter ? /* @__PURE__ */ jsx11("button", {
+      type: "button",
+      className: getTableSorterClasses(Boolean(sortOrder)),
+      "aria-label": `Sort ${textFromNode(title, String(column.columnKey))}`,
+      onClick: () => changeSorter(column),
+      children: sortOrder === "ascend" ? "Asc" : sortOrder === "descend" ? "Desc" : "Sort"
+    }) : null, column.filters?.length ? /* @__PURE__ */ jsxs10("select", {
+      className: tableFilterClass,
+      "aria-label": `Filter ${textFromNode(title, String(column.columnKey))}`,
+      multiple: column.filterMultiple !== false,
+      value: column.filterMultiple === false ? String((filterValueFor(column, filterStates) ?? [])[0] ?? "") : (filterValueFor(column, filterStates) ?? []).map(String),
+      onChange: (event) => changeFilter(column, event),
+      children: [
+        column.filterMultiple === false ? /* @__PURE__ */ jsx11("option", {
+          value: "",
+          children: "All"
+        }) : null,
+        optionValues(column.filters).map((filter) => /* @__PURE__ */ jsx11("option", {
+          value: String(filter.value),
+          children: filter.text
+        }, String(filter.value)))
+      ]
+    }) : null);
+  }
+  function renderCell(record, recordIndex, column) {
+    const value = getValue(record, column.dataIndex);
+    const rendered = column.render ? column.render(value, record, recordIndex) : value;
+    const cellProps = column.onCell?.(record, recordIndex) ?? {};
+    return /* @__PURE__ */ createElement("td", {
+      ...cellProps,
+      key: String(column.columnKey),
+      className: cn(tableCellClass, column.className, cellProps.className),
+      style: { textAlign: column.align, ...cellProps.style }
+    }, hasNode(rendered) ? rendered : null);
+  }
+  function renderSelectionCell(record, index) {
+    if (!rowSelection) {
+      return null;
+    }
+    const key = getRecordKey(record, index, rowKey);
+    const checked = selectedKeySet.has(String(key));
+    const checkboxProps = rowSelection.getCheckboxProps?.(record) ?? {};
+    const originNode = /* @__PURE__ */ jsx11("input", {
+      ...checkboxProps,
+      type: rowSelection.type === "radio" ? "radio" : "checkbox",
+      "aria-label": `Select row ${index + 1}`,
+      checked,
+      onChange: (event) => toggleRowSelection(record, index, event)
+    });
+    return /* @__PURE__ */ jsx11("td", {
+      className: cn(tableCellClass, tableSelectionCellClass),
+      children: rowSelection.renderCell ? rowSelection.renderCell(checked, record, index, originNode) : originNode
+    });
+  }
+  function renderExpandCell(record, index) {
+    if (!expandable?.expandedRowRender) {
+      return null;
+    }
+    const key = getRecordKey(record, index, rowKey);
+    const expanded = expandedKeySet.has(String(key));
+    const expandableRow = expandable.rowExpandable?.(record) ?? true;
+    return /* @__PURE__ */ jsx11("td", {
+      className: cn(tableCellClass, tableExpandCellClass),
+      children: expandableRow ? /* @__PURE__ */ jsx11("button", {
+        type: "button",
+        className: tableExpandButtonClass,
+        "aria-label": `${expanded ? "Collapse" : "Expand"} row ${index + 1}`,
+        onClick: () => toggleExpand(record, index),
+        children: expanded ? "-" : "+"
+      }) : null
+    });
+  }
+  function renderRow(record, index) {
+    const key = getRecordKey(record, index, rowKey);
+    const expanded = expandedKeySet.has(String(key));
+    const selected = selectedKeySet.has(String(key));
+    const row = /* @__PURE__ */ jsxs10("tr", {
+      className: getTableRowClasses({ selected, expanded }),
+      onClick: () => {
+        if (expandable?.expandRowByClick) {
+          toggleExpand(record, index);
+        }
+      },
+      children: [
+        renderSelectionCell(record, index),
+        renderExpandCell(record, index),
+        leaves.map((column) => renderCell(record, index, column))
+      ]
+    }, String(key));
+    if (!expanded || !expandable?.expandedRowRender) {
+      return row;
+    }
+    return /* @__PURE__ */ jsxs10(React9.Fragment, {
+      children: [
+        row,
+        /* @__PURE__ */ jsx11("tr", {
+          className: "table-expanded-row",
+          children: /* @__PURE__ */ jsx11("td", {
+            className: tableCellClass,
+            colSpan: structuralColumnCount,
+            children: expandable.expandedRowRender(record, index, 0, expanded)
+          })
+        })
+      ]
+    }, String(key));
+  }
+  const tableNode = /* @__PURE__ */ jsxs10("table", {
+    className: getTableClasses({ bordered, size }),
+    style: { tableLayout },
+    children: [
+      /* @__PURE__ */ jsx11("thead", {
+        children: headerRows.map((row, rowIndex) => /* @__PURE__ */ jsxs10("tr", {
+          children: [
+            rowIndex === 0 ? renderSelectionHeader() : null,
+            rowIndex === 0 && hasExpandable ? /* @__PURE__ */ jsx11("th", {
+              className: cn(tableHeaderCellClass, tableExpandCellClass),
+              children: expandable?.columnTitle
+            }) : null,
+            row.map(renderHeaderCell)
+          ]
+        }, rowIndex))
+      }),
+      /* @__PURE__ */ jsx11("tbody", {
+        children: bodyEmpty ? /* @__PURE__ */ jsx11("tr", {
+          children: /* @__PURE__ */ jsx11("td", {
+            className: tableEmptyClass,
+            colSpan: structuralColumnCount,
+            children: locale?.emptyText ?? "No data"
+          })
+        }) : pageData.map(renderRow)
+      }),
+      renderSummary(summary, pageData, structuralColumnCount)
+    ]
+  });
+  return /* @__PURE__ */ jsxs10("div", {
+    ...props,
+    ref,
+    className: getTableWrapperClasses({ loading: spinning, className }),
+    children: [
+      scroll?.x || scroll?.y ? /* @__PURE__ */ jsx11("div", {
+        style: {
+          overflow: "auto",
+          maxHeight: scroll.y,
+          width: scroll.x === true ? "100%" : scroll.x
+        },
+        children: tableNode
+      }) : tableNode,
+      spinning ? /* @__PURE__ */ jsx11("div", {
+        className: tableLoadingIndicatorClass,
+        role: "status",
+        children: typeof loading === "object" && loading.indicator ? loading.indicator : "Loading"
+      }) : null,
+      paginationConfig && !(paginationConfig.hideOnSinglePage && pageCount <= 1) ? /* @__PURE__ */ jsxs10("nav", {
+        className: tablePaginationClass,
+        "aria-label": "Table pagination",
+        children: [
+          /* @__PURE__ */ jsx11("button", {
+            type: "button",
+            className: tablePaginationButtonClass,
+            disabled: paginationConfig.disabled || current <= 1,
+            onClick: () => changePage(current - 1),
+            children: "Previous"
+          }),
+          /* @__PURE__ */ jsx11("span", {
+            className: tablePaginationInfoClass,
+            children: paginationConfig.showTotal ? paginationConfig.showTotal(paginationConfig.total ?? sortedData.length, [
+              bodyEmpty ? 0 : (current - 1) * pageSize + 1,
+              Math.min(current * pageSize, sortedData.length)
+            ]) : `${current} / ${pageCount}`
+          }),
+          /* @__PURE__ */ jsx11("button", {
+            type: "button",
+            className: tablePaginationButtonClass,
+            disabled: paginationConfig.disabled || current >= pageCount,
+            onClick: () => changePage(current + 1),
+            children: "Next"
+          })
+        ]
+      }) : null
+    ]
+  });
+}
+var TableWithRef = forwardRef8(TableRoot);
+var Table = Object.assign(TableWithRef, {
+  Column,
+  ColumnGroup,
+  Summary,
+  SELECTION_ALL: "SELECT_ALL",
+  SELECTION_INVERT: "SELECT_INVERT",
+  SELECTION_NONE: "SELECT_NONE",
+  SELECTION_COLUMN: "SELECTION_COLUMN",
+  EXPAND_COLUMN: "EXPAND_COLUMN"
+});
+Table.displayName = "Table";
+// src/components/dm-table/DmTable.tsx
+import { useMemo as useMemo8, useState as useState9 } from "react";
+
+// src/classes/dm-table.ts
+var dmTableBaseClass = "dm-table";
+var dmTableSearchClass = "dm-table-search";
+var dmTableCardClass = "dm-table-card";
+var dmTableHeaderClass = "dm-table-header";
+var dmTableTitleClass = "dm-table-title";
+var dmTableExtraClass = "dm-table-extra";
+var dmTableIndicatorsClass = "dm-table-indicators";
+var dmTableTableExtraClass = "dm-table-table-extra";
+var dmTableColumnSettingClass = "dm-table-column-setting";
+var dmTablePaginationClass = "dm-table-pagination";
+function getDmTableClasses({ className }) {
+  return cn(dmTableBaseClass, className);
+}
+
+// src/components/dm-table/DmTable.tsx
+import { jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
+function mapAndFilter(list, mapper) {
+  return list.map(mapper).filter((item) => item !== false && item != null);
+}
+function filterDmTableColumn(column) {
+  if (column.onlySearch || column.hideInTable)
+    return false;
+  if (Array.isArray(column.children)) {
+    const children = mapAndFilter(column.children, filterDmTableColumn);
+    return children.length > 0 ? { ...column, children } : null;
+  }
+  return column;
+}
+function filterSearchColumn(column) {
+  if (Array.isArray(column.children)) {
+    const children = mapAndFilter(column.children, filterSearchColumn);
+    return children.length > 0 ? { ...column, children } : null;
+  }
+  return column.search ? column : false;
+}
+function flattenSearchColumns(column) {
+  return Array.isArray(column.children) ? column.children.flatMap(flattenSearchColumns) : [column];
+}
+function searchItems(columns) {
+  return mapAndFilter(columns, filterSearchColumn).flatMap(flattenSearchColumns).map((column) => ({
+    key: String(column.key ?? column.dataIndex),
+    title: column.title,
+    dataIndex: String(column.dataIndex ?? column.key),
+    search: column.search || {
+      type: "input",
+      extraProps: {},
+      formProps: {}
+    }
+  }));
+}
+function DmTable({
+  name,
+  extra,
+  indicators,
+  pagination,
+  columns: inputColumns,
+  columnSettingVisible = true,
+  onColumnsChange,
+  columnState,
+  searchProps,
+  tableExtra,
+  className,
+  dataSource,
+  rowSelection,
+  ...props
+}) {
+  const tableColumns = useMemo8(() => mapAndFilter(inputColumns, filterDmTableColumn), [inputColumns]);
+  const [columns, setColumns] = useState9(tableColumns);
+  const [columnSettingsOpen, setColumnSettingsOpen] = useState9(false);
+  const items = searchProps?.items?.length ? searchProps.items : searchItems(inputColumns);
+  const paginationObj = typeof pagination === "object" ? pagination : undefined;
+  const paginationProps = paginationObj ? Object.fromEntries(Object.entries(paginationObj).filter(([key]) => key !== "ref")) : {};
+  const total = paginationObj?.total ?? dataSource?.length ?? 0;
+  const selectedTotal = rowSelection?.selectedRowKeys?.length ?? 0;
+  function resetColumns() {
+    setColumns(tableColumns);
+    onColumnsChange?.(tableColumns);
+    if (columnState?.persistenceKey) {
+      globalThis.localStorage?.removeItem(columnState.persistenceKey);
+    }
+  }
+  return /* @__PURE__ */ jsxs11("div", {
+    className: getDmTableClasses({ className }),
+    children: [
+      items.length > 0 || searchProps?.fastFilterItem ? /* @__PURE__ */ jsx12(Card, {
+        className: dmTableSearchClass,
+        padding: "md",
+        children: /* @__PURE__ */ jsx12(DmSearch, {
+          ...searchProps,
+          items
+        })
+      }) : null,
+      indicators ? /* @__PURE__ */ jsx12("div", {
+        className: dmTableIndicatorsClass,
+        children: indicators
+      }) : null,
+      /* @__PURE__ */ jsxs11(Card, {
+        className: dmTableCardClass,
+        padding: "md",
+        children: [
+          name || extra || columnSettingVisible ? /* @__PURE__ */ jsxs11("div", {
+            className: dmTableHeaderClass,
+            children: [
+              /* @__PURE__ */ jsx12("div", {
+                className: dmTableTitleClass,
+                children: name
+              }),
+              /* @__PURE__ */ jsxs11("div", {
+                className: dmTableExtraClass,
+                children: [
+                  extra,
+                  columnSettingVisible ? /* @__PURE__ */ jsx12(Button, {
+                    type: "button",
+                    color: "secondary",
+                    appearance: "outline",
+                    className: dmTableColumnSettingClass,
+                    onClick: () => setColumnSettingsOpen((open) => !open),
+                    children: "Columns"
+                  }) : null
+                ]
+              })
+            ]
+          }) : null,
+          columnSettingsOpen ? /* @__PURE__ */ jsx12("div", {
+            role: "dialog",
+            "aria-label": "Column settings",
+            children: /* @__PURE__ */ jsx12(Button, {
+              type: "button",
+              onClick: resetColumns,
+              children: "Reset columns"
+            })
+          }) : null,
+          tableExtra ? /* @__PURE__ */ jsx12("div", {
+            className: dmTableTableExtraClass,
+            children: tableExtra
+          }) : null,
+          /* @__PURE__ */ jsx12(Table, {
+            ...props,
+            dataSource,
+            rowSelection,
+            size: props.size ?? "small",
+            scroll: props.scroll ?? { x: 680 },
+            columns,
+            pagination: pagination ? {
+              current: paginationObj?.current,
+              defaultCurrent: paginationObj?.defaultCurrent,
+              pageSize: paginationObj?.pageSize,
+              defaultPageSize: paginationObj?.defaultPageSize,
+              total,
+              onChange: paginationObj?.onChange
+            } : false
+          }),
+          pagination ? /* @__PURE__ */ jsx12(DmPagination, {
+            ...paginationProps,
+            className: dmTablePaginationClass,
+            total,
+            selectedTotal,
+            showSizeChanger: true
+          }) : null
+        ]
+      })
+    ]
+  });
+}
+DmTable.displayName = "DmTable";
+// src/components/dm-pro-table-inner/DmProTableInner.tsx
+import { jsx as jsx13 } from "react/jsx-runtime";
+function DmProTableInner({
+  rowData,
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx13(DmTable, {
+    ...props,
+    className: getDmTableClasses({ className }),
+    dataSource: rowData
+  });
+}
+DmProTableInner.displayName = "DmProTableInner";
+// src/classes/dm-pro-table.ts
+var dmProTableBaseClass = "dm-pro-table";
+var dmProTableHeaderClass = "dm-pro-table-header";
+var dmProTableTitleClass = "dm-pro-table-title";
+var dmProTableToolbarClass = "dm-pro-table-toolbar";
+var dmProTableColumnSettingClass = "dm-pro-table-column-setting";
+function getDmProTableClasses({ className }) {
+  return cn(dmProTableBaseClass, className);
+}
+
+// src/components/dm-pro-table/DmProTable.tsx
+import { jsx as jsx14, jsxs as jsxs12 } from "react/jsx-runtime";
+function renderToolbar(toolBarRender) {
+  if (typeof toolBarRender === "function")
+    return toolBarRender();
+  return toolBarRender;
+}
+function DmProTable({
+  headerTitle,
+  toolBarRender,
+  toolbarItems,
+  showTitleBar = true,
+  columnSettingVisible,
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxs12("div", {
+    className: getDmProTableClasses({ className }),
+    children: [
+      showTitleBar ? /* @__PURE__ */ jsxs12("div", {
+        className: dmProTableHeaderClass,
+        children: [
+          /* @__PURE__ */ jsx14("div", {
+            className: dmProTableTitleClass,
+            children: headerTitle
+          }),
+          /* @__PURE__ */ jsxs12("div", {
+            className: dmProTableToolbarClass,
+            children: [
+              toolbarItems?.length ? /* @__PURE__ */ jsx14(DmToolbar, {
+                items: toolbarItems
+              }) : renderToolbar(toolBarRender),
+              columnSettingVisible ? /* @__PURE__ */ jsx14(Button, {
+                type: "button",
+                color: "secondary",
+                appearance: "outline",
+                className: dmProTableColumnSettingClass,
+                children: "Columns"
+              }) : null
+            ]
+          })
+        ]
+      }) : null,
+      /* @__PURE__ */ jsx14(DmProTableInner, {
+        ...props,
+        columnSettingVisible: showTitleBar ? false : columnSettingVisible
+      })
+    ]
+  });
+}
+DmProTable.displayName = "DmProTable";
+export {
+  DmProTable
+};