var __defProp = Object.defineProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, {
      get: all[name],
      enumerable: true,
      configurable: true,
      set: (newValue) => all[name] = () => newValue
    });
};

// src/sigpro.js
var activeEffect = null;
var currentOwner = null;
var effectQueue = new Set;
var isFlushing = false;
var MOUNTED_NODES = new WeakMap;
var doc = document;
var isArr = Array.isArray;
var assign = Object.assign;
var createEl = (t) => doc.createElement(t);
var createText = (t) => doc.createTextNode(String(t ?? ""));
var isFunc = (f) => typeof f === "function";
var isObj = (o) => typeof o === "object" && o !== null;
var runWithContext = (effect, callback) => {
  const previousEffect = activeEffect;
  activeEffect = effect;
  try {
    return callback();
  } finally {
    activeEffect = previousEffect;
  }
};
var cleanupNode = (node) => {
  if (node._cleanups) {
    node._cleanups.forEach((dispose) => dispose());
    node._cleanups.clear();
  }
  node.childNodes?.forEach(cleanupNode);
};
var flushEffects = () => {
  if (isFlushing)
    return;
  isFlushing = true;
  while (effectQueue.size > 0) {
    const sortedEffects = Array.from(effectQueue).sort((a, b) => (a.depth || 0) - (b.depth || 0));
    effectQueue.clear();
    for (const effect of sortedEffects) {
      if (!effect._deleted)
        effect();
    }
  }
  isFlushing = false;
};
var trackSubscription = (subscribers) => {
  if (activeEffect && !activeEffect._deleted) {
    subscribers.add(activeEffect);
    activeEffect._deps.add(subscribers);
  }
};
var triggerUpdate = (subscribers) => {
  subscribers.forEach((effect) => {
    if (effect === activeEffect || effect._deleted)
      return;
    if (effect._isComputed) {
      effect.markDirty();
      if (effect._subs)
        triggerUpdate(effect._subs);
    } else {
      effectQueue.add(effect);
    }
  });
  if (!isFlushing)
    queueMicrotask(flushEffects);
};
var Render = (renderFn) => {
  const cleanups = new Set;
  const previousOwner = currentOwner;
  const container = createEl("div");
  container.style.display = "contents";
  currentOwner = { cleanups };
  const processResult = (result) => {
    if (!result)
      return;
    if (result._isRuntime) {
      cleanups.add(result.destroy);
      container.appendChild(result.container);
    } else if (isArr(result)) {
      result.forEach(processResult);
    } else {
      container.appendChild(result instanceof Node ? result : createText(result));
    }
  };
  try {
    processResult(renderFn({ onCleanup: (fn) => cleanups.add(fn) }));
  } finally {
    currentOwner = previousOwner;
  }
  return {
    _isRuntime: true,
    container,
    destroy: () => {
      cleanups.forEach((fn) => fn());
      cleanupNode(container);
      container.remove();
    }
  };
};
var $ = (initialValue, storageKey = null) => {
  const subscribers = new Set;
  if (isFunc(initialValue)) {
    let cachedValue, isDirty = true;
    const effect = () => {
      if (effect._deleted)
        return;
      effect._deps.forEach((dep) => dep.delete(effect));
      effect._deps.clear();
      runWithContext(effect, () => {
        const newValue = initialValue();
        if (!Object.is(cachedValue, newValue) || isDirty) {
          cachedValue = newValue;
          isDirty = false;
          triggerUpdate(subscribers);
        }
      });
    };
    assign(effect, {
      _deps: new Set,
      _isComputed: true,
      _subs: subscribers,
      _deleted: false,
      markDirty: () => isDirty = true,
      stop: () => {
        effect._deleted = true;
        effect._deps.forEach((dep) => dep.delete(effect));
        subscribers.clear();
      }
    });
    if (currentOwner)
      currentOwner.cleanups.add(effect.stop);
    return () => {
      if (isDirty)
        effect();
      trackSubscription(subscribers);
      return cachedValue;
    };
  }
  let value = initialValue;
  if (storageKey) {
    try {
      const saved = localStorage.getItem(storageKey);
      if (saved !== null)
        value = JSON.parse(saved);
    } catch (e) {
      console.warn("SigPro Storage Lock", e);
    }
  }
  return (...args) => {
    if (args.length) {
      const nextValue = isFunc(args[0]) ? args[0](value) : args[0];
      if (!Object.is(value, nextValue)) {
        value = nextValue;
        if (storageKey)
          localStorage.setItem(storageKey, JSON.stringify(value));
        triggerUpdate(subscribers);
      }
    }
    trackSubscription(subscribers);
    return value;
  };
};
var $$ = (object, cache = new WeakMap) => {
  if (!isObj(object))
    return object;
  if (cache.has(object))
    return cache.get(object);
  const keySubscribers = {};
  const proxy = new Proxy(object, {
    get(target, key) {
      if (activeEffect)
        trackSubscription(keySubscribers[key] ??= new Set);
      const value = Reflect.get(target, key);
      return isObj(value) ? $$(value, cache) : value;
    },
    set(target, key, value) {
      if (Object.is(target[key], value))
        return true;
      const success = Reflect.set(target, key, value);
      if (keySubscribers[key])
        triggerUpdate(keySubscribers[key]);
      return success;
    }
  });
  cache.set(object, proxy);
  return proxy;
};
var Watch2 = (target, callbackFn) => {
  const isExplicit = isArr(target);
  const callback = isExplicit ? callbackFn : target;
  if (!isFunc(callback))
    return () => {};
  const owner = currentOwner;
  const runner = () => {
    if (runner._deleted)
      return;
    runner._deps.forEach((dep) => dep.delete(runner));
    runner._deps.clear();
    runner._cleanups.forEach((cleanup) => cleanup());
    runner._cleanups.clear();
    const previousOwner = currentOwner;
    runner.depth = activeEffect ? activeEffect.depth + 1 : 0;
    runWithContext(runner, () => {
      currentOwner = { cleanups: runner._cleanups };
      if (isExplicit) {
        runWithContext(null, callback);
        target.forEach((dep) => isFunc(dep) && dep());
      } else {
        callback();
      }
      currentOwner = previousOwner;
    });
  };
  assign(runner, {
    _deps: new Set,
    _cleanups: new Set,
    _deleted: false,
    stop: () => {
      if (runner._deleted)
        return;
      runner._deleted = true;
      effectQueue.delete(runner);
      runner._deps.forEach((dep) => dep.delete(runner));
      runner._cleanups.forEach((cleanup) => cleanup());
      if (owner)
        owner.cleanups.delete(runner.stop);
    }
  });
  if (owner)
    owner.cleanups.add(runner.stop);
  runner();
  return runner.stop;
};
var Tag2 = (tag, props = {}, children = []) => {
  if (props instanceof Node || isArr(props) || !isObj(props)) {
    children = props;
    props = {};
  }
  const isSVG = /^(svg|path|circle|rect|line|polyline|polygon|g|defs|text|tspan|use)$/.test(tag);
  const element = isSVG ? doc.createElementNS("http://www.w3.org/2000/svg", tag) : createEl(tag);
  element._cleanups = new Set;
  element.onUnmount = (fn) => element._cleanups.add(fn);
  const booleanAttributes = ["disabled", "checked", "required", "readonly", "selected", "multiple", "autofocus"];
  const updateAttribute = (name, value) => {
    const sanitized = (name === "src" || name === "href") && String(value).toLowerCase().includes("javascript:") ? "#" : value;
    if (booleanAttributes.includes(name)) {
      element[name] = !!sanitized;
      sanitized ? element.setAttribute(name, "") : element.removeAttribute(name);
    } else {
      sanitized == null ? element.removeAttribute(name) : element.setAttribute(name, sanitized);
    }
  };
  for (let [key, value] of Object.entries(props)) {
    if (key === "ref") {
      isFunc(value) ? value(element) : value.current = element;
      continue;
    }
    const isSignal = isFunc(value);
    if (key.startsWith("on")) {
      const eventName = key.slice(2).toLowerCase().split(".")[0];
      element.addEventListener(eventName, value);
      element._cleanups.add(() => element.removeEventListener(eventName, value));
    } else if (isSignal) {
      element._cleanups.add(Watch2(() => {
        const currentVal = value();
        key === "class" ? element.className = currentVal || "" : updateAttribute(key, currentVal);
      }));
      if (["INPUT", "TEXTAREA", "SELECT"].includes(element.tagName) && (key === "value" || key === "checked")) {
        const event = key === "checked" ? "change" : "input";
        const handler = (e) => value(e.target[key]);
        element.addEventListener(event, handler);
        element._cleanups.add(() => element.removeEventListener(event, handler));
      }
    } else {
      updateAttribute(key, value);
    }
  }
  const appendChildNode = (child) => {
    if (isArr(child))
      return child.forEach(appendChildNode);
    if (isFunc(child)) {
      const marker = createText("");
      element.appendChild(marker);
      let currentNodes = [];
      element._cleanups.add(Watch2(() => {
        const result = child();
        const nextNodes = (isArr(result) ? result : [result]).map((node) => node?._isRuntime ? node.container : node instanceof Node ? node : createText(node));
        currentNodes.forEach((node) => {
          cleanupNode(node);
          node.remove();
        });
        nextNodes.forEach((node) => marker.parentNode?.insertBefore(node, marker));
        currentNodes = nextNodes;
      }));
    } else {
      element.appendChild(child instanceof Node ? child : createText(child));
    }
  };
  appendChildNode(children);
  return element;
};
var If = (condition, thenVal, otherwiseVal = null, transition = null) => {
  const marker = createText("");
  const container = Tag2("div", { style: "display:contents" }, [marker]);
  let currentView = null, lastState = null;
  Watch2(() => {
    const state = !!(isFunc(condition) ? condition() : condition);
    if (state === lastState)
      return;
    lastState = state;
    const dispose = () => {
      if (currentView)
        currentView.destroy();
      currentView = null;
    };
    if (currentView && !state && transition?.out) {
      transition.out(currentView.container, dispose);
    } else {
      dispose();
    }
    const branch = state ? thenVal : otherwiseVal;
    if (branch) {
      currentView = Render(() => isFunc(branch) ? branch() : branch);
      container.insertBefore(currentView.container, marker);
      if (state && transition?.in)
        transition.in(currentView.container);
    }
  });
  return container;
};
var For = (source, renderFn, keyFn, tag = "div", props = { style: "display:contents" }) => {
  const marker = createText("");
  const container = Tag2(tag, props, [marker]);
  let viewCache = new Map;
  Watch2(() => {
    const items = (isFunc(source) ? source() : source) || [];
    const nextCache = new Map;
    const order = [];
    for (let i = 0;i < items.length; i++) {
      const item = items[i];
      const key = keyFn ? keyFn(item, i) : i;
      let view = viewCache.get(key) || Render(() => renderFn(item, i));
      viewCache.delete(key);
      nextCache.set(key, view);
      order.push(key);
    }
    viewCache.forEach((view) => {
      view.destroy();
      view.container.remove();
    });
    let anchor = marker;
    for (let i = order.length - 1;i >= 0; i--) {
      const view = nextCache.get(order[i]);
      if (view.container.nextSibling !== anchor) {
        container.insertBefore(view.container, anchor);
      }
      anchor = view.container;
    }
    viewCache = nextCache;
  });
  return container;
};
var Router = (routes) => {
  const currentPath = $(window.location.hash.replace(/^#/, "") || "/");
  window.addEventListener("hashchange", () => currentPath(window.location.hash.replace(/^#/, "") || "/"));
  const outlet = Tag2("div", { class: "router-outlet" });
  let currentView = null;
  Watch2([currentPath], async () => {
    const path = currentPath();
    const route = routes.find((r) => {
      const routeParts = r.path.split("/").filter(Boolean);
      const pathParts = path.split("/").filter(Boolean);
      return routeParts.length === pathParts.length && routeParts.every((part, i) => part.startsWith(":") || part === pathParts[i]);
    }) || routes.find((r) => r.path === "*");
    if (route) {
      let component = route.component;
      if (isFunc(component) && component.toString().includes("import")) {
        component = (await component()).default || await component();
      }
      const params = {};
      route.path.split("/").filter(Boolean).forEach((part, i) => {
        if (part.startsWith(":"))
          params[part.slice(1)] = path.split("/").filter(Boolean)[i];
      });
      if (currentView)
        currentView.destroy();
      if (Router.params)
        Router.params(params);
      currentView = Render(() => {
        try {
          return isFunc(component) ? component(params) : component;
        } catch (e) {
          return Tag2("div", { class: "p-4 text-error" }, "Error loading view");
        }
      });
      outlet.appendChild(currentView.container);
    }
  });
  return outlet;
};
Router.params = $({});
Router.to = (path) => window.location.hash = path.replace(/^#?\/?/, "#/");
Router.back = () => window.history.back();
Router.path = () => window.location.hash.replace(/^#/, "") || "/";
var Mount = (component, target) => {
  const targetEl = typeof target === "string" ? doc.querySelector(target) : target;
  if (!targetEl)
    return;
  if (MOUNTED_NODES.has(targetEl))
    MOUNTED_NODES.get(targetEl).destroy();
  const instance = Render(isFunc(component) ? component : () => component);
  targetEl.replaceChildren(instance.container);
  MOUNTED_NODES.set(targetEl, instance);
  return instance;
};
var Fragment = ({ children }) => children;
var SigPro = { $, $$, Render, Watch: Watch2, Tag: Tag2, If, For, Router, Mount, Fragment };
if (typeof window !== "undefined") {
  assign(window, SigPro);
  const tags = `div span p h1 h2 h3 h4 h5 h6 br hr section article aside nav main header footer address ul ol li dl dt dd a em strong small i b u mark time sub sup pre code blockquote details summary dialog form label input textarea select button option fieldset legend table thead tbody tfoot tr th td caption img video audio canvas svg iframe picture source progress meter`.split(" ");
  tags.forEach((tag) => {
    const helper = tag[0].toUpperCase() + tag.slice(1);
    if (!(helper in window))
      window[helper] = (p, c) => Tag2(tag, p, c);
  });
  window.SigPro = Object.freeze(SigPro);
}

// src/components/index.js
var exports_components = {};
__export(exports_components, {
  default: () => components_default,
  Tooltip: () => Tooltip,
  Toast: () => Toast,
  Timeline: () => Timeline,
  Tabs: () => Tabs,
  Table: () => Table,
  Swap: () => Swap,
  Stat: () => Stat,
  Stack: () => Stack,
  Select: () => Select,
  Rating: () => Rating,
  Range: () => Range,
  Radio: () => Radio,
  Navbar: () => Navbar,
  Modal: () => Modal,
  Menu: () => Menu,
  List: () => List,
  Label: () => Label,
  Input: () => Input,
  Indicator: () => Indicator,
  Fileinput: () => Fileinput,
  Fieldset: () => Fieldset,
  Fab: () => Fab,
  Dropdown: () => Dropdown,
  Drawer: () => Drawer,
  Datepicker: () => Datepicker,
  Colorpicker: () => Colorpicker,
  Checkbox: () => Checkbox,
  Button: () => Button,
  Badge: () => Badge,
  Autocomplete: () => Autocomplete,
  Alert: () => Alert,
  Accordion: () => Accordion
});

// src/components/Accordion.js
var exports_Accordion = {};
__export(exports_Accordion, {
  Accordion: () => Accordion
});

// src/core/utils.js
var exports_utils = {};
__export(exports_utils, {
  val: () => val,
  ui: () => ui,
  getIcon: () => getIcon
});
var val = (t) => typeof t === "function" ? t() : t;
var ui = (baseClass, additionalClassOrFn) => typeof additionalClassOrFn === "function" ? () => `${baseClass} ${additionalClassOrFn() || ""}`.trim() : `${baseClass} ${additionalClassOrFn || ""}`.trim();
var getIcon = (icon) => {
  if (!icon)
    return null;
  if (typeof icon === "function") {
    return Tag2("span", { class: "mr-1" }, icon());
  }
  if (typeof icon === "object") {
    return Tag2("span", { class: "mr-1" }, icon);
  }
  if (typeof icon === "string") {
    const parts = icon.trim().split(/\s+/);
    const hasRight = parts[parts.length - 1] === "right";
    const iconClass = hasRight ? parts.slice(0, -1).join(" ") : icon;
    const spacing = hasRight ? "ml-1" : "mr-1";
    if (iconClass && !iconClass.startsWith("icon-[") && !iconClass.includes("--")) {
      return Tag2("span", { class: spacing }, iconClass);
    }
    return Tag2("span", { class: `${iconClass} ${spacing}`.trim() });
  }
  return null;
};

// src/components/Accordion.js
var Accordion = (props, children) => {
  const { class: className, title, name, open, ...rest } = props;
  return Tag2("div", {
    ...rest,
    class: ui("collapse collapse-arrow bg-base-200 mb-2", className)
  }, [
    Tag2("input", {
      type: name ? "radio" : "checkbox",
      name,
      checked: val(open)
    }),
    Tag2("div", { class: "collapse-title text-xl font-medium" }, title),
    Tag2("div", { class: "collapse-content" }, children)
  ]);
};

// src/components/Alert.js
var exports_Alert = {};
__export(exports_Alert, {
  Alert: () => Alert
});
var Alert = (props, children) => {
  const { class: className, actions, type = "info", soft = true, ...rest } = props;
  const iconMap = {
    info: "icon-[lucide--info]",
    success: "icon-[lucide--check-circle]",
    warning: "icon-[lucide--alert-triangle]",
    error: "icon-[lucide--alert-circle]"
  };
  const typeClass = `alert-${type}`;
  const softClass = soft ? "alert-soft" : "";
  const allClasses = [typeClass, softClass, className].filter(Boolean).join(" ");
  const content = children || props.message;
  return Tag2("div", {
    ...rest,
    role: "alert",
    class: ui("alert", allClasses)
  }, () => [
    getIcon(iconMap[type]),
    Tag2("div", { class: "flex-1" }, [
      Tag2("span", {}, [typeof content === "function" ? content() : content])
    ]),
    actions ? Tag2("div", { class: "flex-none" }, [
      typeof actions === "function" ? actions() : actions
    ]) : null
  ].filter(Boolean));
};

// src/components/Autocomplete.js
var exports_Autocomplete = {};
__export(exports_Autocomplete, {
  Autocomplete: () => Autocomplete
});

// src/core/i18n.js
var i18n = {
  es: {
    close: "Cerrar",
    confirm: "Confirmar",
    cancel: "Cancelar",
    search: "Buscar...",
    loading: "Cargando...",
    nodata: "Sin datos"
  },
  en: {
    close: "Close",
    confirm: "Confirm",
    cancel: "Cancel",
    search: "Search...",
    loading: "Loading...",
    nodata: "No data"
  }
};
var currentLocale = $("es");
var tt = (t) => () => i18n[currentLocale()][t] || t;

// src/components/Input.js
var exports_Input = {};
__export(exports_Input, {
  Input: () => Input
});
var Input = (props) => {
  const {
    class: className,
    value,
    type = "text",
    icon,
    oninput,
    placeholder,
    disabled,
    size,
    validate,
    ...rest
  } = props;
  const isPassword = type === "password";
  const visible = $(false);
  const errorMsg = $(null);
  const iconMap = {
    text: "icon-[lucide--text]",
    password: "icon-[lucide--lock]",
    date: "icon-[lucide--calendar]",
    number: "icon-[lucide--hash]",
    email: "icon-[lucide--mail]",
    search: "icon-[lucide--search]",
    tel: "icon-[lucide--phone]",
    url: "icon-[lucide--link]"
  };
  const leftIcon = icon ? getIcon(icon) : iconMap[type] ? getIcon(iconMap[type]) : null;
  const getPasswordIcon = () => getIcon(visible() ? "icon-[lucide--eye-off]" : "icon-[lucide--eye]");
  const paddingLeft = leftIcon ? "pl-10" : "";
  const paddingRight = isPassword ? "pr-10" : "";
  const buttonSize = () => {
    if (className?.includes("input-xs"))
      return "btn-xs";
    if (className?.includes("input-sm"))
      return "btn-sm";
    if (className?.includes("input-lg"))
      return "btn-lg";
    return "btn-md";
  };
  const handleInput = (e) => {
    const newValue = e.target.value;
    if (validate) {
      const result = validate(newValue);
      errorMsg(result || null);
    }
    oninput?.(e);
  };
  const hasError = () => errorMsg() && errorMsg() !== "";
  const inputClasses = () => {
    let classes = `input w-full ${paddingLeft} ${paddingRight}`;
    if (className)
      classes += ` ${className}`;
    if (hasError())
      classes += " input-error";
    return classes.trim();
  };
  const inputElement = Tag2("input", {
    ...rest,
    type: () => isPassword ? visible() ? "text" : "password" : type,
    placeholder: placeholder || " ",
    class: inputClasses,
    value,
    oninput: handleInput,
    disabled: () => val(disabled),
    "aria-invalid": () => hasError() ? "true" : "false"
  });
  return Tag2("div", { class: "relative w-full" }, () => [
    inputElement,
    leftIcon ? Tag2("div", {
      class: "absolute left-3 inset-y-0 flex items-center pointer-events-none text-base-content/60"
    }, leftIcon) : null,
    isPassword ? Tag2("button", {
      type: "button",
      class: ui("absolute right-3 inset-y-0 flex items-center", "btn btn-ghost btn-circle opacity-50 hover:opacity-100", buttonSize()),
      onclick: (e) => {
        e.preventDefault();
        visible(!visible());
      }
    }, () => getPasswordIcon()) : null,
    Tag2("div", {
      class: "text-error text-xs mt-1 px-3 absolute -bottom-5 left-0"
    }, () => hasError() ? errorMsg() : null)
  ]);
};

// src/components/Autocomplete.js
var Autocomplete = (props) => {
  const { class: className, items = [], value, onSelect, label, placeholder, ...rest } = props;
  const query = $(val(value) || "");
  const isOpen = $(false);
  const cursor = $(-1);
  const list = $(() => {
    const q = query().toLowerCase();
    const data = val(items) || [];
    return q ? data.filter((o) => (typeof o === "string" ? o : o.label).toLowerCase().includes(q)) : data;
  });
  const pick = (opt) => {
    const valStr = typeof opt === "string" ? opt : opt.value;
    const labelStr = typeof opt === "string" ? opt : opt.label;
    query(labelStr);
    if (typeof value === "function")
      value(valStr);
    onSelect?.(opt);
    isOpen(false);
    cursor(-1);
  };
  const nav = (e) => {
    const items2 = list();
    if (e.key === "ArrowDown") {
      e.preventDefault();
      isOpen(true);
      cursor(Math.min(cursor() + 1, items2.length - 1));
    } else if (e.key === "ArrowUp") {
      e.preventDefault();
      cursor(Math.max(cursor() - 1, 0));
    } else if (e.key === "Enter" && cursor() >= 0) {
      e.preventDefault();
      pick(items2[cursor()]);
    } else if (e.key === "Escape") {
      isOpen(false);
    }
  };
  return Tag2("div", { class: "relative w-full" }, [
    Input({
      label,
      class: className,
      placeholder: placeholder || tt("search")(),
      value: query,
      onfocus: () => isOpen(true),
      onblur: () => setTimeout(() => isOpen(false), 150),
      onkeydown: nav,
      oninput: (e) => {
        const v = e.target.value;
        query(v);
        if (typeof value === "function")
          value(v);
        isOpen(true);
        cursor(-1);
      },
      ...rest
    }),
    Tag2("ul", {
      class: "absolute left-0 w-full menu bg-base-100 rounded-box mt-1 p-2 shadow-xl max-h-60 overflow-y-auto border border-base-300 z-50",
      style: () => isOpen() && list().length ? "display:block" : "display:none"
    }, [
      For(list, (opt, i) => Tag2("li", {}, [
        Tag2("a", {
          class: () => `block w-full ${cursor() === i ? "active bg-primary text-primary-content" : ""}`,
          onclick: () => pick(opt),
          onmouseenter: () => cursor(i)
        }, typeof opt === "string" ? opt : opt.label)
      ]), (opt, i) => (typeof opt === "string" ? opt : opt.value) + i),
      () => list().length ? null : Tag2("li", { class: "p-2 text-center opacity-50" }, tt("nodata")())
    ])
  ]);
};

// src/components/Badge.js
var exports_Badge = {};
__export(exports_Badge, {
  Badge: () => Badge
});
var Badge = (props, children) => {
  const { class: className, ...rest } = props;
  return Tag2("span", {
    ...rest,
    class: ui("badge", className)
  }, children);
};

// src/components/Button.js
var exports_Button = {};
__export(exports_Button, {
  Button: () => Button
});
var Button = (props, children) => {
  const { class: className, loading, icon, ...rest } = props;
  const iconEl = getIcon(icon);
  return Tag2("button", {
    ...rest,
    class: ui("btn", className),
    disabled: () => val(loading) || val(props.disabled)
  }, () => [
    val(loading) && Tag2("span", { class: "loading loading-spinner" }),
    iconEl,
    children
  ].filter(Boolean));
};

// src/components/Checkbox.js
var exports_Checkbox = {};
__export(exports_Checkbox, {
  Checkbox: () => Checkbox
});
var Checkbox = (props) => {
  const { class: className, value, tooltip, toggle, label, ...rest } = props;
  const checkEl = Tag2("input", {
    ...rest,
    type: "checkbox",
    class: () => ui(val(toggle) ? "toggle" : "checkbox", className),
    checked: value
  });
  const layout = Tag2("label", { class: "label cursor-pointer justify-start gap-3" }, [
    checkEl,
    label ? Tag2("span", { class: "label-text" }, label) : null
  ]);
  return tooltip ? Tag2("div", { class: "tooltip", "data-tip": tooltip }, layout) : layout;
};

// src/components/Colorpicker.js
var exports_Colorpicker = {};
__export(exports_Colorpicker, {
  Colorpicker: () => Colorpicker
});
var Colorpicker = (props) => {
  const { class: className, value, label, ...rest } = props;
  const isOpen = $(false);
  const palette = [
    ...["#000", "#1A1A1A", "#333", "#4D4D4D", "#666", "#808080", "#B3B3B3", "#FFF"],
    ...["#450a0a", "#7f1d1d", "#991b1b", "#b91c1c", "#dc2626", "#ef4444", "#f87171", "#fca5a5"],
    ...["#431407", "#7c2d12", "#9a3412", "#c2410c", "#ea580c", "#f97316", "#fb923c", "#ffedd5"],
    ...["#713f12", "#a16207", "#ca8a04", "#eab308", "#facc15", "#fde047", "#fef08a", "#fff9c4"],
    ...["#064e3b", "#065f46", "#059669", "#10b981", "#34d399", "#4ade80", "#84cc16", "#d9f99d"],
    ...["#082f49", "#075985", "#0284c7", "#0ea5e9", "#38bdf8", "#7dd3fc", "#22d3ee", "#cffafe"],
    ...["#1e1b4b", "#312e81", "#4338ca", "#4f46e5", "#6366f1", "#818cf8", "#a5b4fc", "#e0e7ff"],
    ...["#2e1065", "#4c1d95", "#6d28d9", "#7c3aed", "#8b5cf6", "#a855f7", "#d946ef", "#fae8ff"]
  ];
  const getColor = () => val(value) || "#000000";
  return Tag2("div", { class: ui("relative w-fit", className) }, [
    Tag2("button", {
      type: "button",
      class: "btn px-3 bg-base-100 border-base-300 hover:border-primary/50 flex items-center gap-2 shadow-sm font-normal normal-case",
      onclick: (e) => {
        e.stopPropagation();
        isOpen(!isOpen());
      },
      ...rest
    }, [
      Tag2("div", {
        class: "size-5 rounded-sm shadow-inner border border-black/10 shrink-0",
        style: () => `background-color: ${getColor()}`
      }),
      label ? Tag2("span", { class: "opacity-80" }, label) : null
    ]),
    If(isOpen, () => Tag2("div", {
      class: "absolute left-0 mt-2 p-3 bg-base-100 border border-base-300 shadow-2xl rounded-box z-[110] w-64 select-none",
      onclick: (e) => e.stopPropagation()
    }, [
      Tag2("div", { class: "grid grid-cols-8 gap-1" }, palette.map((c) => Tag2("button", {
        type: "button",
        style: `background-color: ${c}`,
        class: () => {
          const active = getColor().toLowerCase() === c.toLowerCase();
          return `size-6 rounded-sm cursor-pointer transition-all hover:scale-125 hover:z-10 active:scale-95 outline-none border border-black/5 
                ${active ? "ring-2 ring-offset-1 ring-primary z-10 scale-110" : ""}`;
        },
        onclick: () => {
          if (typeof value === "function")
            value(c);
          isOpen(false);
        }
      })))
    ])),
    If(isOpen, () => Tag2("div", {
      class: "fixed inset-0 z-[100]",
      onclick: () => isOpen(false)
    }))
  ]);
};

// src/components/Datepicker.js
var exports_Datepicker = {};
__export(exports_Datepicker, {
  Datepicker: () => Datepicker
});
var Datepicker = (props) => {
  const { class: className, value, range, label, placeholder, hour = false, ...rest } = props;
  const isOpen = $(false);
  const internalDate = $(new Date);
  const hoverDate = $(null);
  const startHour = $(0);
  const endHour = $(0);
  const isRangeMode = () => val(range) === true;
  const now = new Date;
  const todayStr = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
  const formatDate = (d) => {
    const year = d.getFullYear();
    const month = String(d.getMonth() + 1).padStart(2, "0");
    const day = String(d.getDate()).padStart(2, "0");
    return `${year}-${month}-${day}`;
  };
  const selectDate = (date) => {
    const dateStr = formatDate(date);
    const current = val(value);
    if (isRangeMode()) {
      if (!current?.start || current.start && current.end) {
        if (typeof value === "function") {
          value({
            start: dateStr,
            end: null,
            ...hour && { startHour: startHour() }
          });
        }
      } else {
        const start = current.start;
        if (typeof value === "function") {
          const newValue = dateStr < start ? { start: dateStr, end: start } : { start, end: dateStr };
          if (hour) {
            newValue.startHour = current.startHour || startHour();
            newValue.endHour = current.endHour || endHour();
          }
          value(newValue);
        }
        isOpen(false);
      }
    } else {
      if (typeof value === "function") {
        value(hour ? `${dateStr}T${String(startHour()).padStart(2, "0")}:00:00` : dateStr);
      }
      isOpen(false);
    }
  };
  const displayValue = $(() => {
    const v = val(value);
    if (!v)
      return "";
    if (typeof v === "string") {
      if (hour && v.includes("T"))
        return v.replace("T", " ");
      return v;
    }
    if (v.start && v.end) {
      const startStr = hour && v.startHour ? `${v.start} ${String(v.startHour).padStart(2, "0")}:00` : v.start;
      const endStr = hour && v.endHour ? `${v.end} ${String(v.endHour).padStart(2, "0")}:00` : v.end;
      return `${startStr} - ${endStr}`;
    }
    if (v.start) {
      const startStr = hour && v.startHour ? `${v.start} ${String(v.startHour).padStart(2, "0")}:00` : v.start;
      return `${startStr}...`;
    }
    return "";
  });
  const move = (m) => {
    const d = internalDate();
    internalDate(new Date(d.getFullYear(), d.getMonth() + m, 1));
  };
  const moveYear = (y) => {
    const d = internalDate();
    internalDate(new Date(d.getFullYear() + y, d.getMonth(), 1));
  };
  const HourSlider = ({ value: hVal, onChange }) => {
    return Tag2("div", { class: "flex-1" }, [
      Tag2("div", { class: "flex gap-2 items-center" }, [
        Tag2("input", {
          type: "range",
          min: 0,
          max: 23,
          value: hVal,
          class: "range range-xs flex-1",
          oninput: (e) => {
            const newHour = parseInt(e.target.value);
            onChange(newHour);
          }
        }),
        Tag2("span", { class: "text-sm font-mono min-w-[48px] text-center" }, () => String(val(hVal)).padStart(2, "0") + ":00")
      ])
    ]);
  };
  return Tag2("div", { class: ui("relative w-full", className) }, [
    Input({
      label,
      placeholder: placeholder || (isRangeMode() ? "Seleccionar rango..." : "Seleccionar fecha..."),
      value: displayValue,
      readonly: true,
      icon: getIcon("icon-[lucide--calendar]"),
      onclick: (e) => {
        e.stopPropagation();
        isOpen(!isOpen());
      },
      ...rest
    }),
    If(isOpen, () => Tag2("div", {
      class: "absolute left-0 mt-2 p-4 bg-base-100 border border-base-300 shadow-2xl rounded-box z-[100] w-80 select-none",
      onclick: (e) => e.stopPropagation()
    }, [
      Tag2("div", { class: "flex justify-between items-center mb-4 gap-1" }, [
        Tag2("div", { class: "flex gap-0.5" }, [
          Tag2("button", { type: "button", class: "btn btn-ghost btn-xs px-1", onclick: () => moveYear(-1) }, getIcon("icon-[lucide--chevrons-left]")),
          Tag2("button", { type: "button", class: "btn btn-ghost btn-xs px-1", onclick: () => move(-1) }, getIcon("icon-[lucide--chevron-left]"))
        ]),
        Tag2("span", { class: "font-bold uppercase flex-1 text-center" }, [
          () => internalDate().toLocaleString("es-ES", { month: "short", year: "numeric" })
        ]),
        Tag2("div", { class: "flex gap-0.5" }, [
          Tag2("button", { type: "button", class: "btn btn-ghost btn-xs px-1", onclick: () => move(1) }, getIcon("icon-[lucide--chevron-right]")),
          Tag2("button", { type: "button", class: "btn btn-ghost btn-xs px-1", onclick: () => moveYear(1) }, getIcon("icon-[lucide--chevrons-right]"))
        ])
      ]),
      Tag2("div", { class: "grid grid-cols-7 gap-1", onmouseleave: () => hoverDate(null) }, [
        ...["L", "M", "X", "J", "V", "S", "D"].map((d) => Tag2("div", { class: "text-[10px] opacity-40 font-bold text-center" }, d)),
        () => {
          const d = internalDate();
          const year = d.getFullYear();
          const month = d.getMonth();
          const firstDay = new Date(year, month, 1).getDay();
          const offset = firstDay === 0 ? 6 : firstDay - 1;
          const daysInMonth = new Date(year, month + 1, 0).getDate();
          const nodes = [];
          for (let i = 0;i < offset; i++)
            nodes.push(Tag2("div"));
          for (let i = 1;i <= daysInMonth; i++) {
            const date = new Date(year, month, i);
            const dStr = formatDate(date);
            nodes.push(Tag2("button", {
              type: "button",
              class: () => {
                const v = val(value);
                const h = hoverDate();
                const isStart = typeof v === "string" ? v.split("T")[0] === dStr : v?.start === dStr;
                const isEnd = v?.end === dStr;
                let inRange = false;
                if (isRangeMode() && v?.start) {
                  const start = v.start;
                  if (!v.end && h) {
                    inRange = dStr > start && dStr <= h || dStr < start && dStr >= h;
                  } else if (v.end) {
                    inRange = dStr > start && dStr < v.end;
                  }
                }
                const base = "btn btn-xs p-0 aspect-square min-h-0 h-auto font-normal relative";
                const state = isStart || isEnd ? "btn-primary z-10" : inRange ? "bg-primary/20 border-none rounded-none" : "btn-ghost";
                const today = dStr === todayStr ? "ring-1 ring-primary ring-inset font-black text-primary" : "";
                return `${base} ${state} ${today}`;
              },
              onmouseenter: () => {
                if (isRangeMode())
                  hoverDate(dStr);
              },
              onclick: () => selectDate(date)
            }, [i.toString()]));
          }
          return nodes;
        }
      ]),
      hour ? Tag2("div", { class: "mt-3 pt-2 border-t border-base-300" }, [
        isRangeMode() ? Tag2("div", { class: "flex gap-4" }, [
          HourSlider({
            value: startHour,
            onChange: (newHour) => {
              startHour(newHour);
              const currentVal = val(value);
              if (currentVal?.start)
                value({ ...currentVal, startHour: newHour });
            }
          }),
          HourSlider({
            value: endHour,
            onChange: (newHour) => {
              endHour(newHour);
              const currentVal = val(value);
              if (currentVal?.end)
                value({ ...currentVal, endHour: newHour });
            }
          })
        ]) : HourSlider({
          value: startHour,
          onChange: (newHour) => {
            startHour(newHour);
            const currentVal = val(value);
            if (currentVal && typeof currentVal === "string" && currentVal.includes("-")) {
              value(currentVal.split("T")[0] + "T" + String(newHour).padStart(2, "0") + ":00:00");
            }
          }
        })
      ]) : null
    ])),
    If(isOpen, () => Tag2("div", { class: "fixed inset-0 z-[90]", onclick: () => isOpen(false) }))
  ]);
};

// src/components/Drawer.js
var exports_Drawer = {};
__export(exports_Drawer, {
  Drawer: () => Drawer
});
var Drawer = (props, children) => {
  const { class: className, id, open, side, content, ...rest } = props;
  const drawerId = id || `drawer-${Math.random().toString(36).slice(2, 9)}`;
  return Tag2("div", {
    ...rest,
    class: ui("drawer", className)
  }, [
    Tag2("input", {
      id: drawerId,
      type: "checkbox",
      class: "drawer-toggle",
      checked: () => typeof open === "function" ? open() : open,
      onchange: (e) => {
        if (typeof open === "function")
          open(e.target.checked);
      }
    }),
    Tag2("div", { class: "drawer-content" }, [
      typeof content === "function" ? content() : content
    ]),
    Tag2("div", { class: "drawer-side" }, [
      Tag2("label", {
        for: drawerId,
        class: "drawer-overlay",
        onclick: () => {
          if (typeof open === "function")
            open(false);
        }
      }),
      Tag2("div", { class: "min-h-full bg-base-200 w-80" }, [
        typeof side === "function" ? side() : side
      ])
    ])
  ]);
};

// src/components/Dropdown.js
var exports_Dropdown = {};
__export(exports_Dropdown, {
  Dropdown: () => Dropdown
});
var currentOpen = null;
if (typeof window !== "undefined" && !window.__dropdownHandlerRegistered) {
  window.addEventListener("click", (e) => {
    if (currentOpen && !currentOpen.contains(e.target)) {
      currentOpen.open = false;
      currentOpen = null;
    }
  });
  window.__dropdownHandlerRegistered = true;
}
var Dropdown = (props) => {
  const { class: className, label, icon, items, ...rest } = props;
  return Tag("details", {
    ...rest,
    class: ui("dropdown", className)
  }, [
    Tag("summary", {
      class: "btn m-1 flex items-center gap-2 list-none cursor-pointer",
      style: "display: inline-flex;",
      onclick: (e) => {
        const details = e.currentTarget.closest("details");
        if (currentOpen && currentOpen !== details) {
          currentOpen.open = false;
        }
        setTimeout(() => {
          currentOpen = details.open ? details : null;
        }, 0);
      }
    }, [
      () => icon ? typeof icon === "function" ? icon() : icon : null,
      () => label ? typeof label === "function" ? label() : label : null
    ]),
    Tag("ul", {
      tabindex: "-1",
      class: "dropdown-content z-[50] menu p-2 shadow bg-base-100 rounded-box w-52 border border-base-300"
    }, [
      () => {
        const currentItems = typeof items === "function" ? items() : items || [];
        return currentItems.map((item) => Tag("li", {}, [
          Tag("a", {
            class: item.class || "",
            onclick: (e) => {
              if (item.onclick)
                item.onclick(e);
              const details = e.currentTarget.closest("details");
              if (details) {
                details.open = false;
                if (currentOpen === details)
                  currentOpen = null;
              }
            }
          }, [
            item.icon ? Tag("span", {}, item.icon) : null,
            Tag("span", {}, item.label)
          ])
        ]));
      }
    ])
  ]);
};

// src/components/Fab.js
var exports_Fab = {};
__export(exports_Fab, {
  Fab: () => Fab
});
var Fab = (props) => {
  const { class: className, icon, label, actions = [], position = "bottom-6 right-6", ...rest } = props;
  return Tag2("div", {
    ...rest,
    class: ui(`fab absolute ${position} flex flex-col-reverse items-end gap-3 z-[100]`, className)
  }, [
    Tag2("div", {
      tabindex: 0,
      role: "button",
      class: "btn btn-lg btn-circle btn-primary shadow-2xl"
    }, [
      icon ? getIcon(icon) : null,
      !icon && label ? label : null
    ]),
    ...val(actions).map((act) => Tag2("div", { class: "flex items-center gap-3 transition-all duration-300" }, [
      act.label ? Tag2("span", { class: "badge badge-ghost shadow-sm whitespace-nowrap" }, act.label) : null,
      Tag2("button", {
        type: "button",
        class: `btn btn-circle shadow-lg ${act.class || ""}`,
        onclick: (e) => {
          e.stopPropagation();
          act.onclick?.(e);
        }
      }, [act.icon ? getIcon(act.icon) : act.text || ""])
    ]))
  ]);
};

// src/components/Fieldset.js
var exports_Fieldset = {};
__export(exports_Fieldset, {
  Fieldset: () => Fieldset
});
var Fieldset = (props, children) => {
  const { class: className, legend, ...rest } = props;
  return Tag2("fieldset", {
    ...rest,
    class: ui("fieldset bg-base-200 border border-base-300 p-4 rounded-lg", className)
  }, [
    () => {
      const legendText = val(legend);
      return legendText ? Tag2("legend", { class: "fieldset-legend font-bold" }, [legendText]) : null;
    },
    children
  ]);
};

// src/components/Fileinput.js
var exports_Fileinput = {};
__export(exports_Fileinput, {
  Fileinput: () => Fileinput
});
var Fileinput = (props) => {
  const { class: className, tooltip, max = 2, accept = "*", onSelect, ...rest } = props;
  const selectedFiles = $([]);
  const isDragging = $(false);
  const error = $(null);
  const MAX_BYTES = max * 1024 * 1024;
  const handleFiles = (files) => {
    const fileList = Array.from(files);
    error(null);
    const oversized = fileList.find((f) => f.size > MAX_BYTES);
    if (oversized) {
      error(`Máx ${max}MB`);
      return;
    }
    selectedFiles([...selectedFiles(), ...fileList]);
    onSelect?.(selectedFiles());
  };
  const removeFile = (index) => {
    const updated = selectedFiles().filter((_, i) => i !== index);
    selectedFiles(updated);
    onSelect?.(updated);
  };
  return Tag2("fieldset", { ...rest, class: ui("fieldset w-full p-0", className) }, [
    Tag2("div", {
      class: () => `w-full ${tooltip ? "tooltip tooltip-top before:z-50 after:z-50" : ""}`,
      "data-tip": tooltip
    }, [
      Tag2("label", {
        class: () => `
          relative flex items-center justify-between w-full h-12 px-4
          border-2 border-dashed rounded-lg cursor-pointer
          transition-all duration-200
          ${isDragging() ? "border-primary bg-primary/10" : "border-base-content/20 bg-base-100 hover:bg-base-200"}
        `,
        ondragover: (e) => {
          e.preventDefault();
          isDragging(true);
        },
        ondragleave: () => isDragging(false),
        ondrop: (e) => {
          e.preventDefault();
          isDragging(false);
          handleFiles(e.dataTransfer.files);
        }
      }, [
        Tag2("div", { class: "flex items-center gap-3 w-full" }, [
          getIcon("icon-[lucide--upload]"),
          Tag2("span", { class: "text-sm opacity-70 truncate grow text-left" }, "Arrastra o selecciona archivos..."),
          Tag2("span", { class: "text-[10px] opacity-40 shrink-0" }, `Máx ${max}MB`)
        ]),
        Tag2("input", {
          type: "file",
          multiple: true,
          accept,
          class: "hidden",
          onchange: (e) => handleFiles(e.target.files)
        })
      ])
    ]),
    () => error() ? Tag2("span", { class: "text-[10px] text-error mt-1 px-1 font-medium" }, error()) : null,
    If(() => selectedFiles().length > 0, () => Tag2("ul", { class: "mt-2 space-y-1" }, [
      For(selectedFiles, (file, index) => Tag2("li", { class: "flex items-center justify-between p-1.5 pl-3 text-xs bg-base-200/50 rounded-md border border-base-300" }, [
        Tag2("div", { class: "flex items-center gap-2 truncate" }, [
          Tag2("span", { class: "opacity-50" }, "\uD83D\uDCC4"),
          Tag2("span", { class: "truncate font-medium max-w-[200px]" }, file.name),
          Tag2("span", { class: "text-[9px] opacity-40" }, `(${(file.size / 1024).toFixed(0)} KB)`)
        ]),
        Tag2("button", {
          type: "button",
          class: "btn btn-ghost btn-xs btn-circle",
          onclick: (e) => {
            e.preventDefault();
            e.stopPropagation();
            removeFile(index);
          }
        }, [getIcon("icon-[lucide--x]")])
      ]), (file) => file.name + file.lastModified)
    ]))
  ]);
};

// src/components/Indicator.js
var exports_Indicator = {};
__export(exports_Indicator, {
  Indicator: () => Indicator
});
var Indicator = (props, children) => {
  const { value, class: className, ...rest } = props;
  return Tag2("div", {
    ...rest,
    class: "indicator"
  }, () => [
    value ? Tag2("span", {
      class: ui("indicator-item badge", className)
    }, () => typeof value === "function" ? value() : value) : null,
    children
  ].filter(Boolean));
};

// src/components/Label.js
var exports_Label = {};
__export(exports_Label, {
  Label: () => Label
});
var Label = (props) => {
  const { children, value, floating = false, error, required, class: className, ...rest } = props;
  if (floating) {
    return Tag2("label", { class: ui("floating-label w-full", className), ...rest }, () => [
      value ? Tag2("span", {}, value) : null,
      children,
      error ? Tag2("span", { class: "text-error text-xs" }, val(error)) : null
    ]);
  }
  return Tag2("label", { class: ui("input w-full", className), ...rest }, () => [
    value ? Tag2("span", { class: "label" }, value) : null,
    children,
    error ? Tag2("span", { class: "text-error text-xs" }, val(error)) : null
  ]);
};

// src/components/List.js
var exports_List = {};
__export(exports_List, {
  List: () => List
});
var List = (props) => {
  const { class: className, items, header, render, keyFn = (item, index) => item.id ?? index, ...rest } = props;
  const listItems = For(items, (item, index) => Tag2("li", { class: "list-row" }, [render(item, index)]), keyFn);
  return Tag2("ul", {
    ...rest,
    class: ui("list bg-base-100 rounded-box shadow-md", className)
  }, header ? [If(header, () => Tag2("li", { class: "p-4 pb-2 text-xs opacity-60" }, [val(header)])), listItems] : listItems);
};

// src/components/Menu.js
var exports_Menu = {};
__export(exports_Menu, {
  Menu: () => Menu
});
var Menu = (props) => {
  const { class: className, items, ...rest } = props;
  const renderItems = (items2) => For(() => items2 || [], (it) => Tag2("li", {}, [
    it.children ? Tag2("details", { open: it.open }, [
      Tag2("summary", {}, [it.icon && Tag2("span", { class: "mr-2" }, it.icon), it.label]),
      Tag2("ul", {}, renderItems(it.children))
    ]) : Tag2("a", { class: () => val(it.active) ? "active" : "", onclick: it.onclick }, [
      it.icon && Tag2("span", { class: "mr-2" }, it.icon),
      it.label
    ])
  ]), (it, i) => it.label || i);
  return Tag2("ul", { ...rest, class: ui("menu bg-base-200 rounded-box", className) }, renderItems(items));
};

// src/components/Modal.js
var exports_Modal = {};
__export(exports_Modal, {
  Modal: () => Modal
});
var Modal = (props, children) => {
  const { class: className, title, buttons, open, ...rest } = props;
  let dialogElement = null;
  const handleOpen = () => {
    const isOpen = typeof open === "function" ? open() : open;
    if (!dialogElement)
      return;
    if (isOpen) {
      if (!dialogElement.open)
        dialogElement.showModal();
    } else {
      if (dialogElement.open)
        dialogElement.close();
    }
  };
  Watch2(() => handleOpen());
  const close = () => {
    if (typeof open === "function")
      open(false);
  };
  return Tag2("dialog", {
    ...rest,
    ref: (el) => {
      dialogElement = el;
      if (el)
        handleOpen();
    },
    class: ui("modal", className),
    onclose: close,
    oncancel: close
  }, [
    Tag2("div", { class: "modal-box" }, [
      title ? Tag2("h3", { class: "text-lg font-bold mb-4" }, () => typeof title === "function" ? title() : title) : null,
      Tag2("div", { class: "py-2" }, [
        typeof children === "function" ? children() : children
      ]),
      Tag2("div", { class: "modal-action" }, [
        Tag2("form", { method: "dialog", class: "flex gap-2" }, [
          ...(Array.isArray(buttons) ? buttons : [buttons]).filter(Boolean),
          Button({ type: "submit" }, tt("close")())
        ])
      ])
    ]),
    Tag2("form", { method: "dialog", class: "modal-backdrop" }, [
      Tag2("button", {}, "close")
    ])
  ]);
};

// src/components/Navbar.js
var exports_Navbar = {};
__export(exports_Navbar, {
  Navbar: () => Navbar
});
var Navbar = (props, children) => {
  const { class: className, ...rest } = props;
  return Tag2("div", { ...rest, class: ui("navbar bg-base-100 shadow-sm px-4", className) }, children);
};

// src/components/Radio.js
var exports_Radio = {};
__export(exports_Radio, {
  Radio: () => Radio
});
var Radio = (props) => {
  const { class: className, label, tooltip, value, inputValue, name, ...rest } = props;
  const radioEl = Tag2("input", {
    ...rest,
    type: "radio",
    name,
    class: ui("radio", className),
    checked: () => val(value) === inputValue,
    onclick: () => {
      if (typeof value === "function")
        value(inputValue);
    }
  });
  if (!label && !tooltip)
    return radioEl;
  const layout = Tag2("label", { class: "label cursor-pointer justify-start gap-3" }, [
    radioEl,
    label ? Tag2("span", { class: "label-text" }, label) : null
  ]);
  return tooltip ? Tag2("div", { class: "tooltip", "data-tip": tooltip }, layout) : layout;
};

// src/components/Range.js
var exports_Range = {};
__export(exports_Range, {
  Range: () => Range
});
var Range = (props) => {
  const { class: className, label, tooltip, value, ...rest } = props;
  const rangeEl = Tag2("input", {
    ...rest,
    type: "range",
    class: ui("range", className),
    value,
    disabled: () => val(props.disabled)
  });
  if (!label && !tooltip)
    return rangeEl;
  const layout = Tag2("div", { class: "flex flex-col gap-2" }, [
    label ? Tag2("span", { class: "label-text" }, label) : null,
    rangeEl
  ]);
  return tooltip ? Tag2("div", { class: "tooltip", "data-tip": tooltip }, layout) : layout;
};

// src/components/Rating.js
var exports_Rating = {};
__export(exports_Rating, {
  Rating: () => Rating
});
var Rating = (props) => {
  const { class: className, value, count = 5, mask = "mask-star", readonly = false, onchange, ...rest } = props;
  const ratingGroup = `rating-${Math.random().toString(36).slice(2, 7)}`;
  return Tag2("div", {
    ...rest,
    class: () => ui(`rating ${val(readonly) ? "pointer-events-none" : ""}`, className)
  }, Array.from({ length: val(count) }, (_, i) => {
    const starValue = i + 1;
    return Tag2("input", {
      type: "radio",
      name: ratingGroup,
      class: `mask ${mask}`,
      checked: () => Math.round(val(value)) === starValue,
      onchange: () => {
        if (!val(readonly)) {
          if (typeof onchange === "function") {
            onchange(starValue);
          } else if (typeof value === "function") {
            value(starValue);
          }
        }
      }
    });
  }));
};

// src/components/Select.js
var exports_Select = {};
__export(exports_Select, {
  Select: () => Select
});
var Select = (props) => {
  const { class: className, label, items, value, ...rest } = props;
  const selectEl = Tag2("select", {
    ...rest,
    class: ui("select select-bordered w-full", className),
    value
  }, For(() => val(items) || [], (opt) => Tag2("option", {
    value: opt.value,
    $selected: () => String(val(value)) === String(opt.value)
  }, opt.label), (opt) => opt.value));
  if (!label)
    return selectEl;
  return Tag2("label", { class: "fieldset-label flex flex-col gap-1" }, [
    Tag2("span", {}, label),
    selectEl
  ]);
};

// src/components/Stack.js
var exports_Stack = {};
__export(exports_Stack, {
  Stack: () => Stack
});
var Stack = (props, children) => {
  const { class: className, ...rest } = props;
  return Tag2("div", { ...rest, class: ui("stack", className) }, children);
};

// src/components/Stat.js
var exports_Stat = {};
__export(exports_Stat, {
  Stat: () => Stat
});
var Stat = (props) => {
  const { class: className, icon, label, value, desc, ...rest } = props;
  return Tag2("div", { ...rest, class: ui("stat", className) }, [
    icon && Tag2("div", { class: "stat-figure text-secondary" }, icon),
    label && Tag2("div", { class: "stat-title" }, label),
    Tag2("div", { class: "stat-value" }, () => val(value) ?? value),
    desc && Tag2("div", { class: "stat-desc" }, desc)
  ]);
};

// src/components/Swap.js
var exports_Swap = {};
__export(exports_Swap, {
  Swap: () => Swap
});
var Swap = (props) => {
  const { class: className, value, on, off, ...rest } = props;
  return Tag2("label", { ...rest, class: ui("swap", className) }, [
    Tag2("input", {
      type: "checkbox",
      checked: () => val(value),
      onclick: (e) => {
        if (typeof value === "function") {
          value(e.target.checked);
        }
      }
    }),
    Tag2("div", { class: "swap-on" }, on),
    Tag2("div", { class: "swap-off" }, off)
  ]);
};

// src/components/Table.js
var exports_Table = {};
__export(exports_Table, {
  Table: () => Table
});
var Table = (props) => {
  const { class: className, items = [], columns = [], keyFn, zebra = false, pinRows = false, empty = tt("nodata")(), ...rest } = props;
  const tableClass = () => {
    const zebraClass = val(zebra) ? "table-zebra" : "";
    const pinRowsClass = val(pinRows) ? "table-pin-rows" : "";
    return ui("table", className, zebraClass, pinRowsClass);
  };
  const getInternalKeyFn = keyFn || ((item, idx) => item.id || idx);
  return Tag2("div", { class: "overflow-x-auto w-full bg-base-100 rounded-box border border-base-300" }, [
    Tag2("table", { ...rest, class: tableClass }, [
      Tag2("thead", {}, [
        Tag2("tr", {}, columns.map((col) => Tag2("th", { class: col.class || "" }, col.label)))
      ]),
      Tag2("tbody", {}, [
        For(items, (item, index) => {
          const it = () => {
            const currentItems = val(items);
            const key = getInternalKeyFn(item, index);
            return currentItems.find((u, i) => getInternalKeyFn(u, i) === key) || item;
          };
          return Tag2("tr", { class: "hover" }, columns.map((col) => {
            const cellContent = () => {
              const latestItem = it();
              if (col.render)
                return col.render(latestItem, index);
              return val(latestItem[col.key]);
            };
            return Tag2("td", { class: col.class || "" }, [cellContent]);
          }));
        }, getInternalKeyFn),
        If(() => val(items).length === 0, () => Tag2("tr", {}, [
          Tag2("td", { colspan: columns.length, class: "text-center p-10 opacity-50" }, [
            val(empty)
          ])
        ]))
      ])
    ])
  ]);
};

// src/components/Tabs.js
var exports_Tabs = {};
__export(exports_Tabs, {
  Tabs: () => Tabs
});
var Tabs = (props) => {
  const { items, class: className, ...rest } = props;
  const itemsSignal = typeof items === "function" ? items : () => items || [];
  const activeIndex = $(0);
  Watch(() => {
    const idx = itemsSignal().findIndex((it) => val(it.active) === true);
    if (idx !== -1 && idx !== activeIndex())
      activeIndex(idx);
  });
  return Tag2("div", { ...rest, class: "w-full" }, [
    Tag2("div", {
      role: "tablist",
      class: ui("tabs", className || "tabs-box")
    }, () => {
      const list = itemsSignal();
      return list.map((it, idx) => {
        const isSelected = () => activeIndex() === idx;
        const tab = Tag2("button", {
          role: "tab",
          class: () => ui("tab", isSelected() ? "tab-active" : ""),
          onclick: (e) => {
            e.preventDefault();
            if (!val(it.disabled)) {
              if (it.onclick)
                it.onclick();
              activeIndex(idx);
            }
          }
        });
        Watch(() => {
          const content = val(it.label);
          if (content instanceof Node) {
            tab.replaceChildren(content);
          } else {
            tab.textContent = String(content);
          }
        });
        return tab;
      });
    }),
    Tag2("div", { class: "tab-panels" }, () => {
      return itemsSignal().map((it, idx) => {
        const isVisible = () => activeIndex() === idx;
        return Tag2("div", {
          role: "tabpanel",
          class: "tab-content bg-base-100 border-base-300 p-6",
          style: () => isVisible() ? "display: block" : "display: none"
        }, [
          () => typeof it.content === "function" ? it.content() : it.content
        ]);
      });
    })
  ]);
};

// src/components/Timeline.js
var exports_Timeline = {};
__export(exports_Timeline, {
  Timeline: () => Timeline
});
var Timeline = (props) => {
  const { class: className, items = [], vertical = true, compact = false, ...rest } = props;
  const iconMap = {
    info: "icon-[lucide--info]",
    success: "icon-[lucide--check-circle]",
    warning: "icon-[lucide--alert-triangle]",
    error: "icon-[lucide--alert-circle]"
  };
  return Tag2("ul", {
    ...rest,
    class: () => ui(`timeline ${val(vertical) ? "timeline-vertical" : "timeline-horizontal"} ${val(compact) ? "timeline-compact" : ""}`, className)
  }, () => {
    const list = (typeof items === "function" ? items() : items) || [];
    return list.map((item, i) => {
      const isFirst = i === 0;
      const isLast = i === list.length - 1;
      const itemType = item.type || "success";
      const isCompleted = () => val(item.completed);
      const prevCompleted = () => i > 0 && val(list[i - 1].completed);
      const renderSlot = (content) => typeof content === "function" ? content() : content;
      return Tag2("li", { class: "flex-1" }, [
        !isFirst ? Tag2("hr", { class: () => prevCompleted() ? "bg-primary" : "" }) : null,
        Tag2("div", { class: "timeline-start" }, [() => renderSlot(item.title)]),
        Tag2("div", { class: "timeline-middle" }, [
          () => item.icon ? getIcon(item.icon) : getIcon(iconMap[itemType] || iconMap.success)
        ]),
        Tag2("div", { class: "timeline-end timeline-box shadow-sm" }, [() => renderSlot(item.detail)]),
        !isLast ? Tag2("hr", { class: () => isCompleted() ? "bg-primary" : "" }) : null
      ]);
    });
  });
};

// src/components/Toast.js
var exports_Toast = {};
__export(exports_Toast, {
  Toast: () => Toast
});
var Toast = (message, type = "alert-success", duration = 3500) => {
  let container = document.getElementById("sigpro-toast-container");
  if (!container) {
    container = Tag2("div", {
      id: "sigpro-toast-container",
      class: "fixed top-0 right-0 z-[9999] p-4 flex flex-col gap-2 pointer-events-none"
    });
    document.body.appendChild(container);
  }
  const toastHost = Tag2("div", { style: "display: contents" });
  container.appendChild(toastHost);
  let timeoutId;
  const close = () => {
    clearTimeout(timeoutId);
    const el = toastHost.firstElementChild;
    if (el && !el.classList.contains("opacity-0")) {
      el.classList.add("translate-x-full", "opacity-0");
      setTimeout(() => {
        instance.destroy();
        toastHost.remove();
        if (!container.hasChildNodes())
          container.remove();
      }, 300);
    } else {
      instance.destroy();
      toastHost.remove();
    }
  };
  const ToastComponent = () => {
    const closeIcon = getIcon("icon-[lucide--x]");
    const el = Tag2("div", {
      class: `alert alert-soft ${type} shadow-lg transition-all duration-300 translate-x-10 opacity-0 pointer-events-auto`
    }, [
      Tag2("span", {}, [typeof message === "function" ? message() : message]),
      Button({
        class: "btn-xs btn-circle btn-ghost",
        onclick: close
      }, closeIcon)
    ]);
    requestAnimationFrame(() => el.classList.remove("translate-x-10", "opacity-0"));
    return el;
  };
  const instance = Mount(ToastComponent, toastHost);
  if (duration > 0) {
    timeoutId = setTimeout(close, duration);
  }
  return close;
};

// src/components/Tooltip.js
var exports_Tooltip = {};
__export(exports_Tooltip, {
  Tooltip: () => Tooltip
});
var Tooltip = (props, children) => Tag2("div", {
  ...props,
  class: () => ui("tooltip", props.class),
  "data-tip": props.tip
}, children);

// src/components/index.js
var Components = {
  ...exports_Accordion,
  ...exports_Alert,
  ...exports_Autocomplete,
  ...exports_Badge,
  ...exports_Button,
  ...exports_Checkbox,
  ...exports_Colorpicker,
  ...exports_Datepicker,
  ...exports_Drawer,
  ...exports_Dropdown,
  ...exports_Fab,
  ...exports_Fieldset,
  ...exports_Fileinput,
  ...exports_Indicator,
  ...exports_Input,
  ...exports_Label,
  ...exports_List,
  ...exports_Menu,
  ...exports_Modal,
  ...exports_Navbar,
  ...exports_Radio,
  ...exports_Range,
  ...exports_Rating,
  ...exports_Select,
  ...exports_Stack,
  ...exports_Stat,
  ...exports_Swap,
  ...exports_Table,
  ...exports_Tabs,
  ...exports_Timeline,
  ...exports_Toast,
  ...exports_Tooltip
};
var components_default = {
  ...Components,
  install: (target = window) => {
    Object.entries(Components).forEach(([name, component]) => {
      target[name] = component;
    });
    console.log("\uD83D\uDE80 SigproUI");
  }
};
// index.js
if (typeof window !== "undefined") {
  Object.entries(exports_components).forEach(([name, component]) => {
    window[name] = component;
  });
  window.Utils = exports_utils;
  window.tt = tt;
  window.SigProUI = { ...exports_components, Utils: exports_utils, tt };
  console.log("\uD83C\uDFA8 SigProUI ready");
}
export {
  val,
  ui,
  tt,
  getIcon,
  Tooltip,
  Toast,
  Timeline,
  Tabs,
  Table,
  Swap,
  Stat,
  Stack,
  Select,
  Rating,
  Range,
  Radio,
  Navbar,
  Modal,
  Menu,
  List,
  Label,
  Input,
  Indicator,
  Fileinput,
  Fieldset,
  Fab,
  Dropdown,
  Drawer,
  Datepicker,
  Colorpicker,
  Checkbox,
  Button,
  Badge,
  Autocomplete,
  Alert,
  Accordion
};