ladrillosjs 2.0.0-beta.3.2 → 2.0.0-beta.3.4

package/dist/webcomponent-WCW6485Z.mjs

@@ -0,0 +1,1250 @@
+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, B = (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)), F = (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), N = (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);
+    }
+  }, c = (u) => {
+    try {
+      r(e.throw(u));
+    } catch (f) {
+      o(f);
+    }
+  }, r = (u) => u.done ? s(u.value) : Promise.resolve(u.value).then(l, c);
+  r((e = e.apply(n, t)).next());
+});
+import { R as nt, l as wt, a as Q, c as W, b as $t, d as yt, e as vt, f as At, g as xt, h as G, i as _t } from "./index-COl4zCLy.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 = Rt(n), o = Lt(n), l = kt(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 c = l.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)/);
+    c && t.push(c[1]);
+  }), t;
+}, Tt = (n) => {
+  const t = document.createTreeWalker(n, NodeFilter.SHOW_TEXT, null), e = [];
+  let s;
+  const o = (c) => {
+    let r = c.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 c = [...s.textContent.matchAll(nt.bindings)];
+    if (c.length > 0) {
+      const r = s.textContent, u = c.map((f) => {
+        const i = f[1].trim(), d = i.includes("(") && i.includes(")"), a = /[+*/%<>=!&|]/.test(i) || // Math or logical operators (excluding hyphen)
+        /\s-\s/.test(i), m = /^(!|typeof\s|void\s|delete\s)/.test(i), b = a || m || // Expressions starting with operators
+        /\.(?![\s}])[a-zA-Z_$][\w]*\(/.test(i) || // Method calls like name.toLowerCase()
+        /\bnew\s+/.test(i) || // Object instantiation like new Date()
+        /\b(typeof|instanceof|void|delete)\b/.test(i), p = d ? [i.split("(")[0].trim()] : i.split(".").map(($) => $.trim()), h = d ? st(i) : [];
+        return { raw: i, path: p, isFunction: d, isExpression: b, functionArgs: h };
+      });
+      e.push({ node: s, bindings: u, original: r });
+    }
+  }
+  return n.querySelectorAll("*").forEach((c) => {
+    if (!(c.hasAttribute("$for") || o(c)))
+      for (const r of c.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, i = u.map((d) => {
+            const a = d[1].trim(), m = a.includes("(") && a.includes(")"), b = /[+*/%<>=!&|]/.test(a) || // Math or logical operators (excluding hyphen)
+            /\s-\s/.test(a), p = /^(!|typeof\s|void\s|delete\s)/.test(a), h = b || 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), $ = m ? [a.split("(")[0].trim()] : a.split(".").map((C) => C.trim()), E = m ? st(a) : [];
+            return { raw: a, path: $, isFunction: m, isExpression: h, functionArgs: E };
+          });
+          e.push({
+            node: c,
+            bindings: i,
+            original: f,
+            isAttribute: !0,
+            attributeName: r.name
+          });
+        }
+      }
+  }), e;
+}, Rt = (n) => {
+  const t = [];
+  return n.querySelectorAll("[\\$bind]").forEach((s) => {
+    var r;
+    const o = s.getAttribute("$bind");
+    if (!o) return;
+    const l = o.trim(), c = l.split(".").map((u) => u.trim());
+    s instanceof HTMLInputElement || s instanceof HTMLTextAreaElement || s instanceof HTMLSelectElement ? (t.push({
+      element: s,
+      path: c,
+      raw: l,
+      isContentEditable: !1,
+      initialValue: s.value || ""
+    }), s.removeAttribute("$bind")) : s instanceof HTMLElement && s.hasAttribute("contenteditable") && (t.push({
+      element: s,
+      path: c,
+      raw: l,
+      isContentEditable: !0,
+      initialValue: ((r = s.textContent) == null ? void 0 : r.trim()) || ""
+    }), s.removeAttribute("$bind"));
+  }), t;
+}, Lt = (n) => {
+  const t = [], e = /* @__PURE__ */ new Set();
+  return n.querySelectorAll("[\\$if]").forEach((o) => {
+    if (e.has(o)) return;
+    const l = [];
+    let c = o;
+    for (; c; ) {
+      const r = c.hasAttribute("$if"), u = c.hasAttribute("$else-if"), f = c.hasAttribute("$else");
+      if (!r && !u && !f) break;
+      e.add(c);
+      let i, d = "";
+      r ? (i = "if", d = c.getAttribute("$if") || "", c.removeAttribute("$if")) : u ? (i = "else-if", d = c.getAttribute("$else-if") || "", c.removeAttribute("$else-if")) : (i = "else", c.removeAttribute("$else"));
+      const a = document.createComment(
+        `conditional:${i}:${d}`
+      ), m = c.parentElement || n, b = c.nextSibling;
+      m.insertBefore(a, c);
+      const p = {
+        element: c,
+        condition: d.trim(),
+        type: i,
+        placeholder: a,
+        group: [],
+        // Will be set after the group is complete
+        originalParent: m,
+        nextSibling: b
+      };
+      l.push(p);
+      const h = c.nextElementSibling;
+      if (c.remove(), c = h, h && !h.hasAttribute("$else-if") && !h.hasAttribute("$else"))
+        break;
+    }
+    l.forEach((r) => {
+      r.group = l;
+    }), t.push(l);
+  }), t;
+}, Vt = (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, c = /* @__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];
+        c.has(f) || t.add(f);
+      }
+    });
+  }), t;
+}, kt = (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, c = o.match(
+      /^\s*(?:\(([^,]+),\s*([^)]+)\)|([^\s]+))\s+(?:in|of)\s+(.+)\s*$/
+    );
+    if (!c) {
+      wt(`Invalid $for expression: "${o}"`, {
+        expression: o,
+        lineHint: "$for attribute parsing"
+      });
+      return;
+    }
+    const r = (c[1] || c[3]).trim(), u = (m = c[2]) == null ? void 0 : m.trim(), f = c[4].trim(), i = document.createComment(`loop:${o}`), d = s.parentElement || n;
+    d.insertBefore(i, 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: i,
+      renderedElements: [],
+      originalParent: d
+    };
+    t.push(a);
+  }), t;
+}, Bt = (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, U = (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;
+}, z = (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 c of o)
+    (l[c] === void 0 || l[c] === null) && (l[c] = {}), l = l[c];
+  l[s] = e;
+}, ot = (n, t, e) => {
+  if (n.length !== 0)
+    for (const s of n) {
+      let o = s.original, l, c = !1;
+      for (const { raw: r, path: u, isFunction: f, isExpression: i } of s.bindings) {
+        let d, a = !1;
+        if (i || f)
+          try {
+            d = U(r)(e || t);
+          } catch (b) {
+            Q(r, b, W(e)), d = void 0, a = !0;
+          }
+        else
+          d = z(t, u), d === void 0 && (a = !0);
+        if (a) {
+          c = !0;
+          continue;
+        }
+        const m = String(d != null ? d : "");
+        l = d, o = o.replace(`{${r}}`, m);
+      }
+      if (c && 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));
+      }
+    }
+}, Ot = (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,
+      W(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 c = `on${l}`, r = o.getAttribute(c);
+      if (r) {
+        const u = `__processed_${c}`;
+        if (o[u]) return;
+        o.removeAttribute(c), o.addEventListener(
+          l,
+          function(f) {
+            try {
+              new Function(
+                "event",
+                "component",
+                `
+                with(component) {
+                  ${r}
+                }
+              `
+              ).call(this, f, t);
+            } catch (i) {
+              vt(
+                l,
+                r,
+                i,
+                W(t, {
+                  elementTag: o.tagName.toLowerCase()
+                })
+              );
+            }
+          }
+        ), o[u] = !0;
+      }
+    });
+  });
+}, rt = (n, t, e) => {
+  var s;
+  for (const o of n) {
+    let l = !1;
+    for (const c of o) {
+      const { element: r, condition: u, type: f, placeholder: i, originalParent: d } = c;
+      let a = !1;
+      f === "else" ? a = !l : l || (a = Ot(u, t, e), a && (l = !0));
+      const m = r.parentNode !== null;
+      a && !m ? ((s = i.parentNode) == null || s.insertBefore(r, i.nextSibling), e && at(r, e)) : !a && m && r.remove();
+    }
+  }
+}, it = (n, t, e) => {
+  var s;
+  for (const o of n) {
+    const {
+      template: l,
+      itemName: c,
+      indexName: r,
+      arrayName: u,
+      placeholder: f,
+      renderedElements: i
+    } = o, d = z(t, u.split("."));
+    if (d !== void 0 && !Array.isArray(d)) {
+      $t(
+        `${c} in ${u}`,
+        new Error(`"${u}" is not an array, got: ${typeof d}`),
+        W(e, {
+          lineHint: "$for loop in template"
+        })
+      ), i.forEach((p) => p.remove()), i.length = 0;
+      return;
+    }
+    if (!d)
+      return;
+    const a = d.length, m = i.length;
+    if (a === m && a > 0) {
+      d.forEach((p, h) => {
+        const $ = i[h], E = Z(B({}, t), {
+          [c]: p
+        });
+        r && (E[r] = h), ct($, E, e);
+      });
+      return;
+    }
+    a < m && i.splice(a).forEach((h) => h.remove());
+    const b = Math.min(a, m);
+    for (let p = 0; p < b; p++) {
+      const h = d[p], $ = i[p], E = Z(B({}, t), {
+        [c]: h
+      });
+      r && (E[r] = p), ct($, E, e);
+    }
+    if (a > m) {
+      const p = document.createDocumentFragment();
+      for (let $ = m; $ < a; $++) {
+        const E = d[$], C = l.cloneNode(!0), T = Z(B({}, t), {
+          [c]: E
+        });
+        r && (T[r] = $), Wt(C, T, e), p.appendChild(C), i.push(C), e && at(C, e);
+      }
+      const h = i[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 c = o.__originalText;
+    if (c || o.textContent && o.textContent.includes("{")) {
+      const u = c || o.textContent;
+      c || (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 $ = U(a), E = typeof t == "object" && t !== null ? B(B({}, t), e || {}) : e || {};
+            h = $(E);
+          } catch ($) {
+            h = void 0;
+          }
+        else {
+          const $ = a.split(".").map((E) => E.trim());
+          h = z(t, $);
+        }
+        h !== void 0 && (f = f.replace(`{${a}}`, String(h != null ? h : "")));
+      }), o.textContent !== f && (o.textContent = f);
+    }
+  }
+  [n, ...n.querySelectorAll("*")].forEach((c) => {
+    Array.from(c.attributes).forEach((r) => {
+      const u = r.__originalValue;
+      if (u || r.value.includes("{")) {
+        const i = u || r.value;
+        u || (r.__originalValue = i);
+        let d = i;
+        [...i.matchAll(/\{([^}]+)\}/g)].forEach((m) => {
+          const b = m[1].trim(), p = b.includes("(") && b.includes(")"), $ = /[+*/%<>=!&|]/.test(b) || /\s-\s/.test(b) || /\.(?![\s}])[a-zA-Z_$][\w]*\(/.test(b) || /\bnew\s+/.test(b) || /\b(typeof|instanceof|void|delete)\b/.test(b);
+          let E;
+          if ($ || p)
+            try {
+              const C = U(b), T = typeof t == "object" && t !== null ? B(B({}, t), e || {}) : e || {};
+              E = C(T);
+            } catch (C) {
+              E = void 0;
+            }
+          else {
+            const C = b.split(".").map((T) => T.trim());
+            E = z(t, C);
+          }
+          E !== void 0 && (d = d.replace(`{${b}}`, String(E != null ? E : "")));
+        }), r.value !== d && c.setAttribute(r.name, d);
+      }
+    });
+  });
+}, Wt = (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 c = o.textContent;
+      o.__originalText = c;
+      let r = c;
+      [...c.matchAll(/\{([^}]+)\}/g)].forEach((f) => {
+        const i = f[1].trim(), d = i.includes("(") && i.includes(")"), m = /[+*/%<>=!&|]/.test(i) || /\s-\s/.test(i) || /\.(?![\s}])[a-zA-Z_$][\w]*\(/.test(i) || // Method calls
+        /\bnew\s+/.test(i) || // Object instantiation like new Date()
+        /\b(typeof|instanceof|void|delete)\b/.test(i);
+        let b;
+        if (m || d)
+          try {
+            const p = U(i), h = typeof t == "object" && t !== null ? B(B({}, t), e || {}) : e || {};
+            b = p(h);
+          } catch (p) {
+            Q(
+              i,
+              p,
+              W(e, {
+                lineHint: "$for loop template binding"
+              })
+            ), b = void 0;
+          }
+        else {
+          const p = i.split(".").map((h) => h.trim());
+          b = z(t, p);
+        }
+        b !== void 0 && (r = r.replace(`{${i}}`, String(b != null ? b : "")));
+      }), o.textContent = r;
+    }
+  [n, ...n.querySelectorAll("*")].forEach((c) => {
+    Array.from(c.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 $ = U(a), E = typeof t == "object" && t !== null ? B(B({}, t), e || {}) : e || {};
+              h = $(E);
+            } catch ($) {
+              Q(
+                a,
+                $,
+                W(e, {
+                  attributeName: r.name,
+                  lineHint: "$for loop attribute binding"
+                })
+              ), h = void 0;
+            }
+          else {
+            const $ = a.split(".").map((E) => E.trim());
+            h = z(t, $);
+          }
+          h !== void 0 && (f = f.replace(`{${a}}`, String(h != null ? h : "")));
+        }), c.setAttribute(r.name, f);
+      }
+    });
+  });
+}, lt = (n) => n instanceof ShadowRoot ? n.host : n, Mt = (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
+  };
+}, Nt = (n, t, e = /* @__PURE__ */ new Set()) => {
+  const s = [], o = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Set();
+  t.forEach((u) => {
+    u.bindings.forEach((f) => {
+      const i = f.path[0];
+      l.add(i), f.isFunction && f.functionArgs && f.functionArgs.forEach((d) => {
+        l.add(d);
+      });
+    });
+  }), e.forEach((u) => {
+    l.add(u);
+  });
+  const c = /(?:const|let|var)\s+(\w+)\s*=\s*([^;]+);?/g;
+  let r;
+  for (; (r = c.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 c = new RegExp(
+      `\\b${s}\\.(\\w+(?:\\.\\w+)*)\\s*([=+\\-*/%&|^]|\\+\\+|\\-\\-)`,
+      "g"
+    );
+    e = e.replace(
+      c,
+      `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 i = new RegExp(
+      `(?<!const\\s)(?<!let\\s)(?<!var\\s)(?<!\\.)\\b${s}\\s*=\\s*([^=])`,
+      "g"
+    );
+    e = e.replace(
+      i,
+      `component.state.${s} = $1`
+    );
+  }), e;
+}, ut = (n, t, e, s, o, l = /* @__PURE__ */ new Set()) => {
+  try {
+    const { injectedCode: c, componentInjections: r, bindVarNames: u } = Mt(n, e), f = /function\s+(\w+)|const\s+(\w+)\s*=\s*(?:\([^)]*\)|[\w\s]*)\s*=>/g, i = [];
+    let d;
+    for (; (d = f.exec(n)) !== null; ) {
+      const R = d[1] || d[2];
+      R && i.push(R);
+    }
+    const a = i.map(
+      (R) => `component.${R} = typeof ${R} !== 'undefined' ? ${R}.bind(component) : undefined;`
+    ).join(`
+            `), { stateBindings: m, boundVarNames: b, defaultValues: p } = Nt(n, t, l), h = /* @__PURE__ */ new Set([...b, ...u]), $ = m.join(`
+            `), E = Ht(
+      n,
+      h
+    ), C = `
+      (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) {
+          ${E}
+          
+          // Auto-bind variables to component state (e.g., const name = "value" → this.state.name = "value")
+          ${$}
+          
+          // Auto-attach all detected functions to component for onclick access
+          ${a}
+        }
+      }).call(arguments[0], arguments[0], arguments[1], arguments[2])
+    `;
+    return new Function(C)(o, s, At), p;
+  } catch (c) {
+    return xt(c, W(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((c) => {
+      const r = `${o}`;
+      if (c[`__processed_${r}`]) return;
+      const u = c.getAttribute(o);
+      u && (c.removeAttribute(o), c.addEventListener(
+        s,
+        function(f) {
+          new Function(
+            "event",
+            "component",
+            `
+            with(component) {
+              ${u}
+            }
+          `
+          ).call(this, f, t);
+        }
+      ), c[`__processed_${r}`] = !0);
+    });
+  });
+}, jt = (l, c, r, ...u) => D(null, [l, c, r, ...u], function* (n, t, e, s = [], o = /* @__PURE__ */ new Set()) {
+  const f = /* @__PURE__ */ new Map();
+  if (!(t != null && t.length)) return f;
+  const i = lt(n);
+  for (const d of t)
+    d.content && ut(
+      d.content,
+      e,
+      s,
+      n,
+      i,
+      o
+    ).forEach((m, b) => {
+      f.has(b) || f.set(b, m);
+    });
+  return dt(n, i), f;
+}), zt = (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);
+}), It = (n, t, e) => t.size === 0 ? n : function(...s) {
+  const o = n.apply(this, s);
+  return e.requestUpdate && e.requestUpdate(), o;
+}, Ut = (n, t, e, s) => {
+  let o = n;
+  const l = /import\s+([^;]*?)\s+from\s+['"]([^'"]+)['"]/g;
+  if (o = o.replace(
+    l,
+    (r, u, f) => {
+      if (!f.startsWith(".") && !f.startsWith("/"))
+        return r;
+      try {
+        const i = new URL(f, s).href;
+        return `import ${u} from '${i}'`;
+      } catch (i) {
+        return console.warn(
+          `Could not resolve import path: ${f} relative to ${s}`
+        ), r;
+      }
+    }
+  ), t.size === 0)
+    return o;
+  const c = `
+// Auto-generated: Reactive state synchronization for module scope
+const __getComponent = () => window.__ladrilloContexts?.get('${e}')?.element;
+const __syncState = (varName, value) => {
+  const component = __getComponent();
+  if (component?.setState) {
+    component.setState({ [varName]: value });
+  }
+};
+`;
+  return t.forEach((r) => {
+    const u = new RegExp(
+      `(let|const|var)\\s+${r}\\s*=\\s*([^;=][^;]*);`,
+      "g"
+    );
+    o = o.replace(u, (i, d, a) => {
+      const m = a.trim();
+      return `${d} ${r} = ${m}; __syncState('${r}', ${r});`;
+    });
+    const f = new RegExp(
+      `(?<!let\\s|const\\s|var\\s)(?<!\\.)\\b${r}\\s*=\\s*([^;=][^;]*);`,
+      "g"
+    );
+    o = o.replace(f, (i, d) => {
+      const a = d.trim();
+      return `${r} = ${a}; __syncState('${r}', ${r});`;
+    });
+  }), c + `
+` + o;
+}, qt = (c, r, u, ...f) => D(null, [c, r, u, ...f], function* (n, t, e, s = [], o = /* @__PURE__ */ new Set(), l) {
+  var d;
+  const i = 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 b = new URL(a.src, m).href;
+    if (a.external)
+      yield zt(b, a.type);
+    else if (a.type === "module") {
+      const p = i.tagName.toLowerCase();
+      window.__ladrilloContexts || (window.__ladrilloContexts = /* @__PURE__ */ new Map()), window.__ladrilloContexts.set(p, {
+        host: n,
+        shadowRoot: n instanceof ShadowRoot ? n : null,
+        element: i,
+        state: i.state,
+        setState: (d = i.setState) == null ? void 0 : d.bind(i)
+      });
+      try {
+        const h = /* @__PURE__ */ new Set();
+        e.forEach((C) => {
+          C.bindings.forEach((T) => {
+            if (!T.isFunction) {
+              const R = T.path[0];
+              h.add(R);
+            }
+          });
+        });
+        let $ = b;
+        if (h.size > 0)
+          try {
+            let T = yield (yield fetch(b)).text();
+            T = Ut(
+              T,
+              h,
+              p,
+              b
+            );
+            const R = new Blob([T], { type: "application/javascript" });
+            $ = URL.createObjectURL(R);
+          } catch (C) {
+            console.warn(
+              `Could not transform module source, using original: ${b}`
+            );
+          }
+        const E = yield import(
+          /* webpackIgnore: true */
+          $
+        );
+        Object.entries(E).forEach(([C, T]) => {
+          if (C !== "default") {
+            const R = typeof T == "function" ? It(
+              T,
+              h,
+              i
+            ) : T;
+            i[C] = R;
+          }
+        }), E.default && (i.default = E.default), $ !== b && URL.revokeObjectURL($);
+      } catch (h) {
+        console.error(
+          `Failed to load or process module script: ${b}`,
+          h
+        );
+      }
+    } else
+      yield fetch(b).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,
+          i,
+          o
+        );
+      }).catch((p) => {
+        console.error(`Failed to load external script: ${a.src}`, p);
+      });
+  }
+  dt(n, i);
+}), Xt = (n, t) => {
+  var f, i, d, a, m, b, p, h, I, E, ft, ht;
+  const { tagName: e, template: s, scripts: o, externalScripts: l, styles: c, sourcePath: r } = n, R = class R extends HTMLElement {
+    constructor() {
+      super();
+      F(this, h);
+      F(this, f, []);
+      F(this, i, []);
+      F(this, d, []);
+      F(this, a, []);
+      F(this, m, []);
+      F(this, b, r);
+      F(this, p, /* @__PURE__ */ new WeakMap());
+      t && this.attachShadow({ mode: "open" });
+      const g = {};
+      let w = !1;
+      const S = () => {
+        w || (w = !0, requestAnimationFrame(() => {
+          w = !1, ot(_(this, f), this.state, this), rt(_(this, d), this.state, this), it(_(this, a), this.state, this), N(this, h, ht).call(this);
+        }));
+      }, A = () => {
+        S();
+      };
+      this.state = new Proxy(g, {
+        get: (y, v) => y[v],
+        set: (y, v, L) => {
+          const M = y[v];
+          return v in y && Object.is(M, L) || (L !== null && typeof L == "object" ? y[v] = N(this, h, I).call(this, L, A) : y[v] = L, Object.getOwnPropertyDescriptor(this, v) || Object.defineProperty(this, v, {
+            get() {
+              return this.state[v];
+            },
+            set(k) {
+              this.state[v] = k;
+            },
+            enumerable: !0,
+            configurable: !0
+          }), A()), !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(g) {
+      Object.assign(this.state, g);
+    }
+    // Invoked when element is added to the DOM
+    connectedCallback() {
+      return D(this, null, function* () {
+        const g = t ? this.shadowRoot : this, { bindings: w, twoWayBindings: S, conditionals: A, loops: y } = Ct(
+          g,
+          s
+        );
+        j(this, f, w), j(this, i, S), j(this, d, A), j(this, a, y);
+        const v = Vt(A), L = Bt(y);
+        St(g, c, t), yield qt(
+          g,
+          l,
+          _(this, f),
+          _(this, i),
+          /* @__PURE__ */ new Set([...v, ...L]),
+          _(this, b)
+        ), (yield jt(
+          g,
+          o,
+          _(this, f),
+          _(this, i),
+          /* @__PURE__ */ new Set([...v, ...L])
+        )).forEach((x, k) => {
+          if (this.state[k] === void 0)
+            try {
+              const V = new Function(`return ${x}`);
+              this.state[k] = V();
+            } catch (V) {
+              this.state[k] = x;
+            }
+        }), this._initializeStateFromAttributes(), this._setupTwoWayBindings(), ot(_(this, f), this.state, this), rt(_(this, d), this.state, this), it(_(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((w) => {
+        try {
+          w();
+        } catch (S) {
+          _t(
+            "cleanup",
+            S,
+            W(this, {
+              lineHint: "disconnectedCallback cleanup"
+            })
+          );
+        }
+      }), j(this, m, []);
+      const g = this.__eventUnsubscribers;
+      g && Array.isArray(g) && (g.forEach((w) => {
+        try {
+          w();
+        } catch (S) {
+          G.error(
+            "⚠️ Event Bus Error: Failed to unsubscribe from event",
+            W(this)
+          ), G.error(`  Error details: ${S.message}`);
+        }
+      }), this.__eventUnsubscribers = []);
+    }
+    // Set up observer to watch for attribute changes
+    _setupAttributeObserver() {
+      const g = new MutationObserver((w) => {
+        w.forEach((S) => {
+          if (S.type === "attributes" && S.attributeName) {
+            const A = this.getAttribute(S.attributeName);
+            this._handleAttributeChange(S.attributeName, A);
+          }
+        });
+      });
+      g.observe(this, {
+        attributes: !0,
+        attributeOldValue: !0
+      }), this.__attributeObserver = g;
+    }
+    // initializes the state from the attributes
+    _initializeStateFromAttributes() {
+      this.getAttributeNames().forEach((g) => {
+        const w = this.getAttribute(g);
+        this._handleAttributeChange(g, w);
+      });
+    }
+    // Invoked when attributes are changed.
+    _handleAttributeChange(g, w) {
+      var A;
+      if (g) {
+        const y = "this.state.";
+        g.startsWith(y) && (g = g.slice(y.length));
+      }
+      const S = N(A = R, E, ft).call(A, w);
+      this.state[g] = S;
+    }
+    // Setup two-way data bindings for input elements with $bind
+    _setupTwoWayBindings() {
+      _(this, i).forEach(
+        ({ element: g, path: w, raw: S, isContentEditable: A, initialValue: y }) => {
+          var L, M;
+          if (this._getNestedValue(w) === void 0) {
+            const x = y || "";
+            K(this.state, w, x);
+          }
+          if (A) {
+            const x = g;
+            x.textContent = (L = this._getNestedValue(w)) != null ? L : "";
+            const k = (X) => {
+              const O = X.target.textContent || "";
+              K(this.state, w, O);
+            };
+            x.addEventListener("input", k);
+            const V = () => {
+              x.removeEventListener("input", k);
+            };
+            _(this, m).push(V);
+          } else {
+            const x = g, k = x instanceof HTMLInputElement && x.type === "checkbox";
+            x instanceof HTMLInputElement && x.type, k ? x.checked = !!this._getNestedValue(w) : x.value = (M = this._getNestedValue(w)) != null ? M : "";
+            const V = (q) => {
+              const O = q.target;
+              let P;
+              O instanceof HTMLInputElement && O.type === "checkbox" ? P = O.checked : (O instanceof HTMLInputElement && O.type, P = O.value), K(this.state, w, P);
+            };
+            x.addEventListener("input", V);
+            const X = () => {
+              x.removeEventListener("input", V);
+            };
+            if (_(this, m).push(X), x instanceof HTMLSelectElement || x instanceof HTMLInputElement && ["checkbox", "radio", "file"].includes(x.type)) {
+              x.addEventListener("change", V);
+              const q = () => {
+                x.removeEventListener("change", V);
+              };
+              _(this, m).push(q);
+            }
+          }
+        }
+      );
+    }
+    // Helper to get nested value from state
+    _getNestedValue(g) {
+      return g.reduce((w, S) => w == null ? void 0 : w[S], this.state);
+    }
+  };
+  f = new WeakMap(), i = new WeakMap(), d = new WeakMap(), a = new WeakMap(), m = new WeakMap(), b = 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
+   */
+  I = function(g, w) {
+    if (g === null || typeof g != "object" || g instanceof HTMLElement || g instanceof Node)
+      return g;
+    if (_(this, p).has(g))
+      return _(this, p).get(g);
+    const S = new Proxy(g, {
+      get: (A, y) => {
+        const v = A[y];
+        if (Array.isArray(A) && typeof v == "function" && [
+          "push",
+          "pop",
+          "shift",
+          "unshift",
+          "splice",
+          "sort",
+          "reverse"
+        ].includes(y))
+          return (...M) => {
+            const x = M.map(
+              (V) => V !== null && typeof V == "object" ? N(this, h, I).call(this, V, w) : V
+            ), k = v.apply(A, x);
+            return w(), k;
+          };
+        if (v !== null && typeof v == "object") {
+          if (_(this, p).has(v))
+            return _(this, p).get(v);
+          const L = N(this, h, I).call(this, v, w);
+          return A[y] = L, L;
+        }
+        return v;
+      },
+      set: (A, y, v) => {
+        const L = A[y];
+        return Object.is(L, v) || (v !== null && typeof v == "object" ? A[y] = N(this, h, I).call(this, v, w) : A[y] = v, w()), !0;
+      }
+    });
+    return _(this, p).set(g, S), S;
+  }, E = new WeakSet(), ft = function(g) {
+    if (g === null || g === "") return null;
+    if (g !== "undefined")
+      try {
+        return JSON.parse(g);
+      } catch (w) {
+        return g;
+      }
+  }, // Update two-way bound elements when state changes
+  ht = function() {
+    _(this, i).forEach(({ element: g, path: w, isContentEditable: S }) => {
+      const A = this._getNestedValue(w);
+      if (S) {
+        const y = g;
+        y.textContent !== A && (y.textContent = A != null ? A : "");
+      } else {
+        const y = g;
+        if (y instanceof HTMLInputElement && y.type === "checkbox") {
+          const v = !!A;
+          y.checked !== v && (y.checked = v);
+        } else
+          y.value !== A && (y.value = A != null ? A : "");
+      }
+    });
+  }, F(R, E);
+  let u = R;
+  customElements.get(e) || (customElements.define(e, u), G.log(`Web component defined: <${e}></${e}>`));
+};
+export {
+  Xt as defineWebComponent
+};
+//# sourceMappingURL=webcomponent-WCW6485Z.mjs.map