(() => {
  var __defProp = Object.defineProperty;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  function __accessProp(key) {
    return this[key];
  }
  var __toCommonJS = (from) => {
    var entry = (__moduleCache ??= new WeakMap).get(from), desc;
    if (entry)
      return entry;
    entry = __defProp({}, "__esModule", { value: true });
    if (from && typeof from === "object" || typeof from === "function") {
      for (var key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(entry, key))
          __defProp(entry, key, {
            get: __accessProp.bind(from, key),
            enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
          });
    }
    __moduleCache.set(from, entry);
    return entry;
  };
  var __moduleCache;
  var __returnValue = (v) => v;
  function __exportSetter(name, newValue) {
    this[name] = __returnValue.bind(null, newValue);
  }
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, {
        get: all[name],
        enumerable: true,
        configurable: true,
        set: __exportSetter.bind(all, name)
      });
  };

  // index.js
  var exports_sigpro = {};
  __export(exports_sigpro, {
    when: () => when,
    watch: () => watch,
    sigpro: () => sigpro,
    router: () => router,
    mount: () => mount,
    h: () => h,
    each: () => each,
    batch: () => batch,
    $$: () => $$,
    $: () => $
  });

  // sigpro.js
  var isFunc = (f) => typeof f === "function";
  var isObj = (o) => o && typeof o === "object";
  var isArr = Array.isArray;
  var doc = typeof document !== "undefined" ? document : null;
  var ensureNode = (n) => n?._isRuntime ? n.container : n instanceof Node ? n : doc.createTextNode(n == null ? "" : String(n));
  var activeEffect = null;
  var activeOwner = null;
  var isFlushing = false;
  var batchDepth = 0;
  var effectQueue = new Set;
  var proxyCache = new WeakMap;
  var ITER = Symbol("iter");
  var MOUNTED_NODES = new WeakMap;
  var SVG_NS = "http://www.w3.org/2000/svg";
  var XLINK_NS = "http://www.w3.org/1999/xlink";
  var SVG_TAGS = new Set("svg,path,circle,rect,line,polyline,polygon,g,defs,text,textPath,tspan,use,symbol,image,marker,ellipse".split(","));
  var dispose = (eff) => {
    if (!eff || eff._disposed)
      return;
    eff._disposed = true;
    const stack = [eff];
    while (stack.length) {
      const e = stack.pop();
      if (e._cleanups) {
        e._cleanups.forEach((fn) => fn());
        e._cleanups.clear();
      }
      if (e._children) {
        e._children.forEach((child) => stack.push(child));
        e._children.clear();
      }
      if (e._deps) {
        e._deps.forEach((depSet) => depSet.delete(e));
        e._deps.clear();
      }
    }
  };
  var onUnmount = (fn) => {
    if (activeOwner)
      (activeOwner._cleanups ||= new Set).add(fn);
  };
  var untrack = (fn) => {
    const p = activeEffect;
    activeEffect = null;
    try {
      return fn();
    } finally {
      activeEffect = p;
    }
  };
  var createEffect = (fn, isComputed = false) => {
    const effect = () => {
      if (effect._disposed)
        return;
      if (effect._deps)
        effect._deps.forEach((s) => s.delete(effect));
      if (effect._cleanups) {
        effect._cleanups.forEach((c) => c());
        effect._cleanups.clear();
      }
      const prevEffect = activeEffect;
      const prevOwner = activeOwner;
      activeEffect = activeOwner = effect;
      try {
        return effect._result = fn();
      } catch (e) {
        console.error("[SigPro]", e);
      } finally {
        activeEffect = prevEffect;
        activeOwner = prevOwner;
      }
    };
    effect._deps = effect._cleanups = effect._children = null;
    effect._disposed = false;
    effect._isComputed = isComputed;
    effect._depth = activeEffect ? activeEffect._depth + 1 : 0;
    effect._mounts = [];
    effect._parent = activeOwner;
    if (activeOwner)
      (activeOwner._children ||= new Set).add(effect);
    return effect;
  };
  var flush = () => {
    if (isFlushing)
      return;
    isFlushing = true;
    const sorted = Array.from(effectQueue).sort((a, b) => a._depth - b._depth);
    effectQueue.clear();
    for (const e of sorted)
      if (!e._disposed)
        e();
    isFlushing = false;
  };
  var batch = (fn) => {
    batchDepth++;
    try {
      return fn();
    } finally {
      batchDepth--;
      if (batchDepth === 0 && effectQueue.size > 0 && !isFlushing) {
        flush();
      }
    }
  };
  var trackUpdate = (subs, trigger = false) => {
    if (!trigger && activeEffect && !activeEffect._disposed) {
      subs.add(activeEffect);
      (activeEffect._deps ||= new Set).add(subs);
    } else if (trigger && subs.size > 0) {
      let hasQueue = false;
      for (const e of subs) {
        if (e === activeEffect || e._disposed)
          continue;
        if (e._isComputed) {
          e._dirty = true;
          if (e._subs)
            trackUpdate(e._subs, true);
        } else {
          effectQueue.add(e);
          hasQueue = true;
        }
      }
      if (hasQueue && !isFlushing && batchDepth === 0)
        queueMicrotask(flush);
    }
  };
  var $ = (val, key = null) => {
    const subs = new Set;
    if (isFunc(val)) {
      let cache;
      const computed = () => {
        if (computed._dirty) {
          const prev = activeEffect;
          activeEffect = computed;
          try {
            const next = val();
            if (!Object.is(cache, next)) {
              cache = next;
              trackUpdate(subs, true);
            }
          } finally {
            activeEffect = prev;
          }
          computed._dirty = false;
        }
        trackUpdate(subs);
        return cache;
      };
      computed._isComputed = true;
      computed._subs = subs;
      computed._dirty = true;
      computed._deps = null;
      computed._disposed = false;
      return computed;
    }
    if (key)
      try {
        val = JSON.parse(localStorage.getItem(key)) ?? val;
      } catch (e) {}
    return (...args) => {
      if (args.length) {
        const next = isFunc(args[0]) ? args[0](val) : args[0];
        if (!Object.is(val, next)) {
          val = next;
          if (key)
            localStorage.setItem(key, JSON.stringify(val));
          trackUpdate(subs, true);
        }
      }
      trackUpdate(subs);
      return val;
    };
  };
  var $$ = (target) => {
    if (!isObj(target))
      return target;
    const cached = proxyCache.get(target);
    if (cached)
      return cached;
    const subs = new Map;
    const getSubs = (key) => {
      let set = subs.get(key);
      if (!set)
        subs.set(key, set = new Set);
      return set;
    };
    const proxy = new Proxy(target, {
      get(target2, key, receiver) {
        if (typeof key !== "symbol")
          trackUpdate(getSubs(key));
        return $$(Reflect.get(target2, key, receiver));
      },
      set(target2, key, value, receiver) {
        const hadKey = Reflect.has(target2, key);
        const oldValue = Reflect.get(target2, key, receiver);
        const result = Reflect.set(target2, key, value, receiver);
        if (result && !Object.is(oldValue, value)) {
          trackUpdate(getSubs(key), true);
          if (!hadKey)
            trackUpdate(getSubs(ITER), true);
        }
        return result;
      },
      deleteProperty(target2, key) {
        const result = Reflect.deleteProperty(target2, key);
        if (result) {
          trackUpdate(getSubs(key), true);
          trackUpdate(getSubs(ITER), true);
        }
        return result;
      },
      ownKeys(target2) {
        trackUpdate(getSubs(ITER));
        return Reflect.ownKeys(target2);
      }
    });
    proxyCache.set(target, proxy);
    return proxy;
  };
  var watch = (sources, cb) => {
    if (cb === undefined) {
      const effect2 = createEffect(sources);
      effect2();
      return () => dispose(effect2);
    }
    const effect = createEffect(() => {
      const vals = Array.isArray(sources) ? sources.map((s) => s()) : sources();
      untrack(() => cb(vals));
    });
    effect();
    return () => dispose(effect);
  };
  var cleanupNode = (node) => {
    if (!node)
      return;
    if (node._cleanups) {
      node._cleanups.forEach((fn) => fn());
      node._cleanups.clear();
    }
    if (node._ownerEffect)
      dispose(node._ownerEffect);
    if (node.childNodes)
      node.childNodes.forEach((n) => cleanupNode(n));
  };
  var DANGEROUS_PROTOCOL = /^\s*(javascript|data|vbscript):/i;
  var DANGEROUS_URI_ATTRS = new Set(["src", "href", "formaction", "action", "background", "code", "archive"]);
  var isDangerousAttr = (key) => DANGEROUS_URI_ATTRS.has(key) || key.startsWith("on");
  var validateAttr = (key, val) => {
    if (val == null || val === false)
      return null;
    if (isDangerousAttr(key)) {
      const sVal = String(val);
      if (DANGEROUS_PROTOCOL.test(sVal)) {
        console.warn(`[SigPro] Bloqueado protocolo peligroso en ${key}`);
        return "#";
      }
    }
    return val;
  };
  var h = (tag, props = {}, children = []) => {
    if (props instanceof Node || isArr(props) || !isObj(props)) {
      children = props;
      props = {};
    }
    if (isFunc(tag)) {
      const effect = createEffect(() => {
        const result2 = tag(props, {
          children,
          emit: (ev, ...args) => props[`on${ev[0].toUpperCase()}${ev.slice(1)}`]?.(...args)
        });
        effect._result = result2;
        return result2;
      });
      effect();
      const result = effect._result;
      if (result == null)
        return null;
      const node = result instanceof Node || isArr(result) && result.every((n) => n instanceof Node) ? result : doc.createTextNode(String(result));
      const attach = (n) => {
        if (isObj(n) && !n._isRuntime) {
          n._mounts = effect._mounts || [];
          n._cleanups = effect._cleanups || new Set;
          n._ownerEffect = effect;
        }
      };
      isArr(node) ? node.forEach(attach) : attach(node);
      return node;
    }
    const isSVG = SVG_TAGS.has(tag);
    const el = isSVG ? doc.createElementNS(SVG_NS, tag) : doc.createElement(tag);
    el._cleanups = new Set;
    for (const k of Object.keys(props)) {
      let v = props[k];
      if (k === "ref") {
        isFunc(v) ? v(el) : v.current = el;
        continue;
      }
      if (isSVG && k.startsWith("xlink:")) {
        const cleanVal = validateAttr(k.slice(6), v);
        cleanVal == null ? el.removeAttributeNS(XLINK_NS, k.slice(6)) : el.setAttributeNS(XLINK_NS, k.slice(6), cleanVal);
        continue;
      }
      if (k.startsWith("on")) {
        const ev = k.slice(2).toLowerCase();
        el.addEventListener(ev, v);
        const off = () => el.removeEventListener(ev, v);
        el._cleanups.add(off);
        onUnmount(off);
      } else if (isFunc(v)) {
        const effect = createEffect(() => {
          const val = validateAttr(k, v());
          if (k === "class")
            el.className = val || "";
          else if (val == null)
            el.removeAttribute(k);
          else if (k in el && !isSVG)
            el[k] = val;
          else
            el.setAttribute(k, val === true ? "" : val);
        });
        effect();
        el._cleanups.add(() => dispose(effect));
        onUnmount(() => dispose(effect));
        if (/^(INPUT|TEXTAREA|SELECT)$/.test(el.tagName) && (k === "value" || k === "checked")) {
          const evType = k === "checked" ? "change" : "input";
          el.addEventListener(evType, (ev) => v(ev.target[k]));
        }
      } else {
        const val = validateAttr(k, v);
        if (val != null) {
          if (k in el && !isSVG)
            el[k] = val;
          else
            el.setAttribute(k, val === true ? "" : val);
        }
      }
    }
    const append = (c) => {
      if (isArr(c))
        return c.forEach(append);
      if (isFunc(c)) {
        const anchor = doc.createTextNode("");
        el.appendChild(anchor);
        let currentNodes = [];
        const effect = createEffect(() => {
          const res = c();
          const next = (isArr(res) ? res : [res]).map(ensureNode);
          currentNodes.forEach((n) => {
            if (n._isRuntime)
              n.destroy();
            else
              cleanupNode(n);
            if (n.parentNode)
              n.remove();
          });
          let ref = anchor;
          for (let i = next.length - 1;i >= 0; i--) {
            const node = next[i];
            if (node.parentNode !== ref.parentNode)
              ref.parentNode?.insertBefore(node, ref);
            if (node._mounts)
              node._mounts.forEach((fn) => fn());
            ref = node;
          }
          currentNodes = next;
        });
        effect();
        el._cleanups.add(() => dispose(effect));
        onUnmount(() => dispose(effect));
      } else {
        const node = ensureNode(c);
        el.appendChild(node);
        if (node._mounts)
          node._mounts.forEach((fn) => fn());
      }
    };
    append(children);
    return el;
  };
  var render = (renderFn) => {
    const cleanups = new Set;
    const previousOwner = activeOwner;
    const previousEffect = activeEffect;
    const container = doc.createElement("div");
    container.style.display = "contents";
    container.setAttribute("role", "presentation");
    activeOwner = { _cleanups: cleanups };
    activeEffect = null;
    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 : doc.createTextNode(String(result == null ? "" : result)));
      }
    };
    try {
      processResult(renderFn({ onCleanup: (fn) => cleanups.add(fn) }));
    } finally {
      activeOwner = previousOwner;
      activeEffect = previousEffect;
    }
    return {
      _isRuntime: true,
      container,
      destroy: () => {
        cleanups.forEach((fn) => fn());
        cleanupNode(container);
        container.remove();
      }
    };
  };
  var when = (cond, SIP, NOP = null) => {
    const anchor = doc.createTextNode("");
    const root = h("div", { style: "display:contents" }, [anchor]);
    let currentView = null;
    watch(() => !!(isFunc(cond) ? cond() : cond), (show) => {
      if (currentView) {
        currentView.destroy();
        currentView = null;
      }
      const content = show ? SIP : NOP;
      if (content) {
        currentView = render(() => isFunc(content) ? content() : content);
        root.insertBefore(currentView.container, anchor);
      }
    });
    onUnmount(() => currentView?.destroy());
    return root;
  };
  var each = (src, itemFn, keyField) => {
    const anchor = doc.createTextNode("");
    const root = h("div", { style: "display:contents" }, [anchor]);
    let cache = new Map;
    watch(() => (isFunc(src) ? src() : src) || [], (items) => {
      const nextCache = new Map;
      const nextOrder = [];
      const newItems = items || [];
      for (let i = 0;i < newItems.length; i++) {
        const item = newItems[i];
        const key = keyField ? item?.[keyField] ?? i : item?.id ?? i;
        let view = cache.get(key);
        if (!view)
          view = render(() => itemFn(item, i));
        else
          cache.delete(key);
        nextCache.set(key, view);
        nextOrder.push(view);
      }
      cache.forEach((view) => view.destroy());
      let lastRef = anchor;
      for (let i = nextOrder.length - 1;i >= 0; i--) {
        const view = nextOrder[i];
        const node = view.container;
        if (node.nextSibling !== lastRef)
          root.insertBefore(node, lastRef);
        lastRef = node;
      }
      cache = nextCache;
    });
    return root;
  };
  var router = (routes) => {
    const getHash = () => window.location.hash.slice(1) || "/";
    const path = $(getHash());
    const handler = () => path(getHash());
    window.addEventListener("hashchange", handler);
    onUnmount(() => window.removeEventListener("hashchange", handler));
    const hook = h("div", { class: "router-hook" });
    let currentView = null;
    watch([path], () => {
      const cur = path();
      const route = routes.find((r) => {
        const p1 = r.path.split("/").filter(Boolean);
        const p2 = cur.split("/").filter(Boolean);
        return p1.length === p2.length && p1.every((p, i) => p[0] === ":" || p === p2[i]);
      }) || routes.find((r) => r.path === "*");
      if (route) {
        currentView?.destroy();
        const params = {};
        route.path.split("/").filter(Boolean).forEach((p, i) => {
          if (p[0] === ":")
            params[p.slice(1)] = cur.split("/").filter(Boolean)[i];
        });
        router.params(params);
        currentView = render(() => isFunc(route.component) ? route.component(params) : route.component);
        hook.replaceChildren(currentView.container);
      }
    });
    return hook;
  };
  router.params = $({});
  router.to = (p) => window.location.hash = p.replace(/^#?\/?/, "#/");
  router.back = () => window.history.back();
  router.path = () => window.location.hash.replace(/^#/, "") || "/";
  var mount = (comp, target) => {
    const t = typeof target === "string" ? doc.querySelector(target) : target;
    if (!t)
      return;
    if (MOUNTED_NODES.has(t))
      MOUNTED_NODES.get(t).destroy();
    const inst = render(isFunc(comp) ? comp : () => comp);
    t.replaceChildren(inst.container);
    MOUNTED_NODES.set(t, inst);
    return inst;
  };
  var sigpro = () => {
    if (typeof window === "undefined")
      return;
    Object.assign(window, { $, $$, watch, h, when, each, router, mount, batch });
    "a abbr article aside ... video".split(" ").forEach((tag) => {
      window[tag] = (props, children) => h(tag, props, children);
    });
  };
  if (typeof import.meta === "undefined" && typeof window !== "undefined")
    sigpro();
})();