ladrillosjs 1.0.2 → 2.0.0-beta.1

package/dist/webcomponent-CJ3lZBZb.mjs

@@ -0,0 +1,703 @@
+var j = (t) => {
+  throw TypeError(t);
+};
+var k = (t, s, n) => s.has(t) || j("Cannot " + n);
+var E = (t, s, n) => (k(t, s, "read from private field"), n ? n.call(t) : s.get(t)), A = (t, s, n) => s.has(t) ? j("Cannot add the same private member more than once") : s instanceof WeakSet ? s.add(t) : s.set(t, n), R = (t, s, n, e) => (k(t, s, "write to private field"), e ? e.call(t, n) : s.set(t, n), n), F = (t, s, n) => (k(t, s, "access private method"), n);
+var N = (t, s, n) => new Promise((e, r) => {
+  var o = (l) => {
+    try {
+      c(n.next(l));
+    } catch (d) {
+      r(d);
+    }
+  }, i = (l) => {
+    try {
+      c(n.throw(l));
+    } catch (d) {
+      r(d);
+    }
+  }, c = (l) => l.done ? e(l.value) : Promise.resolve(l.value).then(o, i);
+  c((n = n.apply(t, s)).next());
+});
+import { R as H, e as K, l as Q } from "./index-VkDZJVOR.mjs";
+const Y = (t, s, n) => {
+  if (!s) return;
+  const e = document.createElement("style");
+  e.textContent = s, n ? t.appendChild(e) : document.head.appendChild(e);
+}, tt = (t, s) => {
+  t.innerHTML = s;
+  const n = et(t), e = nt(t), r = st(t);
+  return { bindings: n, twoWayBindings: e, conditionals: r };
+}, et = (t) => {
+  const s = document.createTreeWalker(t, NodeFilter.SHOW_TEXT, null), n = [];
+  let e;
+  for (; e = s.nextNode(); ) {
+    const o = [...e.textContent.matchAll(H.bindings)];
+    if (o.length > 0) {
+      const i = e.textContent, c = o.map((l) => {
+        const d = l[1].trim(), u = d.includes("("), b = u ? [d.split("(")[0].trim()] : d.split(".").map((f) => f.trim());
+        return { raw: d, path: b, isFunction: u };
+      });
+      n.push({ node: e, bindings: c, original: i });
+    }
+  }
+  return t.querySelectorAll("*").forEach((o) => {
+    for (const i of o.attributes) {
+      if (i.name === "$if" || i.name === "$else-if" || i.name === "$else" || i.name === "$bind")
+        continue;
+      const c = [...i.value.matchAll(H.bindings)];
+      if (c.length > 0) {
+        const l = i.value, d = c.map((u) => {
+          const b = u[1].trim(), f = b.includes("("), w = f ? [b.split("(")[0].trim()] : b.split(".").map((v) => v.trim());
+          return { raw: b, path: w, isFunction: f };
+        });
+        n.push({
+          node: o,
+          bindings: d,
+          original: l,
+          isAttribute: !0,
+          attributeName: i.name
+        });
+      }
+    }
+  }), n;
+}, nt = (t) => {
+  const s = [];
+  return t.querySelectorAll("[\\$bind]").forEach((e) => {
+    const r = e.getAttribute("$bind");
+    if (!r) return;
+    const o = r.trim(), i = o.split(".").map((c) => c.trim());
+    e instanceof HTMLInputElement || e instanceof HTMLTextAreaElement || e instanceof HTMLSelectElement ? (s.push({
+      element: e,
+      path: i,
+      raw: o,
+      isContentEditable: !1
+    }), e.removeAttribute("$bind")) : e instanceof HTMLElement && (e.hasAttribute("contenteditable") || e.isContentEditable) && (s.push({
+      element: e,
+      path: i,
+      raw: o,
+      isContentEditable: !0
+    }), e.removeAttribute("$bind"));
+  }), s;
+}, st = (t) => {
+  const s = [], n = /* @__PURE__ */ new Set();
+  return t.querySelectorAll("[\\$if]").forEach((r) => {
+    if (n.has(r)) return;
+    const o = [];
+    let i = r;
+    for (; i; ) {
+      const c = i.hasAttribute("$if"), l = i.hasAttribute("$else-if"), d = i.hasAttribute("$else");
+      if (!c && !l && !d) break;
+      n.add(i);
+      let u, b = "";
+      c ? (u = "if", b = i.getAttribute("$if") || "", i.removeAttribute("$if")) : l ? (u = "else-if", b = i.getAttribute("$else-if") || "", i.removeAttribute("$else-if")) : (u = "else", i.removeAttribute("$else"));
+      const f = document.createComment(
+        `conditional:${u}:${b}`
+      ), w = i.parentElement || t, v = i.nextSibling;
+      w.insertBefore(f, i);
+      const $ = {
+        element: i,
+        condition: b.trim(),
+        type: u,
+        placeholder: f,
+        group: [],
+        // Will be set after the group is complete
+        originalParent: w,
+        nextSibling: v
+      };
+      o.push($);
+      const m = i.nextElementSibling;
+      if (i.remove(), i = m, m && !m.hasAttribute("$else-if") && !m.hasAttribute("$else"))
+        break;
+    }
+    o.forEach((c) => {
+      c.group = o;
+    }), s.push(o);
+  }), s;
+}, ot = (t) => {
+  const s = /* @__PURE__ */ new Set();
+  return t.forEach((n) => {
+    n.forEach((e) => {
+      let r = e.condition;
+      r = r.replace(/\{([^}]+)\}/g, "$1");
+      const o = /\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 c;
+      for (; (c = o.exec(r)) !== null; ) {
+        const d = c[1].split(".")[0];
+        i.has(d) || s.add(d);
+      }
+    });
+  }), s;
+}, _ = /* @__PURE__ */ new Map(), it = 100, rt = (t) => {
+  const s = _.get(t);
+  if (s)
+    return _.delete(t), _.set(t, s), s;
+  const n = new Function(
+    "component",
+    `with(component) { return ${t}; }`
+  );
+  if (_.size >= it) {
+    const e = _.keys().next().value;
+    e && _.delete(e);
+  }
+  return _.set(t, n), n;
+}, ct = (t, s) => s.reduce((n, e) => {
+  if (!(n == null || typeof n != "object"))
+    return n[e];
+}, t), O = (t, s, n) => {
+  if (s.length === 0) return;
+  const e = s[s.length - 1], r = s.slice(0, -1);
+  let o = t;
+  for (const i of r)
+    (o[i] === void 0 || o[i] === null) && (o[i] = {}), o = o[i];
+  o[e] = n;
+}, q = (t, s, n) => {
+  for (const e of t) {
+    let r = e.original;
+    for (const { raw: o, path: i, isFunction: c } of e.bindings) {
+      let l;
+      if (c)
+        try {
+          const u = i[0];
+          typeof (n == null ? void 0 : n[u]) == "function" ? l = rt(o)(n) : l = void 0;
+        } catch (u) {
+          console.error(`Error executing function binding {${o}}:`, u), l = void 0;
+        }
+      else
+        l = ct(s, i);
+      if (l === void 0) continue;
+      const d = String(l != null ? l : "");
+      r = r.replace(`{${o}}`, d);
+    }
+    if (e.node.nodeType === Node.TEXT_NODE) {
+      const o = e.node, i = o.parentElement, c = r.trim().startsWith("<") && r.includes(">");
+      i && c ? i.innerHTML = r : o.textContent = r;
+    } else {
+      const o = e.node;
+      e.isAttribute && e.attributeName && o.setAttribute(e.attributeName, r);
+    }
+  }
+}, at = (t, s, n) => {
+  if (!t) return !0;
+  let e = t.trim();
+  e = e.replace(/\{([^}]+)\}/g, "$1");
+  try {
+    return new Function(
+      "context",
+      "component",
+      `
+      with (context) {
+        try {
+          return Boolean(${e});
+        } catch (e) {
+          return false;
+        }
+      }
+    `
+    )(s, n);
+  } catch (r) {
+    return console.error(`Error evaluating condition "${t}":`, r), !1;
+  }
+}, I = (t, s, n) => {
+  var e;
+  for (const r of t) {
+    let o = !1;
+    for (const i of r) {
+      const { element: c, condition: l, type: d, placeholder: u, originalParent: b } = i;
+      let f = !1;
+      d === "else" ? f = !o : o || (f = at(l, s, n), f && (o = !0));
+      const w = c.parentNode !== null;
+      f && !w ? (e = u.parentNode) == null || e.insertBefore(c, u.nextSibling) : !f && w && c.remove();
+    }
+  }
+}, M = (t) => t instanceof ShadowRoot ? t.host : t, lt = (t, s) => {
+  const n = /* @__PURE__ */ new Set(), e = [];
+  s.forEach(({ path: o }) => {
+    const i = o[0];
+    n.add(i);
+  }), n.forEach((o) => {
+    new RegExp(
+      `(?:const|let|var)\\s+${o}\\s*=`,
+      "g"
+    ).test(t) && e.push(
+      `⚠️  Variable "${o}" is already bound via $bind and cannot be redeclared. Remove the declaration or use a different variable name.`
+    );
+  });
+  const r = [];
+  return n.forEach((o) => {
+    r.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: r.join(`
+`),
+    bindVarNames: n,
+    errors: e
+  };
+}, ut = (t, s, n = /* @__PURE__ */ new Set()) => {
+  const e = [], r = /* @__PURE__ */ new Set();
+  s.forEach((c) => {
+    c.bindings.forEach((l) => {
+      const d = l.path[0];
+      r.add(d);
+    });
+  }), n.forEach((c) => {
+    r.add(c);
+  });
+  const o = /(?:const|let|var)\s+(\w+)\s*=\s*([^;]+);?/g;
+  let i;
+  for (; (i = o.exec(t)) !== null; ) {
+    const c = i[1];
+    r.has(c) && e.push(`component.state.${c} = ${c};`);
+  }
+  return { stateBindings: e, boundVarNames: r };
+}, dt = (t, s) => {
+  if (s.size === 0) return t;
+  let n = t;
+  return s.forEach((e) => {
+    const r = new RegExp(
+      `(?<!const\\s|let\\s|var\\s|\\.)\\b(\\+\\+|\\-\\-)${e}\\b|\\b${e}(\\+\\+|\\-\\-)`,
+      "g"
+    );
+    n = n.replace(r, (c) => {
+      if (c.startsWith("++") || c.startsWith("--"))
+        return `${c.substring(0, 2)}component.state.${e}`;
+      {
+        const l = c.substring(c.length - 2);
+        return `component.state.${e}${l}`;
+      }
+    });
+    const o = new RegExp(
+      `(?<!const\\s|let\\s|var\\s|\\.)\\b${e}\\s*(\\+=|\\-=|\\*=|\\/=|%=|\\*\\*=|<<=|>>=|>>>=|&=|\\|=|\\^=)`,
+      "g"
+    );
+    n = n.replace(
+      o,
+      `component.state.${e}$1`
+    );
+    const i = new RegExp(
+      `(?<!const\\s|let\\s|var\\s|\\.|\\+|\\-|\\*|\\/|%|<|>|&|\\||\\^)\\b${e}\\s*=\\s*([^=])`,
+      "g"
+    );
+    n = n.replace(
+      i,
+      `component.state.${e} = $1`
+    );
+  }), n;
+}, P = (t, s, n, e, r, o = /* @__PURE__ */ new Set()) => {
+  try {
+    const { injectedCode: i, componentInjections: c, bindVarNames: l, errors: d } = lt(t, n);
+    d.length > 0 && (console.error("❌ $bind Variable Conflicts Detected:"), d.forEach((a) => console.error(a)));
+    const u = /function\s+(\w+)|const\s+(\w+)\s*=\s*(?:\([^)]*\)|[\w\s]*)\s*=>/g, b = [];
+    let f;
+    for (; (f = u.exec(t)) !== null; ) {
+      const a = f[1] || f[2];
+      a && b.push(a);
+    }
+    const w = b.map(
+      (a) => `component.${a} = typeof ${a} !== 'undefined' ? ${a}.bind(component) : undefined;`
+    ).join(`
+            `), { stateBindings: v, boundVarNames: $ } = ut(
+      t,
+      s,
+      o
+    ), m = /* @__PURE__ */ new Set([...$, ...l]), X = v.join(`
+            `), C = dt(
+      t,
+      m
+    ), Z = `
+      (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) {
+          ${C}
+          
+          // Auto-bind variables to component state (e.g., const name = "value" → this.state.name = "value")
+          ${X}
+          
+          // Auto-attach all detected functions to component for onclick access
+          ${w}
+        }
+      }).call(arguments[0], arguments[0], arguments[1], arguments[2])
+    `;
+    new Function(Z)(r, e, K);
+  } catch (i) {
+    console.error("Script execution failed:", i);
+  }
+}, U = (t, 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"
+  ].forEach((e) => {
+    const r = `on${e}`;
+    (t instanceof ShadowRoot ? t.querySelectorAll(`[${r}]`) : s.querySelectorAll(`[${r}]`)).forEach((i) => {
+      const c = `${r}`;
+      if (i[`__processed_${c}`]) return;
+      const l = i.getAttribute(r);
+      l && (i.removeAttribute(r), i.addEventListener(
+        e,
+        function(d) {
+          new Function(
+            "event",
+            "component",
+            `
+            with(component) {
+              ${l}
+            }
+          `
+          ).call(this, d, s);
+        }
+      ), i[`__processed_${c}`] = !0);
+    });
+  });
+}, ft = (o, i, c, ...l) => N(null, [o, i, c, ...l], function* (t, s, n, e = [], r = /* @__PURE__ */ new Set()) {
+  if (!(s != null && s.length)) return;
+  const d = M(t);
+  for (const u of s)
+    u.content && P(
+      u.content,
+      n,
+      e,
+      t,
+      d,
+      r
+    );
+  U(t, d);
+}), ht = (t, s) => new Promise((n, e) => {
+  const r = document.querySelector(
+    `script[src="${t}"]`
+  );
+  if (r) {
+    if (r.dataset.loaded === "true") {
+      n();
+      return;
+    }
+    r.addEventListener("load", () => n(), { once: !0 }), r.addEventListener(
+      "error",
+      () => e(new Error(`Failed to load external script: ${t}`)),
+      { once: !0 }
+    );
+    return;
+  }
+  const o = document.createElement("script");
+  o.src = t, s && (o.type = s), o.onload = () => {
+    o.dataset.loaded = "true", n();
+  }, o.onerror = () => e(new Error(`Failed to load external script: ${t}`)), document.head.appendChild(o);
+}), bt = (i, c, l, ...d) => N(null, [i, c, l, ...d], function* (t, s, n, e = [], r = /* @__PURE__ */ new Set(), o) {
+  var b;
+  const u = M(t);
+  for (const f of s) {
+    let w;
+    o ? o.startsWith("http://") || o.startsWith("https://") ? w = o : w = new URL(
+      o,
+      window.location.href
+    ).href : w = window.location.href;
+    const v = new URL(f.src, w).href;
+    if (f.external)
+      yield ht(v, f.type);
+    else if (f.type === "module") {
+      const $ = u.tagName.toLowerCase();
+      window.__ladrilloContexts || (window.__ladrilloContexts = /* @__PURE__ */ new Map()), window.__ladrilloContexts.set($, {
+        host: t,
+        shadowRoot: t instanceof ShadowRoot ? t : null,
+        element: u,
+        state: u.state,
+        setState: (b = u.setState) == null ? void 0 : b.bind(u)
+      });
+      const m = document.createElement("script");
+      m.type = "module", m.src = v, m.setAttribute("data-component", $), document.head.appendChild(m);
+    } else
+      yield fetch(v).then(($) => {
+        if (!$.ok)
+          throw new Error(`HTTP ${$.status}: ${$.statusText}`);
+        const m = $.headers.get("content-type");
+        if (m && !m.includes("javascript") && !m.includes("text/plain"))
+          throw new Error(`Expected JavaScript but got ${m}`);
+        return $.text();
+      }).then(($) => {
+        P(
+          $,
+          n,
+          e,
+          t,
+          u,
+          r
+        );
+      }).catch(($) => {
+        console.error(`Failed to load external script: ${f.src}`, $);
+      });
+  }
+  U(t, u);
+}), gt = (t, s) => {
+  var d, u, b, f, w, v, z, m, D;
+  const { tagName: n, template: e, scripts: r, externalScripts: o, styles: i, sourcePath: c } = t, C = class C extends HTMLElement {
+    constructor() {
+      super();
+      A(this, m);
+      A(this, d, []);
+      A(this, u, []);
+      A(this, b, []);
+      A(this, f, []);
+      A(this, w, c);
+      s && this.attachShadow({ mode: "open" });
+      const a = {};
+      this.state = new Proxy(a, {
+        set: (h, p, g) => {
+          const y = h[p];
+          return Object.is(y, g) || (h[p] = g, Object.getOwnPropertyDescriptor(this, p) || Object.defineProperty(this, p, {
+            get() {
+              return this.state[p];
+            },
+            set(L) {
+              this.state[p] = L;
+            },
+            enumerable: !0,
+            configurable: !0
+          }), q(E(this, d), this.state, this), I(E(this, b), this.state, this), F(this, m, D).call(this)), !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(a) {
+      Object.assign(this.state, a);
+    }
+    // Invoked when element is added to the DOM
+    connectedCallback() {
+      return N(this, null, function* () {
+        const a = s ? this.shadowRoot : this, { bindings: h, twoWayBindings: p, conditionals: g } = tt(
+          a,
+          e
+        );
+        R(this, d, h), R(this, u, p), R(this, b, g);
+        const y = ot(g);
+        Y(a, i, s), this._initializeStateFromAttributes(), this._setupTwoWayBindings(), yield bt(
+          a,
+          o,
+          E(this, d),
+          E(this, u),
+          y,
+          E(this, w)
+        ), yield ft(
+          a,
+          r,
+          E(this, d),
+          E(this, u),
+          y
+        ), q(E(this, d), this.state, this), I(E(this, b), this.state, this), this._setupAttributeObserver();
+      });
+    }
+    // Invoked when element is removed from the DOM
+    disconnectedCallback() {
+      this.__attributeObserver && (this.__attributeObserver.disconnect(), this.__attributeObserver = null), E(this, f).forEach((h) => {
+        try {
+          h();
+        } catch (p) {
+          console.error("Error cleaning up two-way binding:", p);
+        }
+      }), R(this, f, []);
+      const a = this.__eventUnsubscribers;
+      a && Array.isArray(a) && (a.forEach((h) => {
+        try {
+          h();
+        } catch (p) {
+          console.error("Error unsubscribing from event:", p);
+        }
+      }), this.__eventUnsubscribers = []);
+    }
+    // Set up observer to watch for attribute changes
+    _setupAttributeObserver() {
+      const a = new MutationObserver((h) => {
+        h.forEach((p) => {
+          if (p.type === "attributes" && p.attributeName) {
+            const g = this.getAttribute(p.attributeName);
+            this._handleAttributeChange(p.attributeName, g);
+          }
+        });
+      });
+      a.observe(this, {
+        attributes: !0,
+        attributeOldValue: !0
+      }), this.__attributeObserver = a;
+    }
+    // initializes the state from the attributes
+    _initializeStateFromAttributes() {
+      this.getAttributeNames().forEach((a) => {
+        const h = this.getAttribute(a);
+        this._handleAttributeChange(a, h);
+      });
+    }
+    // Invoked when attributes are changed.
+    _handleAttributeChange(a, h) {
+      var g;
+      if (a) {
+        const y = "this.state.";
+        a.startsWith(y) && (a = a.slice(y.length));
+      }
+      const p = F(g = C, v, z).call(g, h);
+      this.state[a] = p;
+    }
+    // Setup two-way data bindings for input elements with $bind
+    _setupTwoWayBindings() {
+      E(this, u).forEach(
+        ({ element: a, path: h, raw: p, isContentEditable: g }) => {
+          var L, W;
+          if (this._getNestedValue(h) === void 0 && O(this.state, h, ""), g) {
+            const x = a;
+            x.textContent = (L = this._getNestedValue(h)) != null ? L : "";
+            const S = (T) => {
+              const B = T.target.textContent || "";
+              O(this.state, h, B);
+            };
+            x.addEventListener("input", S);
+            const V = () => {
+              x.removeEventListener("input", S);
+            };
+            E(this, f).push(V);
+          } else {
+            const x = a;
+            x.value = (W = this._getNestedValue(h)) != null ? W : "";
+            const S = (T) => {
+              const B = T.target.value;
+              O(this.state, h, B);
+            };
+            x.addEventListener("input", S);
+            const V = () => {
+              x.removeEventListener("input", S);
+            };
+            if (E(this, f).push(V), x instanceof HTMLSelectElement || x instanceof HTMLInputElement && ["checkbox", "radio", "file"].includes(x.type)) {
+              x.addEventListener("change", S);
+              const T = () => {
+                x.removeEventListener("change", S);
+              };
+              E(this, f).push(T);
+            }
+          }
+        }
+      );
+    }
+    // Helper to get nested value from state
+    _getNestedValue(a) {
+      return a.reduce((h, p) => h == null ? void 0 : h[p], this.state);
+    }
+  };
+  d = new WeakMap(), u = new WeakMap(), b = new WeakMap(), f = new WeakMap(), w = new WeakMap(), v = new WeakSet(), z = function(a) {
+    if (a === null || a === "") return null;
+    if (a !== "undefined")
+      try {
+        return JSON.parse(a);
+      } catch (h) {
+        return a;
+      }
+  }, m = new WeakSet(), // Update two-way bound elements when state changes
+  D = function() {
+    E(this, u).forEach(({ element: a, path: h, isContentEditable: p }) => {
+      const g = this._getNestedValue(h);
+      if (p) {
+        const y = a;
+        y.textContent !== g && (y.textContent = g != null ? g : "");
+      } else {
+        const y = a;
+        y.value !== g && (y.value = g != null ? g : "");
+      }
+    });
+  }, A(C, v);
+  let l = C;
+  customElements.define(n, l), Q.log(`Web component defined: <${n}></${n}>`);
+};
+export {
+  gt as defineWebComponent
+};
+//# sourceMappingURL=webcomponent-CJ3lZBZb.mjs.map