ladrillosjs 2.0.0-beta.3.2 → 2.0.0-beta.3.3

package/dist/webcomponent-SSpadLeF.mjs

@@ -0,0 +1,1154 @@
+var pt = Object.defineProperty, mt = Object.defineProperties;
+var bt = Object.getOwnPropertyDescriptors;
+var Y = Object.getOwnPropertySymbols;
+var gt = Object.prototype.hasOwnProperty, Et = Object.prototype.propertyIsEnumerable;
+var et = (n) => {
+  throw TypeError(n);
+};
+var tt = (n, t, e) => t in n ? pt(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e, k = (n, t) => {
+  for (var e in t || (t = {}))
+    gt.call(t, e) && tt(n, e, t[e]);
+  if (Y)
+    for (var e of Y(t))
+      Et.call(t, e) && tt(n, e, t[e]);
+  return n;
+}, Z = (n, t) => mt(n, bt(t));
+var J = (n, t, e) => t.has(n) || et("Cannot " + e);
+var _ = (n, t, e) => (J(n, t, "read from private field"), e ? e.call(n) : t.get(n)), R = (n, t, e) => t.has(n) ? et("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(n) : t.set(n, e), j = (n, t, e, s) => (J(n, t, "write to private field"), s ? s.call(n, e) : t.set(n, e), e), M = (n, t, e) => (J(n, t, "access private method"), e);
+var D = (n, t, e) => new Promise((s, o) => {
+  var l = (u) => {
+    try {
+      r(e.next(u));
+    } catch (f) {
+      o(f);
+    }
+  }, i = (u) => {
+    try {
+      r(e.throw(u));
+    } catch (f) {
+      o(f);
+    }
+  }, r = (u) => u.done ? s(u.value) : Promise.resolve(u.value).then(l, i);
+  r((e = e.apply(n, t)).next());
+});
+import { R as nt, l as wt, a as Q, c as N, b as $t, d as yt, e as vt, f as At, g as xt, h as G, i as _t } from "./index-5zcCcI-K.mjs";
+const St = (n, t, e) => {
+  if (!t) return;
+  const s = document.createElement("style");
+  s.textContent = t, e ? n.appendChild(s) : document.head.appendChild(s);
+}, Ct = (n, t) => {
+  n.innerHTML = t;
+  const e = Tt(n), s = Lt(n), o = Vt(n), l = Bt(n);
+  return { bindings: e, twoWayBindings: s, conditionals: o, loops: l };
+}, st = (n) => {
+  const t = [], e = n.match(/\((.*)\)/);
+  if (!e) return t;
+  const s = e[1].trim();
+  return s && s.split(",").map((l) => l.trim()).forEach((l) => {
+    if (/^['"]/.test(l) || /^\d+/.test(l)) return;
+    const i = l.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)/);
+    i && t.push(i[1]);
+  }), t;
+}, Tt = (n) => {
+  const t = document.createTreeWalker(n, NodeFilter.SHOW_TEXT, null), e = [];
+  let s;
+  const o = (i) => {
+    let r = i.parentElement;
+    for (; r; ) {
+      if (r.hasAttribute && r.hasAttribute("$for"))
+        return !0;
+      r = r.parentElement;
+    }
+    return !1;
+  };
+  for (; s = t.nextNode(); ) {
+    if (o(s))
+      continue;
+    const i = [...s.textContent.matchAll(nt.bindings)];
+    if (i.length > 0) {
+      const r = s.textContent, u = i.map((f) => {
+        const c = f[1].trim(), d = c.includes("(") && c.includes(")"), a = /[+*/%<>=!&|]/.test(c) || // Math or logical operators (excluding hyphen)
+        /\s-\s/.test(c), m = /^(!|typeof\s|void\s|delete\s)/.test(c), g = a || m || // Expressions starting with operators
+        /\.(?![\s}])[a-zA-Z_$][\w]*\(/.test(c) || // Method calls like name.toLowerCase()
+        /\bnew\s+/.test(c) || // Object instantiation like new Date()
+        /\b(typeof|instanceof|void|delete)\b/.test(c), p = d ? [c.split("(")[0].trim()] : c.split(".").map((A) => A.trim()), h = d ? st(c) : [];
+        return { raw: c, path: p, isFunction: d, isExpression: g, functionArgs: h };
+      });
+      e.push({ node: s, bindings: u, original: r });
+    }
+  }
+  return n.querySelectorAll("*").forEach((i) => {
+    if (!(i.hasAttribute("$for") || o(i)))
+      for (const r of i.attributes) {
+        if (r.name === "$if" || r.name === "$else-if" || r.name === "$else" || r.name === "$bind")
+          continue;
+        const u = [...r.value.matchAll(nt.bindings)];
+        if (u.length > 0) {
+          const f = r.value, c = u.map((d) => {
+            const a = d[1].trim(), m = a.includes("(") && a.includes(")"), g = /[+*/%<>=!&|]/.test(a) || // Math or logical operators (excluding hyphen)
+            /\s-\s/.test(a), p = /^(!|typeof\s|void\s|delete\s)/.test(a), h = g || p || // Expressions starting with operators
+            /\.(?![\s}])[a-zA-Z_$][\w]*\(/.test(a) || // Method calls like name.toLowerCase()
+            /\bnew\s+/.test(a) || // Object instantiation like new Date()
+            /\b(typeof|instanceof|void|delete)\b/.test(a), A = m ? [a.split("(")[0].trim()] : a.split(".").map((L) => L.trim()), w = m ? st(a) : [];
+            return { raw: a, path: A, isFunction: m, isExpression: h, functionArgs: w };
+          });
+          e.push({
+            node: i,
+            bindings: c,
+            original: f,
+            isAttribute: !0,
+            attributeName: r.name
+          });
+        }
+      }
+  }), e;
+}, Lt = (n) => {
+  const t = [];
+  return n.querySelectorAll("[\\$bind]").forEach((s) => {
+    var r;
+    const o = s.getAttribute("$bind");
+    if (!o) return;
+    const l = o.trim(), i = l.split(".").map((u) => u.trim());
+    s instanceof HTMLInputElement || s instanceof HTMLTextAreaElement || s instanceof HTMLSelectElement ? (t.push({
+      element: s,
+      path: i,
+      raw: l,
+      isContentEditable: !1,
+      initialValue: s.value || ""
+    }), s.removeAttribute("$bind")) : s instanceof HTMLElement && s.hasAttribute("contenteditable") && (t.push({
+      element: s,
+      path: i,
+      raw: l,
+      isContentEditable: !0,
+      initialValue: ((r = s.textContent) == null ? void 0 : r.trim()) || ""
+    }), s.removeAttribute("$bind"));
+  }), t;
+}, Vt = (n) => {
+  const t = [], e = /* @__PURE__ */ new Set();
+  return n.querySelectorAll("[\\$if]").forEach((o) => {
+    if (e.has(o)) return;
+    const l = [];
+    let i = o;
+    for (; i; ) {
+      const r = i.hasAttribute("$if"), u = i.hasAttribute("$else-if"), f = i.hasAttribute("$else");
+      if (!r && !u && !f) break;
+      e.add(i);
+      let c, d = "";
+      r ? (c = "if", d = i.getAttribute("$if") || "", i.removeAttribute("$if")) : u ? (c = "else-if", d = i.getAttribute("$else-if") || "", i.removeAttribute("$else-if")) : (c = "else", i.removeAttribute("$else"));
+      const a = document.createComment(
+        `conditional:${c}:${d}`
+      ), m = i.parentElement || n, g = i.nextSibling;
+      m.insertBefore(a, i);
+      const p = {
+        element: i,
+        condition: d.trim(),
+        type: c,
+        placeholder: a,
+        group: [],
+        // Will be set after the group is complete
+        originalParent: m,
+        nextSibling: g
+      };
+      l.push(p);
+      const h = i.nextElementSibling;
+      if (i.remove(), i = h, h && !h.hasAttribute("$else-if") && !h.hasAttribute("$else"))
+        break;
+    }
+    l.forEach((r) => {
+      r.group = l;
+    }), t.push(l);
+  }), t;
+}, kt = (n) => {
+  const t = /* @__PURE__ */ new Set();
+  return n.forEach((e) => {
+    e.forEach((s) => {
+      let o = s.condition;
+      o = o.replace(/\{([^}]+)\}/g, "$1");
+      const l = /\b([a-zA-Z_$][a-zA-Z0-9_$]*(?:\.[a-zA-Z_$][a-zA-Z0-9_$]*)*)\b/g, i = /* @__PURE__ */ new Set([
+        "true",
+        "false",
+        "null",
+        "undefined",
+        "typeof",
+        "instanceof",
+        "new",
+        "return",
+        "if",
+        "else",
+        "for",
+        "while",
+        "do",
+        "switch",
+        "case",
+        "break",
+        "continue"
+      ]);
+      let r;
+      for (; (r = l.exec(o)) !== null; ) {
+        const f = r[1].split(".")[0];
+        i.has(f) || t.add(f);
+      }
+    });
+  }), t;
+}, Bt = (n) => {
+  const t = [];
+  return n.querySelectorAll("[\\$for]").forEach((s) => {
+    var m;
+    const o = s.getAttribute("$for");
+    if (!o) return;
+    const l = s.getAttribute("$key") || void 0, i = o.match(
+      /^\s*(?:\(([^,]+),\s*([^)]+)\)|([^\s]+))\s+(?:in|of)\s+(.+)\s*$/
+    );
+    if (!i) {
+      wt(`Invalid $for expression: "${o}"`, {
+        expression: o,
+        lineHint: "$for attribute parsing"
+      });
+      return;
+    }
+    const r = (i[1] || i[3]).trim(), u = (m = i[2]) == null ? void 0 : m.trim(), f = i[4].trim(), c = document.createComment(`loop:${o}`), d = s.parentElement || n;
+    d.insertBefore(c, s), s.removeAttribute("$for"), l && s.removeAttribute("$key"), s.remove();
+    const a = {
+      template: s,
+      expression: o,
+      itemName: r,
+      indexName: u,
+      arrayName: f,
+      keyAttribute: l,
+      placeholder: c,
+      renderedElements: [],
+      originalParent: d
+    };
+    t.push(a);
+  }), t;
+}, Rt = (n) => {
+  const t = /* @__PURE__ */ new Set();
+  return n.forEach((e) => {
+    const s = e.arrayName.split(".")[0];
+    t.add(s);
+  }), t;
+}, H = /* @__PURE__ */ new Map(), Ft = 100, z = (n) => {
+  const t = H.get(n);
+  if (t)
+    return H.delete(n), H.set(n, t), t;
+  const e = new Function(
+    "component",
+    `
+    const { Date, Array, Math, String, Number, Boolean, Object, JSON, RegExp } = globalThis;
+    with(component) { 
+      return ${n}; 
+    }
+    `
+  );
+  if (H.size >= Ft) {
+    const s = H.keys().next().value;
+    s && H.delete(s);
+  }
+  return H.set(n, e), e;
+}, I = (n, t) => t.reduce((e, s) => {
+  if (!(e == null || typeof e != "object"))
+    return e[s];
+}, n), K = (n, t, e) => {
+  if (t.length === 0) return;
+  const s = t[t.length - 1], o = t.slice(0, -1);
+  let l = n;
+  for (const i of o)
+    (l[i] === void 0 || l[i] === null) && (l[i] = {}), l = l[i];
+  l[s] = e;
+}, ot = (n, t, e) => {
+  if (n.length !== 0)
+    for (const s of n) {
+      let o = s.original, l, i = !1;
+      for (const { raw: r, path: u, isFunction: f, isExpression: c } of s.bindings) {
+        let d, a = !1;
+        if (c || f)
+          try {
+            d = z(r)(e || t);
+          } catch (g) {
+            Q(r, g, N(e)), d = void 0, a = !0;
+          }
+        else
+          d = I(t, u), d === void 0 && (a = !0);
+        if (a) {
+          i = !0;
+          continue;
+        }
+        const m = String(d != null ? d : "");
+        l = d, o = o.replace(`{${r}}`, m);
+      }
+      if (i && s.original, s.node.nodeType === Node.TEXT_NODE) {
+        const r = s.node, u = r.parentElement, f = o.trim().startsWith("<") && o.includes(">");
+        u && f ? u.innerHTML !== o && (u.innerHTML = o) : r.textContent !== o && (r.textContent = o);
+      } else {
+        const r = s.node;
+        s.isAttribute && s.attributeName && ([
+          "disabled",
+          "checked",
+          "readonly",
+          "required",
+          "selected",
+          "hidden",
+          "open",
+          "autofocus",
+          "autoplay",
+          "controls",
+          "loop",
+          "muted"
+        ].includes(s.attributeName.toLowerCase()) ? (typeof l == "boolean" ? l : l === "true" || l === "True") ? r.setAttribute(s.attributeName, "") : r.removeAttribute(s.attributeName) : r.setAttribute(s.attributeName, o));
+      }
+    }
+}, Nt = (n, t, e) => {
+  if (!n) return !0;
+  let s = n.trim();
+  s = s.replace(/\{([^}]+)\}/g, "$1");
+  try {
+    return new Function(
+      "context",
+      "component",
+      `
+      with (context) {
+        try {
+          return Boolean(${s});
+        } catch (e) {
+          return false;
+        }
+      }
+    `
+    )(t, e);
+  } catch (o) {
+    return yt(
+      n,
+      o,
+      N(e)
+    ), !1;
+  }
+}, at = (n, t) => {
+  const e = [
+    "click",
+    "dblclick",
+    "mousedown",
+    "mouseup",
+    "mouseover",
+    "mouseout",
+    "mousemove",
+    "mouseenter",
+    "mouseleave",
+    "keydown",
+    "keyup",
+    "keypress",
+    "focus",
+    "blur",
+    "change",
+    "input",
+    "submit",
+    "reset",
+    "scroll",
+    "resize",
+    "load",
+    "unload",
+    "touchstart",
+    "touchend",
+    "touchmove",
+    "touchcancel",
+    "dragstart",
+    "drag",
+    "dragend",
+    "dragenter",
+    "dragover",
+    "dragleave",
+    "drop"
+  ];
+  [n, ...n.querySelectorAll("*")].forEach((o) => {
+    e.forEach((l) => {
+      const i = `on${l}`, r = o.getAttribute(i);
+      if (r) {
+        const u = `__processed_${i}`;
+        if (o[u]) return;
+        o.removeAttribute(i), o.addEventListener(
+          l,
+          function(f) {
+            try {
+              new Function(
+                "event",
+                "component",
+                `
+                with(component) {
+                  ${r}
+                }
+              `
+              ).call(this, f, t);
+            } catch (c) {
+              vt(
+                l,
+                r,
+                c,
+                N(t, {
+                  elementTag: o.tagName.toLowerCase()
+                })
+              );
+            }
+          }
+        ), o[u] = !0;
+      }
+    });
+  });
+}, it = (n, t, e) => {
+  var s;
+  for (const o of n) {
+    let l = !1;
+    for (const i of o) {
+      const { element: r, condition: u, type: f, placeholder: c, originalParent: d } = i;
+      let a = !1;
+      f === "else" ? a = !l : l || (a = Nt(u, t, e), a && (l = !0));
+      const m = r.parentNode !== null;
+      a && !m ? ((s = c.parentNode) == null || s.insertBefore(r, c.nextSibling), e && at(r, e)) : !a && m && r.remove();
+    }
+  }
+}, rt = (n, t, e) => {
+  var s;
+  for (const o of n) {
+    const {
+      template: l,
+      itemName: i,
+      indexName: r,
+      arrayName: u,
+      placeholder: f,
+      renderedElements: c
+    } = o, d = I(t, u.split("."));
+    if (d !== void 0 && !Array.isArray(d)) {
+      $t(
+        `${i} in ${u}`,
+        new Error(`"${u}" is not an array, got: ${typeof d}`),
+        N(e, {
+          lineHint: "$for loop in template"
+        })
+      ), c.forEach((p) => p.remove()), c.length = 0;
+      return;
+    }
+    if (!d)
+      return;
+    const a = d.length, m = c.length;
+    if (a === m && a > 0) {
+      d.forEach((p, h) => {
+        const A = c[h], w = Z(k({}, t), {
+          [i]: p
+        });
+        r && (w[r] = h), ct(A, w, e);
+      });
+      return;
+    }
+    a < m && c.splice(a).forEach((h) => h.remove());
+    const g = Math.min(a, m);
+    for (let p = 0; p < g; p++) {
+      const h = d[p], A = c[p], w = Z(k({}, t), {
+        [i]: h
+      });
+      r && (w[r] = p), ct(A, w, e);
+    }
+    if (a > m) {
+      const p = document.createDocumentFragment();
+      for (let A = m; A < a; A++) {
+        const w = d[A], L = l.cloneNode(!0), O = Z(k({}, t), {
+          [i]: w
+        });
+        r && (O[r] = A), Ot(L, O, e), p.appendChild(L), c.push(L), e && at(L, e);
+      }
+      const h = c[m - 1] || f;
+      (s = h.parentNode) == null || s.insertBefore(p, h.nextSibling);
+    }
+  }
+}, ct = (n, t, e) => {
+  const s = document.createTreeWalker(n, NodeFilter.SHOW_TEXT, null);
+  let o;
+  for (; o = s.nextNode(); ) {
+    const i = o.__originalText;
+    if (i || o.textContent && o.textContent.includes("{")) {
+      const u = i || o.textContent;
+      i || (o.__originalText = u);
+      let f = u;
+      [...u.matchAll(/\{([^}]+)\}/g)].forEach((d) => {
+        const a = d[1].trim(), m = a.includes("(") && a.includes(")"), p = /[+*/%<>=!&|]/.test(a) || /\s-\s/.test(a) || /\.(?![\s}])[a-zA-Z_$][\w]*\(/.test(a) || /\bnew\s+/.test(a) || /\b(typeof|instanceof|void|delete)\b/.test(a);
+        let h;
+        if (p || m)
+          try {
+            const A = z(a), w = typeof t == "object" && t !== null ? k(k({}, t), e || {}) : e || {};
+            h = A(w);
+          } catch (A) {
+            h = void 0;
+          }
+        else {
+          const A = a.split(".").map((w) => w.trim());
+          h = I(t, A);
+        }
+        h !== void 0 && (f = f.replace(`{${a}}`, String(h != null ? h : "")));
+      }), o.textContent !== f && (o.textContent = f);
+    }
+  }
+  [n, ...n.querySelectorAll("*")].forEach((i) => {
+    Array.from(i.attributes).forEach((r) => {
+      const u = r.__originalValue;
+      if (u || r.value.includes("{")) {
+        const c = u || r.value;
+        u || (r.__originalValue = c);
+        let d = c;
+        [...c.matchAll(/\{([^}]+)\}/g)].forEach((m) => {
+          const g = m[1].trim(), p = g.includes("(") && g.includes(")"), A = /[+*/%<>=!&|]/.test(g) || /\s-\s/.test(g) || /\.(?![\s}])[a-zA-Z_$][\w]*\(/.test(g) || /\bnew\s+/.test(g) || /\b(typeof|instanceof|void|delete)\b/.test(g);
+          let w;
+          if (A || p)
+            try {
+              const L = z(g), O = typeof t == "object" && t !== null ? k(k({}, t), e || {}) : e || {};
+              w = L(O);
+            } catch (L) {
+              w = void 0;
+            }
+          else {
+            const L = g.split(".").map((O) => O.trim());
+            w = I(t, L);
+          }
+          w !== void 0 && (d = d.replace(`{${g}}`, String(w != null ? w : "")));
+        }), r.value !== d && i.setAttribute(r.name, d);
+      }
+    });
+  });
+}, Ot = (n, t, e) => {
+  const s = document.createTreeWalker(n, NodeFilter.SHOW_TEXT, null);
+  let o;
+  for (; o = s.nextNode(); )
+    if (o.textContent && o.textContent.includes("{")) {
+      const i = o.textContent;
+      o.__originalText = i;
+      let r = i;
+      [...i.matchAll(/\{([^}]+)\}/g)].forEach((f) => {
+        const c = f[1].trim(), d = c.includes("(") && c.includes(")"), m = /[+*/%<>=!&|]/.test(c) || /\s-\s/.test(c) || /\.(?![\s}])[a-zA-Z_$][\w]*\(/.test(c) || // Method calls
+        /\bnew\s+/.test(c) || // Object instantiation like new Date()
+        /\b(typeof|instanceof|void|delete)\b/.test(c);
+        let g;
+        if (m || d)
+          try {
+            const p = z(c), h = typeof t == "object" && t !== null ? k(k({}, t), e || {}) : e || {};
+            g = p(h);
+          } catch (p) {
+            Q(
+              c,
+              p,
+              N(e, {
+                lineHint: "$for loop template binding"
+              })
+            ), g = void 0;
+          }
+        else {
+          const p = c.split(".").map((h) => h.trim());
+          g = I(t, p);
+        }
+        g !== void 0 && (r = r.replace(`{${c}}`, String(g != null ? g : "")));
+      }), o.textContent = r;
+    }
+  [n, ...n.querySelectorAll("*")].forEach((i) => {
+    Array.from(i.attributes).forEach((r) => {
+      if (r.value.includes("{")) {
+        const u = r.value;
+        r.__originalValue = u;
+        let f = u;
+        [...u.matchAll(/\{([^}]+)\}/g)].forEach((d) => {
+          const a = d[1].trim(), m = a.includes("(") && a.includes(")"), p = /[+*/%<>=!&|]/.test(a) || /\s-\s/.test(a) || /\.(?![\s}])[a-zA-Z_$][\w]*\(/.test(a) || // Method calls
+          /\bnew\s+/.test(a) || // Object instantiation like new Date()
+          /\b(typeof|instanceof|void|delete)\b/.test(a);
+          let h;
+          if (p || m)
+            try {
+              const A = z(a), w = typeof t == "object" && t !== null ? k(k({}, t), e || {}) : e || {};
+              h = A(w);
+            } catch (A) {
+              Q(
+                a,
+                A,
+                N(e, {
+                  attributeName: r.name,
+                  lineHint: "$for loop attribute binding"
+                })
+              ), h = void 0;
+            }
+          else {
+            const A = a.split(".").map((w) => w.trim());
+            h = I(t, A);
+          }
+          h !== void 0 && (f = f.replace(`{${a}}`, String(h != null ? h : "")));
+        }), i.setAttribute(r.name, f);
+      }
+    });
+  });
+}, lt = (n) => n instanceof ShadowRoot ? n.host : n, Wt = (n, t) => {
+  const e = /* @__PURE__ */ new Set();
+  t.forEach(({ path: o }) => {
+    const l = o[0];
+    e.add(l);
+  });
+  const s = [];
+  return e.forEach((o) => {
+    s.push(`
+      if (!Object.getOwnPropertyDescriptor(component, '${o}')) {
+        Object.defineProperty(component, '${o}', {
+          get() { return this.state.${o}; },
+          set(val) { this.state.${o} = val; },
+          enumerable: true,
+          configurable: true
+        });
+      }
+    `);
+  }), {
+    injectedCode: "",
+    // No longer needed in script scope
+    componentInjections: s.join(`
+`),
+    bindVarNames: e
+  };
+}, Mt = (n, t, e = /* @__PURE__ */ new Set()) => {
+  const s = [], o = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Set();
+  t.forEach((u) => {
+    u.bindings.forEach((f) => {
+      const c = f.path[0];
+      l.add(c), f.isFunction && f.functionArgs && f.functionArgs.forEach((d) => {
+        l.add(d);
+      });
+    });
+  }), e.forEach((u) => {
+    l.add(u);
+  });
+  const i = /(?:const|let|var)\s+(\w+)\s*=\s*([^;]+);?/g;
+  let r;
+  for (; (r = i.exec(n)) !== null; ) {
+    const u = r[1], f = r[2].trim();
+    l.has(u) && (s.push(`component.state.${u} = ${u};`), o.set(u, f));
+  }
+  return { stateBindings: s, boundVarNames: l, defaultValues: o };
+}, Ht = (n, t) => {
+  if (t.size === 0) return n;
+  let e = n;
+  return t.forEach((s) => {
+    const o = new RegExp(
+      `\\b${s}((?:\\[[^\\]]+\\])(?:\\.[\\w]+|\\[[^\\]]+\\])*)\\s*([=+\\-*/%&|^]|\\+\\+|\\-\\-)`,
+      "g"
+    );
+    e = e.replace(
+      o,
+      `component.state.${s}$1 $2`
+    );
+    const l = new RegExp(
+      `(?<!component\\.state\\.)\\b${s}((?:\\[[^\\]]+\\])(?:\\.[\\w]+|\\[[^\\]]+\\])*)(?![=+\\-*/%&|^]|\\+\\+|\\-\\-)`,
+      "g"
+    );
+    e = e.replace(
+      l,
+      `component.state.${s}$1`
+    );
+    const i = new RegExp(
+      `\\b${s}\\.(\\w+(?:\\.\\w+)*)\\s*([=+\\-*/%&|^]|\\+\\+|\\-\\-)`,
+      "g"
+    );
+    e = e.replace(
+      i,
+      `component.state.${s}.$1 $2`
+    );
+    const r = new RegExp(
+      `(?<!component\\.state\\.)(?<!const\\s${s}\\s*=\\s*{[^}]*)\\b${s}\\.(\\w+(?:\\.\\w+)*)(?![=+\\-*/%&|^]|\\+\\+|\\-\\-)`,
+      "g"
+    );
+    e = e.replace(
+      r,
+      `component.state.${s}.$1`
+    );
+    const u = new RegExp(
+      `(?<!\\.)\\b(\\+\\+|\\-\\-)${s}\\b|\\b${s}(\\+\\+|\\-\\-)`,
+      "g"
+    );
+    e = e.replace(u, (d) => {
+      if (d.startsWith("++") || d.startsWith("--"))
+        return `${d.substring(0, 2)}component.state.${s}`;
+      {
+        const a = d.substring(d.length - 2);
+        return `component.state.${s}${a}`;
+      }
+    });
+    const f = new RegExp(
+      `(?<!\\.)\\b${s}\\s*(\\+=|\\-=|\\*=|\\/=|%=|\\*\\*=|<<=|>>=|>>>=|&=|\\|=|\\^=)`,
+      "g"
+    );
+    e = e.replace(
+      f,
+      `component.state.${s}$1`
+    );
+    const c = new RegExp(
+      `(?<!const\\s)(?<!let\\s)(?<!var\\s)(?<!\\.)\\b${s}\\s*=\\s*([^=])`,
+      "g"
+    );
+    e = e.replace(
+      c,
+      `component.state.${s} = $1`
+    );
+  }), e;
+}, ut = (n, t, e, s, o, l = /* @__PURE__ */ new Set()) => {
+  try {
+    const { injectedCode: i, componentInjections: r, bindVarNames: u } = Wt(n, e), f = /function\s+(\w+)|const\s+(\w+)\s*=\s*(?:\([^)]*\)|[\w\s]*)\s*=>/g, c = [];
+    let d;
+    for (; (d = f.exec(n)) !== null; ) {
+      const B = d[1] || d[2];
+      B && c.push(B);
+    }
+    const a = c.map(
+      (B) => `component.${B} = typeof ${B} !== 'undefined' ? ${B}.bind(component) : undefined;`
+    ).join(`
+            `), { stateBindings: m, boundVarNames: g, defaultValues: p } = Mt(n, t, l), h = /* @__PURE__ */ new Set([...g, ...u]), A = m.join(`
+            `), w = Ht(
+      n,
+      h
+    ), L = `
+      (function() {
+        // Create component scope with direct access to state
+        const component = this;
+        const $state = component.state;
+        
+        // Define $bind variables on component object for event handler access
+        ${r}
+        
+        // Provide framework utilities with $ prefix to avoid naming conflicts
+        const $setState = (updates) => component.setState(updates);
+        
+        // Event bus methods for component communication
+        const $emit = (eventName, data) => arguments[2].emit(eventName, data);
+        const $listen = (eventName, callback) => {
+          const unsubscribe = arguments[2].listen(eventName, callback);
+          // Store unsubscribe function for cleanup on disconnect
+          if (!component.__eventUnsubscribers) {
+            component.__eventUnsubscribers = [];
+          }
+          component.__eventUnsubscribers.push(unsubscribe);
+          return unsubscribe;
+        };
+        
+        // Also attach to component for event handler access
+        component.$emit = $emit;
+        component.$listen = $listen;
+        
+        // Override querySelector/querySelectorAll to query within the component's host
+        const host = arguments[1];
+        const $querySelector = (selector) => host.querySelector(selector);
+        const $querySelectorAll = (selector) => host.querySelectorAll(selector);
+        
+        // Execute script content within component scope so $bind variables are accessible
+        with(component) {
+          ${w}
+          
+          // Auto-bind variables to component state (e.g., const name = "value" → this.state.name = "value")
+          ${A}
+          
+          // Auto-attach all detected functions to component for onclick access
+          ${a}
+        }
+      }).call(arguments[0], arguments[0], arguments[1], arguments[2])
+    `;
+    return new Function(L)(o, s, At), p;
+  } catch (i) {
+    return xt(i, N(o)), /* @__PURE__ */ new Map();
+  }
+}, dt = (n, t) => {
+  [
+    "click",
+    "dblclick",
+    "mousedown",
+    "mouseup",
+    "mouseover",
+    "mouseout",
+    "mousemove",
+    "mouseenter",
+    "mouseleave",
+    "keydown",
+    "keyup",
+    "keypress",
+    "focus",
+    "blur",
+    "change",
+    "input",
+    "submit",
+    "reset",
+    "scroll",
+    "resize",
+    "load",
+    "unload",
+    "touchstart",
+    "touchend",
+    "touchmove",
+    "touchcancel",
+    "dragstart",
+    "drag",
+    "dragend",
+    "dragenter",
+    "dragover",
+    "dragleave",
+    "drop"
+  ].forEach((s) => {
+    const o = `on${s}`;
+    (n instanceof ShadowRoot ? n.querySelectorAll(`[${o}]`) : t.querySelectorAll(`[${o}]`)).forEach((i) => {
+      const r = `${o}`;
+      if (i[`__processed_${r}`]) return;
+      const u = i.getAttribute(o);
+      u && (i.removeAttribute(o), i.addEventListener(
+        s,
+        function(f) {
+          new Function(
+            "event",
+            "component",
+            `
+            with(component) {
+              ${u}
+            }
+          `
+          ).call(this, f, t);
+        }
+      ), i[`__processed_${r}`] = !0);
+    });
+  });
+}, jt = (l, i, r, ...u) => D(null, [l, i, r, ...u], function* (n, t, e, s = [], o = /* @__PURE__ */ new Set()) {
+  const f = /* @__PURE__ */ new Map();
+  if (!(t != null && t.length)) return f;
+  const c = lt(n);
+  for (const d of t)
+    d.content && ut(
+      d.content,
+      e,
+      s,
+      n,
+      c,
+      o
+    ).forEach((m, g) => {
+      f.has(g) || f.set(g, m);
+    });
+  return dt(n, c), f;
+}), It = (n, t) => new Promise((e, s) => {
+  const o = document.querySelector(
+    `script[src="${n}"]`
+  );
+  if (o) {
+    if (o.dataset.loaded === "true") {
+      e();
+      return;
+    }
+    o.addEventListener("load", () => e(), { once: !0 }), o.addEventListener(
+      "error",
+      () => s(new Error(`Failed to load external script: ${n}`)),
+      { once: !0 }
+    );
+    return;
+  }
+  const l = document.createElement("script");
+  l.src = n, t && (l.type = t), l.onload = () => {
+    l.dataset.loaded = "true", e();
+  }, l.onerror = () => s(new Error(`Failed to load external script: ${n}`)), document.head.appendChild(l);
+}), qt = (i, r, u, ...f) => D(null, [i, r, u, ...f], function* (n, t, e, s = [], o = /* @__PURE__ */ new Set(), l) {
+  var d;
+  const c = lt(n);
+  for (const a of t) {
+    let m;
+    l ? l.startsWith("http://") || l.startsWith("https://") ? m = l : m = new URL(
+      l,
+      window.location.href
+    ).href : m = window.location.href;
+    const g = new URL(a.src, m).href;
+    if (a.external)
+      yield It(g, a.type);
+    else if (a.type === "module") {
+      const p = c.tagName.toLowerCase();
+      window.__ladrilloContexts || (window.__ladrilloContexts = /* @__PURE__ */ new Map()), window.__ladrilloContexts.set(p, {
+        host: n,
+        shadowRoot: n instanceof ShadowRoot ? n : null,
+        element: c,
+        state: c.state,
+        setState: (d = c.setState) == null ? void 0 : d.bind(c)
+      });
+      const h = document.createElement("script");
+      h.type = "module", h.src = g, h.setAttribute("data-component", p), document.head.appendChild(h);
+    } else
+      yield fetch(g).then((p) => {
+        if (!p.ok)
+          throw new Error(`HTTP ${p.status}: ${p.statusText}`);
+        const h = p.headers.get("content-type");
+        if (h && !h.includes("javascript") && !h.includes("text/plain"))
+          throw new Error(`Expected JavaScript but got ${h}`);
+        return p.text();
+      }).then((p) => {
+        ut(
+          p,
+          e,
+          s,
+          n,
+          c,
+          o
+        );
+      }).catch((p) => {
+        console.error(`Failed to load external script: ${a.src}`, p);
+      });
+  }
+  dt(n, c);
+}), Zt = (n, t) => {
+  var f, c, d, a, m, g, p, h, q, w, ft, ht;
+  const { tagName: e, template: s, scripts: o, externalScripts: l, styles: i, sourcePath: r } = n, B = class B extends HTMLElement {
+    constructor() {
+      super();
+      R(this, h);
+      R(this, f, []);
+      R(this, c, []);
+      R(this, d, []);
+      R(this, a, []);
+      R(this, m, []);
+      R(this, g, r);
+      R(this, p, /* @__PURE__ */ new WeakMap());
+      t && this.attachShadow({ mode: "open" });
+      const b = {};
+      let E = !1;
+      const S = () => {
+        E || (E = !0, requestAnimationFrame(() => {
+          E = !1, ot(_(this, f), this.state, this), it(_(this, d), this.state, this), rt(_(this, a), this.state, this), M(this, h, ht).call(this);
+        }));
+      }, v = () => {
+        S();
+      };
+      this.state = new Proxy(b, {
+        get: ($, y) => $[y],
+        set: ($, y, C) => {
+          const W = $[y];
+          return y in $ && Object.is(W, C) || (C !== null && typeof C == "object" ? $[y] = M(this, h, q).call(this, C, v) : $[y] = C, Object.getOwnPropertyDescriptor(this, y) || Object.defineProperty(this, y, {
+            get() {
+              return this.state[y];
+            },
+            set(V) {
+              this.state[y] = V;
+            },
+            enumerable: !0,
+            configurable: !0
+          }), v()), !0;
+        }
+      });
+    }
+    /**
+     * Updates component state with one or more key-value pairs
+     * @param updates - Object containing state updates
+     * @example
+     * component.setState({ count: 5, name: 'John' })
+     */
+    setState(b) {
+      Object.assign(this.state, b);
+    }
+    // Invoked when element is added to the DOM
+    connectedCallback() {
+      return D(this, null, function* () {
+        const b = t ? this.shadowRoot : this, { bindings: E, twoWayBindings: S, conditionals: v, loops: $ } = Ct(
+          b,
+          s
+        );
+        j(this, f, E), j(this, c, S), j(this, d, v), j(this, a, $);
+        const y = kt(v), C = Rt($);
+        St(b, i, t), yield qt(
+          b,
+          l,
+          _(this, f),
+          _(this, c),
+          /* @__PURE__ */ new Set([...y, ...C]),
+          _(this, g)
+        ), (yield jt(
+          b,
+          o,
+          _(this, f),
+          _(this, c),
+          /* @__PURE__ */ new Set([...y, ...C])
+        )).forEach((x, V) => {
+          if (this.state[V] === void 0)
+            try {
+              const T = new Function(`return ${x}`);
+              this.state[V] = T();
+            } catch (T) {
+              this.state[V] = x;
+            }
+        }), this._initializeStateFromAttributes(), this._setupTwoWayBindings(), ot(_(this, f), this.state, this), it(_(this, d), this.state, this), rt(_(this, a), this.state, this), this._setupAttributeObserver();
+      });
+    }
+    // Invoked when element is removed from the DOM
+    disconnectedCallback() {
+      this.__attributeObserver && (this.__attributeObserver.disconnect(), this.__attributeObserver = null), _(this, m).forEach((E) => {
+        try {
+          E();
+        } catch (S) {
+          _t(
+            "cleanup",
+            S,
+            N(this, {
+              lineHint: "disconnectedCallback cleanup"
+            })
+          );
+        }
+      }), j(this, m, []);
+      const b = this.__eventUnsubscribers;
+      b && Array.isArray(b) && (b.forEach((E) => {
+        try {
+          E();
+        } catch (S) {
+          G.error(
+            "⚠️ Event Bus Error: Failed to unsubscribe from event",
+            N(this)
+          ), G.error(`  Error details: ${S.message}`);
+        }
+      }), this.__eventUnsubscribers = []);
+    }
+    // Set up observer to watch for attribute changes
+    _setupAttributeObserver() {
+      const b = new MutationObserver((E) => {
+        E.forEach((S) => {
+          if (S.type === "attributes" && S.attributeName) {
+            const v = this.getAttribute(S.attributeName);
+            this._handleAttributeChange(S.attributeName, v);
+          }
+        });
+      });
+      b.observe(this, {
+        attributes: !0,
+        attributeOldValue: !0
+      }), this.__attributeObserver = b;
+    }
+    // initializes the state from the attributes
+    _initializeStateFromAttributes() {
+      this.getAttributeNames().forEach((b) => {
+        const E = this.getAttribute(b);
+        this._handleAttributeChange(b, E);
+      });
+    }
+    // Invoked when attributes are changed.
+    _handleAttributeChange(b, E) {
+      var v;
+      if (b) {
+        const $ = "this.state.";
+        b.startsWith($) && (b = b.slice($.length));
+      }
+      const S = M(v = B, w, ft).call(v, E);
+      this.state[b] = S;
+    }
+    // Setup two-way data bindings for input elements with $bind
+    _setupTwoWayBindings() {
+      _(this, c).forEach(
+        ({ element: b, path: E, raw: S, isContentEditable: v, initialValue: $ }) => {
+          var C, W;
+          if (this._getNestedValue(E) === void 0) {
+            const x = $ || "";
+            K(this.state, E, x);
+          }
+          if (v) {
+            const x = b;
+            x.textContent = (C = this._getNestedValue(E)) != null ? C : "";
+            const V = (X) => {
+              const F = X.target.textContent || "";
+              K(this.state, E, F);
+            };
+            x.addEventListener("input", V);
+            const T = () => {
+              x.removeEventListener("input", V);
+            };
+            _(this, m).push(T);
+          } else {
+            const x = b, V = x instanceof HTMLInputElement && x.type === "checkbox";
+            x instanceof HTMLInputElement && x.type, V ? x.checked = !!this._getNestedValue(E) : x.value = (W = this._getNestedValue(E)) != null ? W : "";
+            const T = (P) => {
+              const F = P.target;
+              let U;
+              F instanceof HTMLInputElement && F.type === "checkbox" ? U = F.checked : (F instanceof HTMLInputElement && F.type, U = F.value), K(this.state, E, U);
+            };
+            x.addEventListener("input", T);
+            const X = () => {
+              x.removeEventListener("input", T);
+            };
+            if (_(this, m).push(X), x instanceof HTMLSelectElement || x instanceof HTMLInputElement && ["checkbox", "radio", "file"].includes(x.type)) {
+              x.addEventListener("change", T);
+              const P = () => {
+                x.removeEventListener("change", T);
+              };
+              _(this, m).push(P);
+            }
+          }
+        }
+      );
+    }
+    // Helper to get nested value from state
+    _getNestedValue(b) {
+      return b.reduce((E, S) => E == null ? void 0 : E[S], this.state);
+    }
+  };
+  f = new WeakMap(), c = new WeakMap(), d = new WeakMap(), a = new WeakMap(), m = new WeakMap(), g = new WeakMap(), p = new WeakMap(), h = new WeakSet(), /**
+   * Creates a deep reactive proxy that tracks nested object/array mutations
+   * @param target - The object or array to make reactive
+   * @param callback - Function to call when any nested property changes
+   */
+  q = function(b, E) {
+    if (b === null || typeof b != "object" || b instanceof HTMLElement || b instanceof Node)
+      return b;
+    if (_(this, p).has(b))
+      return _(this, p).get(b);
+    const S = new Proxy(b, {
+      get: (v, $) => {
+        const y = v[$];
+        if (Array.isArray(v) && typeof y == "function" && [
+          "push",
+          "pop",
+          "shift",
+          "unshift",
+          "splice",
+          "sort",
+          "reverse"
+        ].includes($))
+          return (...W) => {
+            const x = W.map(
+              (T) => T !== null && typeof T == "object" ? M(this, h, q).call(this, T, E) : T
+            ), V = y.apply(v, x);
+            return E(), V;
+          };
+        if (y !== null && typeof y == "object") {
+          if (_(this, p).has(y))
+            return _(this, p).get(y);
+          const C = M(this, h, q).call(this, y, E);
+          return v[$] = C, C;
+        }
+        return y;
+      },
+      set: (v, $, y) => {
+        const C = v[$];
+        return Object.is(C, y) || (y !== null && typeof y == "object" ? v[$] = M(this, h, q).call(this, y, E) : v[$] = y, E()), !0;
+      }
+    });
+    return _(this, p).set(b, S), S;
+  }, w = new WeakSet(), ft = function(b) {
+    if (b === null || b === "") return null;
+    if (b !== "undefined")
+      try {
+        return JSON.parse(b);
+      } catch (E) {
+        return b;
+      }
+  }, // Update two-way bound elements when state changes
+  ht = function() {
+    _(this, c).forEach(({ element: b, path: E, isContentEditable: S }) => {
+      const v = this._getNestedValue(E);
+      if (S) {
+        const $ = b;
+        $.textContent !== v && ($.textContent = v != null ? v : "");
+      } else {
+        const $ = b;
+        if ($ instanceof HTMLInputElement && $.type === "checkbox") {
+          const y = !!v;
+          $.checked !== y && ($.checked = y);
+        } else
+          $.value !== v && ($.value = v != null ? v : "");
+      }
+    });
+  }, R(B, w);
+  let u = B;
+  customElements.get(e) || (customElements.define(e, u), G.log(`Web component defined: <${e}></${e}>`));
+};
+export {
+  Zt as defineWebComponent
+};
+//# sourceMappingURL=webcomponent-SSpadLeF.mjs.map