ladrillosjs 2.0.0-beta.2 → 2.0.0-beta.2.1

package/dist/webcomponent-G5lefoR-.mjs

@@ -0,0 +1,1016 @@
+var lt = Object.defineProperty, ut = Object.defineProperties;
+var dt = Object.getOwnPropertyDescriptors;
+var X = Object.getOwnPropertySymbols;
+var ft = Object.prototype.hasOwnProperty, ht = Object.prototype.propertyIsEnumerable;
+var G = (t) => {
+  throw TypeError(t);
+};
+var J = (t, e, s) => e in t ? lt(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s, k = (t, e) => {
+  for (var s in e || (e = {}))
+    ft.call(e, s) && J(t, s, e[s]);
+  if (X)
+    for (var s of X(e))
+      ht.call(e, s) && J(t, s, e[s]);
+  return t;
+}, K = (t, e) => ut(t, dt(e));
+var P = (t, e, s) => e.has(t) || G("Cannot " + s);
+var A = (t, e, s) => (P(t, e, "read from private field"), s ? s.call(t) : e.get(t)), _ = (t, e, s) => e.has(t) ? G("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, s), B = (t, e, s, n) => (P(t, e, "write to private field"), n ? n.call(t, s) : e.set(t, s), s), O = (t, e, s) => (P(t, e, "access private method"), s);
+var I = (t, e, s) => new Promise((n, r) => {
+  var a = (d) => {
+    try {
+      c(s.next(d));
+    } catch (l) {
+      r(l);
+    }
+  }, o = (d) => {
+    try {
+      c(s.throw(d));
+    } catch (l) {
+      r(l);
+    }
+  }, c = (d) => d.done ? n(d.value) : Promise.resolve(d.value).then(a, o);
+  c((s = s.apply(t, e)).next());
+});
+import { R as Q, e as pt, l as mt } from "./index-BvTcGGey.mjs";
+const bt = (t, e, s) => {
+  if (!e) return;
+  const n = document.createElement("style");
+  n.textContent = e, s ? t.appendChild(n) : document.head.appendChild(n);
+}, gt = (t, e) => {
+  t.innerHTML = e;
+  const s = Et(t), n = $t(t), r = wt(t), a = vt(t);
+  return { bindings: s, twoWayBindings: n, conditionals: r, loops: a };
+}, Y = (t) => {
+  const e = [], s = t.match(/\((.*)\)/);
+  if (!s) return e;
+  const n = s[1].trim();
+  return n && n.split(",").map((a) => a.trim()).forEach((a) => {
+    if (/^['"]/.test(a) || /^\d+/.test(a)) return;
+    const o = a.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)/);
+    o && e.push(o[1]);
+  }), e;
+}, Et = (t) => {
+  const e = document.createTreeWalker(t, NodeFilter.SHOW_TEXT, null), s = [];
+  let n;
+  const r = (o) => {
+    let c = o.parentElement;
+    for (; c; ) {
+      if (c.hasAttribute && c.hasAttribute("$for"))
+        return !0;
+      c = c.parentElement;
+    }
+    return !1;
+  };
+  for (; n = e.nextNode(); ) {
+    if (r(n))
+      continue;
+    const o = [...n.textContent.matchAll(Q.bindings)];
+    if (o.length > 0) {
+      const c = n.textContent, d = o.map((l) => {
+        const i = l[1].trim(), u = i.includes("(") && i.includes(")"), p = /[+*/%<>=!&|]/.test(i) || // Math or logical operators (excluding hyphen)
+        /\s-\s/.test(i) || /\.(?![\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), w = u ? [i.split("(")[0].trim()] : i.split(".").map((b) => b.trim()), m = u ? Y(i) : [];
+        return { raw: i, path: w, isFunction: u, isExpression: p, functionArgs: m };
+      });
+      s.push({ node: n, bindings: d, original: c });
+    }
+  }
+  return t.querySelectorAll("*").forEach((o) => {
+    if (!(o.hasAttribute("$for") || r(o)))
+      for (const c of o.attributes) {
+        if (c.name === "$if" || c.name === "$else-if" || c.name === "$else" || c.name === "$bind")
+          continue;
+        const d = [...c.value.matchAll(Q.bindings)];
+        if (d.length > 0) {
+          const l = c.value, i = d.map((u) => {
+            const f = u[1].trim(), p = f.includes("(") && f.includes(")"), m = /[+*/%<>=!&|]/.test(f) || // Math or logical operators (excluding hyphen)
+            /\s-\s/.test(f) || /\.(?![\s}])[a-zA-Z_$][\w]*\(/.test(f) || // Method calls like name.toLowerCase()
+            /\bnew\s+/.test(f) || // Object instantiation like new Date()
+            /\b(typeof|instanceof|void|delete)\b/.test(f), b = p ? [f.split("(")[0].trim()] : f.split(".").map((T) => T.trim()), L = p ? Y(f) : [];
+            return { raw: f, path: b, isFunction: p, isExpression: m, functionArgs: L };
+          });
+          s.push({
+            node: o,
+            bindings: i,
+            original: l,
+            isAttribute: !0,
+            attributeName: c.name
+          });
+        }
+      }
+  }), s;
+}, $t = (t) => {
+  const e = [];
+  return t.querySelectorAll("[\\$bind]").forEach((n) => {
+    var c;
+    const r = n.getAttribute("$bind");
+    if (!r) return;
+    const a = r.trim(), o = a.split(".").map((d) => d.trim());
+    n instanceof HTMLInputElement || n instanceof HTMLTextAreaElement || n instanceof HTMLSelectElement ? (e.push({
+      element: n,
+      path: o,
+      raw: a,
+      isContentEditable: !1,
+      initialValue: n.value || ""
+    }), n.removeAttribute("$bind")) : n instanceof HTMLElement && n.hasAttribute("contenteditable") && (e.push({
+      element: n,
+      path: o,
+      raw: a,
+      isContentEditable: !0,
+      initialValue: ((c = n.textContent) == null ? void 0 : c.trim()) || ""
+    }), n.removeAttribute("$bind"));
+  }), e;
+}, wt = (t) => {
+  const e = [], s = /* @__PURE__ */ new Set();
+  return t.querySelectorAll("[\\$if]").forEach((r) => {
+    if (s.has(r)) return;
+    const a = [];
+    let o = r;
+    for (; o; ) {
+      const c = o.hasAttribute("$if"), d = o.hasAttribute("$else-if"), l = o.hasAttribute("$else");
+      if (!c && !d && !l) break;
+      s.add(o);
+      let i, u = "";
+      c ? (i = "if", u = o.getAttribute("$if") || "", o.removeAttribute("$if")) : d ? (i = "else-if", u = o.getAttribute("$else-if") || "", o.removeAttribute("$else-if")) : (i = "else", o.removeAttribute("$else"));
+      const f = document.createComment(
+        `conditional:${i}:${u}`
+      ), p = o.parentElement || t, w = o.nextSibling;
+      p.insertBefore(f, o);
+      const m = {
+        element: o,
+        condition: u.trim(),
+        type: i,
+        placeholder: f,
+        group: [],
+        // Will be set after the group is complete
+        originalParent: p,
+        nextSibling: w
+      };
+      a.push(m);
+      const b = o.nextElementSibling;
+      if (o.remove(), o = b, b && !b.hasAttribute("$else-if") && !b.hasAttribute("$else"))
+        break;
+    }
+    a.forEach((c) => {
+      c.group = a;
+    }), e.push(a);
+  }), e;
+}, yt = (t) => {
+  const e = /* @__PURE__ */ new Set();
+  return t.forEach((s) => {
+    s.forEach((n) => {
+      let r = n.condition;
+      r = r.replace(/\{([^}]+)\}/g, "$1");
+      const a = /\b([a-zA-Z_$][a-zA-Z0-9_$]*(?:\.[a-zA-Z_$][a-zA-Z0-9_$]*)*)\b/g, o = /* @__PURE__ */ new Set([
+        "true",
+        "false",
+        "null",
+        "undefined",
+        "typeof",
+        "instanceof",
+        "new",
+        "return",
+        "if",
+        "else",
+        "for",
+        "while",
+        "do",
+        "switch",
+        "case",
+        "break",
+        "continue"
+      ]);
+      let c;
+      for (; (c = a.exec(r)) !== null; ) {
+        const l = c[1].split(".")[0];
+        o.has(l) || e.add(l);
+      }
+    });
+  }), e;
+}, vt = (t) => {
+  const e = [];
+  return t.querySelectorAll("[\\$for]").forEach((n) => {
+    var p;
+    const r = n.getAttribute("$for");
+    if (!r) return;
+    const a = n.getAttribute("$key") || void 0, o = r.match(
+      /^\s*(?:\(([^,]+),\s*([^)]+)\)|([^\s]+))\s+(?:in|of)\s+(.+)\s*$/
+    );
+    if (!o) {
+      console.error(`Invalid $for expression: "${r}"`);
+      return;
+    }
+    const c = (o[1] || o[3]).trim(), d = (p = o[2]) == null ? void 0 : p.trim(), l = o[4].trim(), i = document.createComment(`loop:${r}`), u = n.parentElement || t;
+    u.insertBefore(i, n), n.removeAttribute("$for"), a && n.removeAttribute("$key"), n.remove();
+    const f = {
+      template: n,
+      expression: r,
+      itemName: c,
+      indexName: d,
+      arrayName: l,
+      keyAttribute: a,
+      placeholder: i,
+      renderedElements: [],
+      originalParent: u
+    };
+    e.push(f);
+  }), e;
+}, At = (t) => {
+  const e = /* @__PURE__ */ new Set();
+  return t.forEach((s) => {
+    const n = s.arrayName.split(".")[0];
+    e.add(n);
+  }), e;
+}, N = /* @__PURE__ */ new Map(), xt = 100, Z = (t) => {
+  const e = N.get(t);
+  if (e)
+    return N.delete(t), N.set(t, e), e;
+  const s = new Function(
+    "component",
+    `
+    const { Date, Array, Math, String, Number, Boolean, Object, JSON, RegExp } = globalThis;
+    with(component) { 
+      return ${t}; 
+    }
+    `
+  );
+  if (N.size >= xt) {
+    const n = N.keys().next().value;
+    n && N.delete(n);
+  }
+  return N.set(t, s), s;
+}, q = (t, e) => e.reduce((s, n) => {
+  if (!(s == null || typeof s != "object"))
+    return s[n];
+}, t), U = (t, e, s) => {
+  if (e.length === 0) return;
+  const n = e[e.length - 1], r = e.slice(0, -1);
+  let a = t;
+  for (const o of r)
+    (a[o] === void 0 || a[o] === null) && (a[o] = {}), a = a[o];
+  a[n] = s;
+}, tt = (t, e, s) => {
+  for (const n of t) {
+    let r = n.original, a;
+    for (const { raw: o, path: c, isFunction: d, isExpression: l } of n.bindings) {
+      let i;
+      if (l || d)
+        try {
+          const f = Z(o), p = typeof e == "object" && e !== null ? k(k({}, e), s || {}) : s || {};
+          i = f(p);
+        } catch (f) {
+          console.error(`Error executing expression binding {${o}}:`, f), i = void 0;
+        }
+      else
+        i = q(e, c);
+      if (i === void 0) continue;
+      const u = String(i != null ? i : "");
+      a = i, r = r.replace(`{${o}}`, u);
+    }
+    if (n.node.nodeType === Node.TEXT_NODE) {
+      const o = n.node, c = o.parentElement, d = r.trim().startsWith("<") && r.includes(">");
+      c && d ? c.innerHTML = r : o.textContent = r;
+    } else {
+      const o = n.node;
+      n.isAttribute && n.attributeName && ([
+        "disabled",
+        "checked",
+        "readonly",
+        "required",
+        "selected",
+        "hidden",
+        "open",
+        "autofocus",
+        "autoplay",
+        "controls",
+        "loop",
+        "muted"
+      ].includes(n.attributeName.toLowerCase()) ? (typeof a == "boolean" ? a : a === "true" || a === "True") ? o.setAttribute(n.attributeName, "") : o.removeAttribute(n.attributeName) : o.setAttribute(n.attributeName, r));
+    }
+  }
+}, St = (t, e, s) => {
+  if (!t) return !0;
+  let n = t.trim();
+  n = n.replace(/\{([^}]+)\}/g, "$1");
+  try {
+    return new Function(
+      "context",
+      "component",
+      `
+      with (context) {
+        try {
+          return Boolean(${n});
+        } catch (e) {
+          return false;
+        }
+      }
+    `
+    )(e, s);
+  } catch (r) {
+    return console.error(`Error evaluating condition "${t}":`, r), !1;
+  }
+}, st = (t, e) => {
+  const s = [
+    "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"
+  ];
+  [t, ...t.querySelectorAll("*")].forEach((r) => {
+    s.forEach((a) => {
+      const o = `on${a}`, c = r.getAttribute(o);
+      if (c) {
+        const d = `__processed_${o}`;
+        if (r[d]) return;
+        r.removeAttribute(o), r.addEventListener(
+          a,
+          function(l) {
+            try {
+              new Function(
+                "event",
+                "component",
+                `
+                with(component) {
+                  ${c}
+                }
+              `
+              ).call(this, l, e);
+            } catch (i) {
+              console.error(
+                `Error executing ${a} handler:`,
+                i,
+                c
+              );
+            }
+          }
+        ), r[d] = !0;
+      }
+    });
+  });
+}, et = (t, e, s) => {
+  var n;
+  for (const r of t) {
+    let a = !1;
+    for (const o of r) {
+      const { element: c, condition: d, type: l, placeholder: i, originalParent: u } = o;
+      let f = !1;
+      l === "else" ? f = !a : a || (f = St(d, e, s), f && (a = !0));
+      const p = c.parentNode !== null;
+      f && !p ? ((n = i.parentNode) == null || n.insertBefore(c, i.nextSibling), s && st(c, s)) : !f && p && c.remove();
+    }
+  }
+}, nt = (t, e, s) => {
+  for (const n of t) {
+    const {
+      template: r,
+      itemName: a,
+      indexName: o,
+      arrayName: c,
+      placeholder: d,
+      renderedElements: l
+    } = n, i = q(e, c.split("."));
+    if (i !== void 0 && !Array.isArray(i)) {
+      console.warn(`$for: "${c}" is not an array, got:`, i), l.forEach((u) => u.remove()), l.length = 0;
+      return;
+    }
+    if (!i)
+      return;
+    l.forEach((u) => u.remove()), l.length = 0, i.forEach((u, f) => {
+      var b;
+      const p = r.cloneNode(!0), w = K(k({}, e), {
+        [a]: u
+      });
+      o && (w[o] = f), _t(p, w, s);
+      const m = l.length > 0 ? l[l.length - 1] : d;
+      (b = m.parentNode) == null || b.insertBefore(p, m.nextSibling), l.push(p), s && st(p, s);
+    });
+  }
+}, _t = (t, e, s) => {
+  const n = document.createTreeWalker(t, NodeFilter.SHOW_TEXT, null);
+  let r;
+  for (; r = n.nextNode(); )
+    if (r.textContent && r.textContent.includes("{")) {
+      let o = r.textContent;
+      [...r.textContent.matchAll(/\{([^}]+)\}/g)].forEach((d) => {
+        const l = d[1].trim(), i = l.includes("(") && l.includes(")"), f = /[+*/%<>=!&|]/.test(l) || /\s-\s/.test(l) || /\.(?![\s}])[a-zA-Z_$][\w]*\(/.test(l) || // Method calls
+        /\bnew\s+/.test(l) || // Object instantiation like new Date()
+        /\b(typeof|instanceof|void|delete)\b/.test(l);
+        let p;
+        if (f || i)
+          try {
+            const w = Z(l), m = typeof e == "object" && e !== null ? k(k({}, e), s || {}) : s || {};
+            p = w(m);
+          } catch (w) {
+            console.error(
+              `Error executing expression in loop {${l}}:`,
+              w
+            ), p = void 0;
+          }
+        else {
+          const w = l.split(".").map((m) => m.trim());
+          p = q(e, w);
+        }
+        p !== void 0 && (o = o.replace(`{${l}}`, String(p != null ? p : "")));
+      }), r.textContent = o;
+    }
+  [t, ...t.querySelectorAll("*")].forEach((o) => {
+    Array.from(o.attributes).forEach((c) => {
+      if (c.value.includes("{")) {
+        let d = c.value;
+        [...c.value.matchAll(/\{([^}]+)\}/g)].forEach((i) => {
+          const u = i[1].trim(), f = u.includes("(") && u.includes(")"), w = /[+*/%<>=!&|]/.test(u) || /\s-\s/.test(u) || /\.(?![\s}])[a-zA-Z_$][\w]*\(/.test(u) || // Method calls
+          /\bnew\s+/.test(u) || // Object instantiation like new Date()
+          /\b(typeof|instanceof|void|delete)\b/.test(u);
+          let m;
+          if (w || f)
+            try {
+              const b = Z(u), L = typeof e == "object" && e !== null ? k(k({}, e), s || {}) : s || {};
+              m = b(L);
+            } catch (b) {
+              console.error(
+                `Error executing expression in loop attribute {${u}}:`,
+                b
+              ), m = void 0;
+            }
+          else {
+            const b = u.split(".").map((L) => L.trim());
+            m = q(e, b);
+          }
+          m !== void 0 && (d = d.replace(`{${u}}`, String(m != null ? m : "")));
+        }), o.setAttribute(c.name, d);
+      }
+    });
+  });
+}, ot = (t) => t instanceof ShadowRoot ? t.host : t, Ct = (t, e) => {
+  const s = /* @__PURE__ */ new Set();
+  e.forEach(({ path: r }) => {
+    const a = r[0];
+    s.add(a);
+  });
+  const n = [];
+  return s.forEach((r) => {
+    n.push(`
+      if (!Object.getOwnPropertyDescriptor(component, '${r}')) {
+        Object.defineProperty(component, '${r}', {
+          get() { return this.state.${r}; },
+          set(val) { this.state.${r} = val; },
+          enumerable: true,
+          configurable: true
+        });
+      }
+    `);
+  }), {
+    injectedCode: "",
+    // No longer needed in script scope
+    componentInjections: n.join(`
+`),
+    bindVarNames: s
+  };
+}, Tt = (t, e, s = /* @__PURE__ */ new Set()) => {
+  const n = [], r = /* @__PURE__ */ new Set();
+  e.forEach((c) => {
+    c.bindings.forEach((d) => {
+      const l = d.path[0];
+      r.add(l), d.isFunction && d.functionArgs && d.functionArgs.forEach((i) => {
+        r.add(i);
+      });
+    });
+  }), s.forEach((c) => {
+    r.add(c);
+  });
+  const a = /(?:const|let|var)\s+(\w+)\s*=\s*([^;]+);?/g;
+  let o;
+  for (; (o = a.exec(t)) !== null; ) {
+    const c = o[1];
+    r.has(c) && n.push(`component.state.${c} = ${c};`);
+  }
+  return { stateBindings: n, boundVarNames: r };
+}, kt = (t, e) => {
+  if (e.size === 0) return t;
+  let s = t;
+  return e.forEach((n) => {
+    const r = new RegExp(
+      `\\b${n}((?:\\[[^\\]]+\\])(?:\\.[\\w]+|\\[[^\\]]+\\])*)\\s*([=+\\-*/%&|^]|\\+\\+|\\-\\-)`,
+      "g"
+    );
+    s = s.replace(
+      r,
+      `component.state.${n}$1 $2`
+    );
+    const a = new RegExp(
+      `(?<!component\\.state\\.)\\b${n}((?:\\[[^\\]]+\\])(?:\\.[\\w]+|\\[[^\\]]+\\])*)(?![=+\\-*/%&|^]|\\+\\+|\\-\\-)`,
+      "g"
+    );
+    s = s.replace(
+      a,
+      `component.state.${n}$1`
+    );
+    const o = new RegExp(
+      `\\b${n}\\.(\\w+(?:\\.\\w+)*)\\s*([=+\\-*/%&|^]|\\+\\+|\\-\\-)`,
+      "g"
+    );
+    s = s.replace(
+      o,
+      `component.state.${n}.$1 $2`
+    );
+    const c = new RegExp(
+      `(?<!component\\.state\\.)(?<!const\\s${n}\\s*=\\s*{[^}]*)\\b${n}\\.(\\w+(?:\\.\\w+)*)(?![=+\\-*/%&|^]|\\+\\+|\\-\\-)`,
+      "g"
+    );
+    s = s.replace(
+      c,
+      `component.state.${n}.$1`
+    );
+    const d = new RegExp(
+      `(?<!\\.)\\b(\\+\\+|\\-\\-)${n}\\b|\\b${n}(\\+\\+|\\-\\-)`,
+      "g"
+    );
+    s = s.replace(d, (u) => {
+      if (u.startsWith("++") || u.startsWith("--"))
+        return `${u.substring(0, 2)}component.state.${n}`;
+      {
+        const f = u.substring(u.length - 2);
+        return `component.state.${n}${f}`;
+      }
+    });
+    const l = new RegExp(
+      `(?<!\\.)\\b${n}\\s*(\\+=|\\-=|\\*=|\\/=|%=|\\*\\*=|<<=|>>=|>>>=|&=|\\|=|\\^=)`,
+      "g"
+    );
+    s = s.replace(
+      l,
+      `component.state.${n}$1`
+    );
+    const i = new RegExp(
+      `(?<!const\\s)(?<!let\\s)(?<!var\\s)(?<!\\.)\\b${n}\\s*=\\s*([^=])`,
+      "g"
+    );
+    s = s.replace(
+      i,
+      `component.state.${n} = $1`
+    );
+  }), s;
+}, rt = (t, e, s, n, r, a = /* @__PURE__ */ new Set()) => {
+  try {
+    const { injectedCode: o, componentInjections: c, bindVarNames: d } = Ct(t, s), l = /function\s+(\w+)|const\s+(\w+)\s*=\s*(?:\([^)]*\)|[\w\s]*)\s*=>/g, i = [];
+    let u;
+    for (; (u = l.exec(t)) !== null; ) {
+      const R = u[1] || u[2];
+      R && i.push(R);
+    }
+    const f = i.map(
+      (R) => `component.${R} = typeof ${R} !== 'undefined' ? ${R}.bind(component) : undefined;`
+    ).join(`
+            `), { stateBindings: p, boundVarNames: w } = Tt(
+      t,
+      e,
+      a
+    ), m = /* @__PURE__ */ new Set([...w, ...d]), b = p.join(`
+            `), L = kt(
+      t,
+      m
+    ), T = `
+      (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
+        ${c}
+        
+        // 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) {
+          ${L}
+          
+          // Auto-bind variables to component state (e.g., const name = "value" → this.state.name = "value")
+          ${b}
+          
+          // Auto-attach all detected functions to component for onclick access
+          ${f}
+        }
+      }).call(arguments[0], arguments[0], arguments[1], arguments[2])
+    `;
+    new Function(T)(r, n, pt);
+  } catch (o) {
+    console.error("Script execution failed:", o);
+  }
+}, it = (t, 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"
+  ].forEach((n) => {
+    const r = `on${n}`;
+    (t instanceof ShadowRoot ? t.querySelectorAll(`[${r}]`) : e.querySelectorAll(`[${r}]`)).forEach((o) => {
+      const c = `${r}`;
+      if (o[`__processed_${c}`]) return;
+      const d = o.getAttribute(r);
+      d && (o.removeAttribute(r), o.addEventListener(
+        n,
+        function(l) {
+          new Function(
+            "event",
+            "component",
+            `
+            with(component) {
+              ${d}
+            }
+          `
+          ).call(this, l, e);
+        }
+      ), o[`__processed_${c}`] = !0);
+    });
+  });
+}, Lt = (a, o, c, ...d) => I(null, [a, o, c, ...d], function* (t, e, s, n = [], r = /* @__PURE__ */ new Set()) {
+  if (!(e != null && e.length)) return;
+  const l = ot(t);
+  for (const i of e)
+    i.content && rt(
+      i.content,
+      s,
+      n,
+      t,
+      l,
+      r
+    );
+  it(t, l);
+}), Nt = (t, e) => new Promise((s, n) => {
+  const r = document.querySelector(
+    `script[src="${t}"]`
+  );
+  if (r) {
+    if (r.dataset.loaded === "true") {
+      s();
+      return;
+    }
+    r.addEventListener("load", () => s(), { once: !0 }), r.addEventListener(
+      "error",
+      () => n(new Error(`Failed to load external script: ${t}`)),
+      { once: !0 }
+    );
+    return;
+  }
+  const a = document.createElement("script");
+  a.src = t, e && (a.type = e), a.onload = () => {
+    a.dataset.loaded = "true", s();
+  }, a.onerror = () => n(new Error(`Failed to load external script: ${t}`)), document.head.appendChild(a);
+}), Rt = (o, c, d, ...l) => I(null, [o, c, d, ...l], function* (t, e, s, n = [], r = /* @__PURE__ */ new Set(), a) {
+  var u;
+  const i = ot(t);
+  for (const f of e) {
+    let p;
+    a ? a.startsWith("http://") || a.startsWith("https://") ? p = a : p = new URL(
+      a,
+      window.location.href
+    ).href : p = window.location.href;
+    const w = new URL(f.src, p).href;
+    if (f.external)
+      yield Nt(w, f.type);
+    else if (f.type === "module") {
+      const m = i.tagName.toLowerCase();
+      window.__ladrilloContexts || (window.__ladrilloContexts = /* @__PURE__ */ new Map()), window.__ladrilloContexts.set(m, {
+        host: t,
+        shadowRoot: t instanceof ShadowRoot ? t : null,
+        element: i,
+        state: i.state,
+        setState: (u = i.setState) == null ? void 0 : u.bind(i)
+      });
+      const b = document.createElement("script");
+      b.type = "module", b.src = w, b.setAttribute("data-component", m), document.head.appendChild(b);
+    } else
+      yield fetch(w).then((m) => {
+        if (!m.ok)
+          throw new Error(`HTTP ${m.status}: ${m.statusText}`);
+        const b = m.headers.get("content-type");
+        if (b && !b.includes("javascript") && !b.includes("text/plain"))
+          throw new Error(`Expected JavaScript but got ${b}`);
+        return m.text();
+      }).then((m) => {
+        rt(
+          m,
+          s,
+          n,
+          t,
+          i,
+          r
+        );
+      }).catch((m) => {
+        console.error(`Failed to load external script: ${f.src}`, m);
+      });
+  }
+  it(t, i);
+}), Mt = (t, e) => {
+  var l, i, u, f, p, w, m, b, D, T, ct, at;
+  const { tagName: s, template: n, scripts: r, externalScripts: a, styles: o, sourcePath: c } = t, F = class F extends HTMLElement {
+    constructor() {
+      super();
+      _(this, b);
+      _(this, l, []);
+      _(this, i, []);
+      _(this, u, []);
+      _(this, f, []);
+      _(this, p, []);
+      _(this, w, c);
+      _(this, m, /* @__PURE__ */ new WeakMap());
+      e && this.attachShadow({ mode: "open" });
+      const h = {}, E = () => {
+        tt(A(this, l), this.state, this), et(A(this, u), this.state, this), nt(A(this, f), this.state, this), O(this, b, at).call(this);
+      };
+      this.state = new Proxy(h, {
+        get: (y, g) => y[g],
+        set: (y, g, $) => {
+          const x = y[g];
+          return Object.is(x, $) || ($ !== null && typeof $ == "object" ? y[g] = O(this, b, D).call(this, $, E) : y[g] = $, Object.getOwnPropertyDescriptor(this, g) || Object.defineProperty(this, g, {
+            get() {
+              return this.state[g];
+            },
+            set(S) {
+              this.state[g] = S;
+            },
+            enumerable: !0,
+            configurable: !0
+          }), E()), !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(h) {
+      Object.assign(this.state, h);
+    }
+    // Invoked when element is added to the DOM
+    connectedCallback() {
+      return I(this, null, function* () {
+        const h = e ? this.shadowRoot : this, { bindings: E, twoWayBindings: y, conditionals: g, loops: $ } = gt(
+          h,
+          n
+        );
+        B(this, l, E), B(this, i, y), B(this, u, g), B(this, f, $);
+        const x = yt(g), S = At($);
+        bt(h, o, e), this._initializeStateFromAttributes(), this._setupTwoWayBindings(), yield Rt(
+          h,
+          a,
+          A(this, l),
+          A(this, i),
+          /* @__PURE__ */ new Set([...x, ...S]),
+          A(this, w)
+        ), yield Lt(
+          h,
+          r,
+          A(this, l),
+          A(this, i),
+          /* @__PURE__ */ new Set([...x, ...S])
+        ), tt(A(this, l), this.state, this), et(A(this, u), this.state, this), nt(A(this, f), this.state, this), this._setupAttributeObserver();
+      });
+    }
+    // Invoked when element is removed from the DOM
+    disconnectedCallback() {
+      this.__attributeObserver && (this.__attributeObserver.disconnect(), this.__attributeObserver = null), A(this, p).forEach((E) => {
+        try {
+          E();
+        } catch (y) {
+          console.error("Error cleaning up two-way binding:", y);
+        }
+      }), B(this, p, []);
+      const h = this.__eventUnsubscribers;
+      h && Array.isArray(h) && (h.forEach((E) => {
+        try {
+          E();
+        } catch (y) {
+          console.error("Error unsubscribing from event:", y);
+        }
+      }), this.__eventUnsubscribers = []);
+    }
+    // Set up observer to watch for attribute changes
+    _setupAttributeObserver() {
+      const h = new MutationObserver((E) => {
+        E.forEach((y) => {
+          if (y.type === "attributes" && y.attributeName) {
+            const g = this.getAttribute(y.attributeName);
+            this._handleAttributeChange(y.attributeName, g);
+          }
+        });
+      });
+      h.observe(this, {
+        attributes: !0,
+        attributeOldValue: !0
+      }), this.__attributeObserver = h;
+    }
+    // initializes the state from the attributes
+    _initializeStateFromAttributes() {
+      this.getAttributeNames().forEach((h) => {
+        const E = this.getAttribute(h);
+        this._handleAttributeChange(h, E);
+      });
+    }
+    // Invoked when attributes are changed.
+    _handleAttributeChange(h, E) {
+      var g;
+      if (h) {
+        const $ = "this.state.";
+        h.startsWith($) && (h = h.slice($.length));
+      }
+      const y = O(g = F, T, ct).call(g, E);
+      this.state[h] = y;
+    }
+    // Setup two-way data bindings for input elements with $bind
+    _setupTwoWayBindings() {
+      A(this, i).forEach(
+        ({ element: h, path: E, raw: y, isContentEditable: g, initialValue: $ }) => {
+          var S, M;
+          if (this._getNestedValue(E) === void 0) {
+            const v = $ || "";
+            U(this.state, E, v);
+          }
+          if (g) {
+            const v = h;
+            v.textContent = (S = this._getNestedValue(E)) != null ? S : "";
+            const W = (z) => {
+              const C = z.target.textContent || "";
+              U(this.state, E, C);
+            };
+            v.addEventListener("input", W);
+            const V = () => {
+              v.removeEventListener("input", W);
+            };
+            A(this, p).push(V);
+          } else {
+            const v = h, W = v instanceof HTMLInputElement && v.type === "checkbox";
+            v instanceof HTMLInputElement && v.type, W ? v.checked = !!this._getNestedValue(E) : v.value = (M = this._getNestedValue(E)) != null ? M : "";
+            const V = (H) => {
+              const C = H.target;
+              let j;
+              C instanceof HTMLInputElement && C.type === "checkbox" ? j = C.checked : (C instanceof HTMLInputElement && C.type, j = C.value), U(this.state, E, j);
+            };
+            v.addEventListener("input", V);
+            const z = () => {
+              v.removeEventListener("input", V);
+            };
+            if (A(this, p).push(z), v instanceof HTMLSelectElement || v instanceof HTMLInputElement && ["checkbox", "radio", "file"].includes(v.type)) {
+              v.addEventListener("change", V);
+              const H = () => {
+                v.removeEventListener("change", V);
+              };
+              A(this, p).push(H);
+            }
+          }
+        }
+      );
+    }
+    // Helper to get nested value from state
+    _getNestedValue(h) {
+      return h.reduce((E, y) => E == null ? void 0 : E[y], this.state);
+    }
+  };
+  l = new WeakMap(), i = new WeakMap(), u = new WeakMap(), f = new WeakMap(), p = new WeakMap(), w = new WeakMap(), m = new WeakMap(), b = 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
+   */
+  D = function(h, E) {
+    if (h === null || typeof h != "object" || h instanceof HTMLElement || h instanceof Node)
+      return h;
+    if (A(this, m).has(h))
+      return A(this, m).get(h);
+    const y = new Proxy(h, {
+      get: (g, $) => {
+        const x = g[$];
+        return Array.isArray(g) && typeof x == "function" && [
+          "push",
+          "pop",
+          "shift",
+          "unshift",
+          "splice",
+          "sort",
+          "reverse"
+        ].includes($) ? (...M) => {
+          const v = x.apply(g, M);
+          return E(), v;
+        } : x !== null && typeof x == "object" ? O(this, b, D).call(this, x, E) : x;
+      },
+      set: (g, $, x) => {
+        const S = g[$];
+        return Object.is(S, x) || (g[$] = x, E()), !0;
+      }
+    });
+    return A(this, m).set(h, y), y;
+  }, T = new WeakSet(), ct = function(h) {
+    if (h === null || h === "") return null;
+    if (h !== "undefined")
+      try {
+        return JSON.parse(h);
+      } catch (E) {
+        return h;
+      }
+  }, // Update two-way bound elements when state changes
+  at = function() {
+    A(this, i).forEach(({ element: h, path: E, isContentEditable: y }) => {
+      const g = this._getNestedValue(E);
+      if (y) {
+        const $ = h;
+        $.textContent !== g && ($.textContent = g != null ? g : "");
+      } else {
+        const $ = h;
+        if ($ instanceof HTMLInputElement && $.type === "checkbox") {
+          const x = !!g;
+          $.checked !== x && ($.checked = x);
+        } else
+          $.value !== g && ($.value = g != null ? g : "");
+      }
+    });
+  }, _(F, T);
+  let d = F;
+  customElements.define(s, d), mt.log(`Web component defined: <${s}></${s}>`);
+};
+export {
+  Mt as defineWebComponent
+};
+//# sourceMappingURL=webcomponent-G5lefoR-.mjs.map