@hot-page/fun 0.0.1

package/dist/index.js

@@ -0,0 +1,705 @@
+const te = globalThis, U = te.trustedTypes, ne = U ? U.createPolicy("lit-html", { createHTML: (e) => e }) : void 0, pe = "$lit$", C = `lit$${Math.random().toFixed(9).slice(2)}$`, fe = "?" + C, Se = `<${fe}>`, E = document, P = () => E.createComment(""), R = (e) => e === null || typeof e != "object" && typeof e != "function", re = Array.isArray, Ee = (e) => re(e) || typeof e?.[Symbol.iterator] == "function", G = `[ 	
+\f\r]`, W = /<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g, ue = /-->/g, ce = />/g, x = RegExp(`>|${G}(?:([^\\s"'>=/]+)(${G}*=${G}*(?:[^ 	
+\f\r"'\`<>=]|("|')|))|$)`, "g"), ae = /'/g, le = /"/g, me = /^(?:script|style|textarea|title)$/i, ve = (e) => (t, ...r) => ({ _$litType$: e, strings: t, values: r }), nt = ve(1), ut = ve(2), H = Symbol.for("lit-noChange"), w = Symbol.for("lit-nothing"), he = /* @__PURE__ */ new WeakMap(), T = E.createTreeWalker(E, 129);
+function Ae(e, t) {
+  if (!re(e) || !e.hasOwnProperty("raw")) throw Error("invalid template strings array");
+  return ne !== void 0 ? ne.createHTML(t) : t;
+}
+const Ie = (e, t) => {
+  const r = e.length - 1, s = [];
+  let o, i = t === 2 ? "<svg>" : t === 3 ? "<math>" : "", a = W;
+  for (let h = 0; h < r; h++) {
+    const n = e[h];
+    let u, d, c = -1, v = 0;
+    for (; v < n.length && (a.lastIndex = v, d = a.exec(n), d !== null); ) v = a.lastIndex, a === W ? d[1] === "!--" ? a = ue : d[1] !== void 0 ? a = ce : d[2] !== void 0 ? (me.test(d[2]) && (o = RegExp("</" + d[2], "g")), a = x) : d[3] !== void 0 && (a = x) : a === x ? d[0] === ">" ? (a = o ?? W, c = -1) : d[1] === void 0 ? c = -2 : (c = a.lastIndex - d[2].length, u = d[1], a = d[3] === void 0 ? x : d[3] === '"' ? le : ae) : a === le || a === ae ? a = x : a === ue || a === ce ? a = W : (a = x, o = void 0);
+    const m = a === x && e[h + 1].startsWith("/>") ? " " : "";
+    i += a === W ? n + Se : c >= 0 ? (s.push(u), n.slice(0, c) + pe + n.slice(c) + C + m) : n + C + (c === -2 ? h : m);
+  }
+  return [Ae(e, i + (e[r] || "<?>") + (t === 2 ? "</svg>" : t === 3 ? "</math>" : "")), s];
+};
+class k {
+  constructor({ strings: t, _$litType$: r }, s) {
+    let o;
+    this.parts = [];
+    let i = 0, a = 0;
+    const h = t.length - 1, n = this.parts, [u, d] = Ie(t, r);
+    if (this.el = k.createElement(u, s), T.currentNode = this.el.content, r === 2 || r === 3) {
+      const c = this.el.content.firstChild;
+      c.replaceWith(...c.childNodes);
+    }
+    for (; (o = T.nextNode()) !== null && n.length < h; ) {
+      if (o.nodeType === 1) {
+        if (o.hasAttributes()) for (const c of o.getAttributeNames()) if (c.endsWith(pe)) {
+          const v = d[a++], m = o.getAttribute(c).split(C), _ = /([.?@])?(.*)/.exec(v);
+          n.push({ type: 1, index: i, name: _[2], strings: m, ctor: _[1] === "." ? Oe : _[1] === "?" ? We : _[1] === "@" ? Me : B }), o.removeAttribute(c);
+        } else c.startsWith(C) && (n.push({ type: 6, index: i }), o.removeAttribute(c));
+        if (me.test(o.tagName)) {
+          const c = o.textContent.split(C), v = c.length - 1;
+          if (v > 0) {
+            o.textContent = U ? U.emptyScript : "";
+            for (let m = 0; m < v; m++) o.append(c[m], P()), T.nextNode(), n.push({ type: 2, index: ++i });
+            o.append(c[v], P());
+          }
+        }
+      } else if (o.nodeType === 8) if (o.data === fe) n.push({ type: 2, index: i });
+      else {
+        let c = -1;
+        for (; (c = o.data.indexOf(C, c + 1)) !== -1; ) n.push({ type: 7, index: i }), c += C.length - 1;
+      }
+      i++;
+    }
+  }
+  static createElement(t, r) {
+    const s = E.createElement("template");
+    return s.innerHTML = t, s;
+  }
+}
+function b(e, t, r = e, s) {
+  if (t === H) return t;
+  let o = s !== void 0 ? r._$Co?.[s] : r._$Cl;
+  const i = R(t) ? void 0 : t._$litDirective$;
+  return o?.constructor !== i && (o?._$AO?.(!1), i === void 0 ? o = void 0 : (o = new i(e), o._$AT(e, r, s)), s !== void 0 ? (r._$Co ??= [])[s] = o : r._$Cl = o), o !== void 0 && (t = b(e, o._$AS(e, t.values), o, s)), t;
+}
+class be {
+  constructor(t, r) {
+    this._$AV = [], this._$AN = void 0, this._$AD = t, this._$AM = r;
+  }
+  get parentNode() {
+    return this._$AM.parentNode;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  u(t) {
+    const { el: { content: r }, parts: s } = this._$AD, o = (t?.creationScope ?? E).importNode(r, !0);
+    T.currentNode = o;
+    let i = T.nextNode(), a = 0, h = 0, n = s[0];
+    for (; n !== void 0; ) {
+      if (a === n.index) {
+        let u;
+        n.type === 2 ? u = new L(i, i.nextSibling, this, t) : n.type === 1 ? u = new n.ctor(i, n.name, n.strings, this, t) : n.type === 6 && (u = new Pe(i, this, t)), this._$AV.push(u), n = s[++h];
+      }
+      a !== n?.index && (i = T.nextNode(), a++);
+    }
+    return T.currentNode = E, o;
+  }
+  p(t) {
+    let r = 0;
+    for (const s of this._$AV) s !== void 0 && (s.strings !== void 0 ? (s._$AI(t, s, r), r += s.strings.length - 2) : s._$AI(t[r])), r++;
+  }
+}
+class L {
+  get _$AU() {
+    return this._$AM?._$AU ?? this._$Cv;
+  }
+  constructor(t, r, s, o) {
+    this.type = 2, this._$AH = w, this._$AN = void 0, this._$AA = t, this._$AB = r, this._$AM = s, this.options = o, this._$Cv = o?.isConnected ?? !0;
+  }
+  get parentNode() {
+    let t = this._$AA.parentNode;
+    const r = this._$AM;
+    return r !== void 0 && t?.nodeType === 11 && (t = r.parentNode), t;
+  }
+  get startNode() {
+    return this._$AA;
+  }
+  get endNode() {
+    return this._$AB;
+  }
+  _$AI(t, r = this) {
+    t = b(this, t, r), R(t) ? t === w || t == null || t === "" ? (this._$AH !== w && this._$AR(), this._$AH = w) : t !== this._$AH && t !== H && this._(t) : t._$litType$ !== void 0 ? this.$(t) : t.nodeType !== void 0 ? this.T(t) : Ee(t) ? this.k(t) : this._(t);
+  }
+  O(t) {
+    return this._$AA.parentNode.insertBefore(t, this._$AB);
+  }
+  T(t) {
+    this._$AH !== t && (this._$AR(), this._$AH = this.O(t));
+  }
+  _(t) {
+    this._$AH !== w && R(this._$AH) ? this._$AA.nextSibling.data = t : this.T(E.createTextNode(t)), this._$AH = t;
+  }
+  $(t) {
+    const { values: r, _$litType$: s } = t, o = typeof s == "number" ? this._$AC(t) : (s.el === void 0 && (s.el = k.createElement(Ae(s.h, s.h[0]), this.options)), s);
+    if (this._$AH?._$AD === o) this._$AH.p(r);
+    else {
+      const i = new be(o, this), a = i.u(this.options);
+      i.p(r), this.T(a), this._$AH = i;
+    }
+  }
+  _$AC(t) {
+    let r = he.get(t.strings);
+    return r === void 0 && he.set(t.strings, r = new k(t)), r;
+  }
+  k(t) {
+    re(this._$AH) || (this._$AH = [], this._$AR());
+    const r = this._$AH;
+    let s, o = 0;
+    for (const i of t) o === r.length ? r.push(s = new L(this.O(P()), this.O(P()), this, this.options)) : s = r[o], s._$AI(i), o++;
+    o < r.length && (this._$AR(s && s._$AB.nextSibling, o), r.length = o);
+  }
+  _$AR(t = this._$AA.nextSibling, r) {
+    for (this._$AP?.(!1, !0, r); t !== this._$AB; ) {
+      const s = t.nextSibling;
+      t.remove(), t = s;
+    }
+  }
+  setConnected(t) {
+    this._$AM === void 0 && (this._$Cv = t, this._$AP?.(t));
+  }
+}
+class B {
+  get tagName() {
+    return this.element.tagName;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  constructor(t, r, s, o, i) {
+    this.type = 1, this._$AH = w, this._$AN = void 0, this.element = t, this.name = r, this._$AM = o, this.options = i, s.length > 2 || s[0] !== "" || s[1] !== "" ? (this._$AH = Array(s.length - 1).fill(new String()), this.strings = s) : this._$AH = w;
+  }
+  _$AI(t, r = this, s, o) {
+    const i = this.strings;
+    let a = !1;
+    if (i === void 0) t = b(this, t, r, 0), a = !R(t) || t !== this._$AH && t !== H, a && (this._$AH = t);
+    else {
+      const h = t;
+      let n, u;
+      for (t = i[0], n = 0; n < i.length - 1; n++) u = b(this, h[s + n], r, n), u === H && (u = this._$AH[n]), a ||= !R(u) || u !== this._$AH[n], u === w ? t = w : t !== w && (t += (u ?? "") + i[n + 1]), this._$AH[n] = u;
+    }
+    a && !o && this.j(t);
+  }
+  j(t) {
+    t === w ? this.element.removeAttribute(this.name) : this.element.setAttribute(this.name, t ?? "");
+  }
+}
+class Oe extends B {
+  constructor() {
+    super(...arguments), this.type = 3;
+  }
+  j(t) {
+    this.element[this.name] = t === w ? void 0 : t;
+  }
+}
+class We extends B {
+  constructor() {
+    super(...arguments), this.type = 4;
+  }
+  j(t) {
+    this.element.toggleAttribute(this.name, !!t && t !== w);
+  }
+}
+class Me extends B {
+  constructor(t, r, s, o, i) {
+    super(t, r, s, o, i), this.type = 5;
+  }
+  _$AI(t, r = this) {
+    if ((t = b(this, t, r, 0) ?? w) === H) return;
+    const s = this._$AH, o = t === w && s !== w || t.capture !== s.capture || t.once !== s.once || t.passive !== s.passive, i = t !== w && (s === w || o);
+    o && this.element.removeEventListener(this.name, this, s), i && this.element.addEventListener(this.name, this, t), this._$AH = t;
+  }
+  handleEvent(t) {
+    typeof this._$AH == "function" ? this._$AH.call(this.options?.host ?? this.element, t) : this._$AH.handleEvent(t);
+  }
+}
+class Pe {
+  constructor(t, r, s) {
+    this.element = t, this.type = 6, this._$AN = void 0, this._$AM = r, this.options = s;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  _$AI(t) {
+    b(this, t);
+  }
+}
+const Re = te.litHtmlPolyfillSupport;
+Re?.(k, L), (te.litHtmlVersions ??= []).push("3.3.1");
+const He = (e, t, r) => {
+  const s = t;
+  let o = s._$litPart$;
+  return o === void 0 && (s._$litPart$ = o = new L(t.insertBefore(P(), null), null, void 0, {})), o._$AI(e), o;
+};
+var ke = Object.defineProperty, Le = (e, t, r) => t in e ? ke(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r, K = (e, t, r) => (Le(e, typeof t != "symbol" ? t + "" : t, r), r), Ve = (e, t, r) => {
+  if (!t.has(e))
+    throw TypeError("Cannot " + r);
+}, Y = (e, t) => {
+  if (Object(t) !== t)
+    throw TypeError('Cannot use the "in" operator on this value');
+  return e.has(t);
+}, D = (e, t, r) => {
+  if (t.has(e))
+    throw TypeError("Cannot add the same private member more than once");
+  t instanceof WeakSet ? t.add(e) : t.set(e, r);
+}, de = (e, t, r) => (Ve(e, t, "access private method"), r);
+function we(e, t) {
+  return Object.is(e, t);
+}
+let A = null, M = !1, q = 1;
+const j = /* @__PURE__ */ Symbol("SIGNAL");
+function I(e) {
+  const t = A;
+  return A = e, t;
+}
+function De() {
+  return A;
+}
+function qe() {
+  return M;
+}
+const se = {
+  version: 0,
+  lastCleanEpoch: 0,
+  dirty: !1,
+  producerNode: void 0,
+  producerLastReadVersion: void 0,
+  producerIndexOfThis: void 0,
+  nextProducerIndex: 0,
+  liveConsumerNode: void 0,
+  liveConsumerIndexOfThis: void 0,
+  consumerAllowSignalWrites: !1,
+  consumerIsAlwaysLive: !1,
+  producerMustRecompute: () => !1,
+  producerRecomputeValue: () => {
+  },
+  consumerMarkedDirty: () => {
+  },
+  consumerOnSignalRead: () => {
+  }
+};
+function F(e) {
+  if (M)
+    throw new Error(
+      typeof ngDevMode < "u" && ngDevMode ? "Assertion error: signal read during notification phase" : ""
+    );
+  if (A === null)
+    return;
+  A.consumerOnSignalRead(e);
+  const t = A.nextProducerIndex++;
+  if (O(A), t < A.producerNode.length && A.producerNode[t] !== e && X(A)) {
+    const r = A.producerNode[t];
+    Z(r, A.producerIndexOfThis[t]);
+  }
+  A.producerNode[t] !== e && (A.producerNode[t] = e, A.producerIndexOfThis[t] = X(A) ? ge(e, A, t) : 0), A.producerLastReadVersion[t] = e.version;
+}
+function Ue() {
+  q++;
+}
+function $e(e) {
+  if (!(!e.dirty && e.lastCleanEpoch === q)) {
+    if (!e.producerMustRecompute(e) && !ze(e)) {
+      e.dirty = !1, e.lastCleanEpoch = q;
+      return;
+    }
+    e.producerRecomputeValue(e), e.dirty = !1, e.lastCleanEpoch = q;
+  }
+}
+function _e(e) {
+  if (e.liveConsumerNode === void 0)
+    return;
+  const t = M;
+  M = !0;
+  try {
+    for (const r of e.liveConsumerNode)
+      r.dirty || Be(r);
+  } finally {
+    M = t;
+  }
+}
+function je() {
+  return A?.consumerAllowSignalWrites !== !1;
+}
+function Be(e) {
+  var t;
+  e.dirty = !0, _e(e), (t = e.consumerMarkedDirty) == null || t.call(e.wrapper ?? e);
+}
+function Fe(e) {
+  return e && (e.nextProducerIndex = 0), I(e);
+}
+function Ze(e, t) {
+  if (I(t), !(!e || e.producerNode === void 0 || e.producerIndexOfThis === void 0 || e.producerLastReadVersion === void 0)) {
+    if (X(e))
+      for (let r = e.nextProducerIndex; r < e.producerNode.length; r++)
+        Z(e.producerNode[r], e.producerIndexOfThis[r]);
+    for (; e.producerNode.length > e.nextProducerIndex; )
+      e.producerNode.pop(), e.producerLastReadVersion.pop(), e.producerIndexOfThis.pop();
+  }
+}
+function ze(e) {
+  O(e);
+  for (let t = 0; t < e.producerNode.length; t++) {
+    const r = e.producerNode[t], s = e.producerLastReadVersion[t];
+    if (s !== r.version || ($e(r), s !== r.version))
+      return !0;
+  }
+  return !1;
+}
+function ge(e, t, r) {
+  var s;
+  if (oe(e), O(e), e.liveConsumerNode.length === 0) {
+    (s = e.watched) == null || s.call(e.wrapper);
+    for (let o = 0; o < e.producerNode.length; o++)
+      e.producerIndexOfThis[o] = ge(e.producerNode[o], e, o);
+  }
+  return e.liveConsumerIndexOfThis.push(r), e.liveConsumerNode.push(t) - 1;
+}
+function Z(e, t) {
+  var r;
+  if (oe(e), O(e), typeof ngDevMode < "u" && ngDevMode && t >= e.liveConsumerNode.length)
+    throw new Error(
+      `Assertion error: active consumer index ${t} is out of bounds of ${e.liveConsumerNode.length} consumers)`
+    );
+  if (e.liveConsumerNode.length === 1) {
+    (r = e.unwatched) == null || r.call(e.wrapper);
+    for (let o = 0; o < e.producerNode.length; o++)
+      Z(e.producerNode[o], e.producerIndexOfThis[o]);
+  }
+  const s = e.liveConsumerNode.length - 1;
+  if (e.liveConsumerNode[t] = e.liveConsumerNode[s], e.liveConsumerIndexOfThis[t] = e.liveConsumerIndexOfThis[s], e.liveConsumerNode.length--, e.liveConsumerIndexOfThis.length--, t < e.liveConsumerNode.length) {
+    const o = e.liveConsumerIndexOfThis[t], i = e.liveConsumerNode[t];
+    O(i), i.producerIndexOfThis[o] = t;
+  }
+}
+function X(e) {
+  var t;
+  return e.consumerIsAlwaysLive || (((t = e?.liveConsumerNode) == null ? void 0 : t.length) ?? 0) > 0;
+}
+function O(e) {
+  e.producerNode ?? (e.producerNode = []), e.producerIndexOfThis ?? (e.producerIndexOfThis = []), e.producerLastReadVersion ?? (e.producerLastReadVersion = []);
+}
+function oe(e) {
+  e.liveConsumerNode ?? (e.liveConsumerNode = []), e.liveConsumerIndexOfThis ?? (e.liveConsumerIndexOfThis = []);
+}
+function ye(e) {
+  if ($e(e), F(e), e.value === ee)
+    throw e.error;
+  return e.value;
+}
+function Ge(e) {
+  const t = Object.create(Ke);
+  t.computation = e;
+  const r = () => ye(t);
+  return r[j] = t, r;
+}
+const J = /* @__PURE__ */ Symbol("UNSET"), Q = /* @__PURE__ */ Symbol("COMPUTING"), ee = /* @__PURE__ */ Symbol("ERRORED"), Ke = {
+  ...se,
+  value: J,
+  dirty: !0,
+  error: null,
+  equal: we,
+  producerMustRecompute(e) {
+    return e.value === J || e.value === Q;
+  },
+  producerRecomputeValue(e) {
+    if (e.value === Q)
+      throw new Error("Detected cycle in computations.");
+    const t = e.value;
+    e.value = Q;
+    const r = Fe(e);
+    let s, o = !1;
+    try {
+      s = e.computation.call(e.wrapper), o = t !== J && t !== ee && e.equal.call(e.wrapper, t, s);
+    } catch (i) {
+      s = ee, e.error = i;
+    } finally {
+      Ze(e, r);
+    }
+    if (o) {
+      e.value = t;
+      return;
+    }
+    e.value = s, e.version++;
+  }
+};
+function Ye() {
+  throw new Error();
+}
+let Je = Ye;
+function Qe() {
+  Je();
+}
+function Xe(e) {
+  const t = Object.create(rt);
+  t.value = e;
+  const r = () => (F(t), t.value);
+  return r[j] = t, r;
+}
+function et() {
+  return F(this), this.value;
+}
+function tt(e, t) {
+  je() || Qe(), e.equal.call(e.wrapper, e.value, t) || (e.value = t, st(e));
+}
+const rt = {
+  ...se,
+  equal: we,
+  value: void 0
+};
+function st(e) {
+  e.version++, Ue(), _e(e);
+}
+const $ = Symbol("node");
+var S;
+((e) => {
+  var t, r, s, o;
+  class i {
+    constructor(n, u = {}) {
+      D(this, r), K(this, t);
+      const c = Xe(n)[j];
+      if (this[$] = c, c.wrapper = this, u) {
+        const v = u.equals;
+        v && (c.equal = v), c.watched = u[e.subtle.watched], c.unwatched = u[e.subtle.unwatched];
+      }
+    }
+    get() {
+      if (!(0, e.isState)(this))
+        throw new TypeError("Wrong receiver type for Signal.State.prototype.get");
+      return et.call(this[$]);
+    }
+    set(n) {
+      if (!(0, e.isState)(this))
+        throw new TypeError("Wrong receiver type for Signal.State.prototype.set");
+      if (qe())
+        throw new Error("Writes to signals not permitted during Watcher callback");
+      const u = this[$];
+      tt(u, n);
+    }
+  }
+  t = $, r = /* @__PURE__ */ new WeakSet(), e.isState = (h) => typeof h == "object" && Y(r, h), e.State = i;
+  class a {
+    // Create a Signal which evaluates to the value returned by the callback.
+    // Callback is called with this signal as the parameter.
+    constructor(n, u) {
+      D(this, o), K(this, s);
+      const c = Ge(n)[j];
+      if (c.consumerAllowSignalWrites = !0, this[$] = c, c.wrapper = this, u) {
+        const v = u.equals;
+        v && (c.equal = v), c.watched = u[e.subtle.watched], c.unwatched = u[e.subtle.unwatched];
+      }
+    }
+    get() {
+      if (!(0, e.isComputed)(this))
+        throw new TypeError("Wrong receiver type for Signal.Computed.prototype.get");
+      return ye(this[$]);
+    }
+  }
+  s = $, o = /* @__PURE__ */ new WeakSet(), e.isComputed = (h) => typeof h == "object" && Y(o, h), e.Computed = a, ((h) => {
+    var n, u, d, c;
+    function v(f) {
+      let p, l = null;
+      try {
+        l = I(null), p = f();
+      } finally {
+        I(l);
+      }
+      return p;
+    }
+    h.untrack = v;
+    function m(f) {
+      var p;
+      if (!(0, e.isComputed)(f) && !(0, e.isWatcher)(f))
+        throw new TypeError("Called introspectSources without a Computed or Watcher argument");
+      return ((p = f[$].producerNode) == null ? void 0 : p.map((l) => l.wrapper)) ?? [];
+    }
+    h.introspectSources = m;
+    function _(f) {
+      var p;
+      if (!(0, e.isComputed)(f) && !(0, e.isState)(f))
+        throw new TypeError("Called introspectSinks without a Signal argument");
+      return ((p = f[$].liveConsumerNode) == null ? void 0 : p.map((l) => l.wrapper)) ?? [];
+    }
+    h.introspectSinks = _;
+    function N(f) {
+      if (!(0, e.isComputed)(f) && !(0, e.isState)(f))
+        throw new TypeError("Called hasSinks without a Signal argument");
+      const p = f[$].liveConsumerNode;
+      return p ? p.length > 0 : !1;
+    }
+    h.hasSinks = N;
+    function g(f) {
+      if (!(0, e.isComputed)(f) && !(0, e.isWatcher)(f))
+        throw new TypeError("Called hasSources without a Computed or Watcher argument");
+      const p = f[$].producerNode;
+      return p ? p.length > 0 : !1;
+    }
+    h.hasSources = g;
+    class z {
+      // When a (recursive) source of Watcher is written to, call this callback,
+      // if it hasn't already been called since the last `watch` call.
+      // No signals may be read or written during the notify.
+      constructor(p) {
+        D(this, u), D(this, d), K(this, n);
+        let l = Object.create(se);
+        l.wrapper = this, l.consumerMarkedDirty = p, l.consumerIsAlwaysLive = !0, l.consumerAllowSignalWrites = !1, l.producerNode = [], this[$] = l;
+      }
+      // Add these signals to the Watcher's set, and set the watcher to run its
+      // notify callback next time any signal in the set (or one of its dependencies) changes.
+      // Can be called with no arguments just to reset the "notified" state, so that
+      // the notify callback will be invoked again.
+      watch(...p) {
+        if (!(0, e.isWatcher)(this))
+          throw new TypeError("Called unwatch without Watcher receiver");
+        de(this, d, c).call(this, p);
+        const l = this[$];
+        l.dirty = !1;
+        const y = I(l);
+        for (const V of p)
+          F(V[$]);
+        I(y);
+      }
+      // Remove these signals from the watched set (e.g., for an effect which is disposed)
+      unwatch(...p) {
+        if (!(0, e.isWatcher)(this))
+          throw new TypeError("Called unwatch without Watcher receiver");
+        de(this, d, c).call(this, p);
+        const l = this[$];
+        O(l);
+        for (let y = l.producerNode.length - 1; y >= 0; y--)
+          if (p.includes(l.producerNode[y].wrapper)) {
+            Z(l.producerNode[y], l.producerIndexOfThis[y]);
+            const V = l.producerNode.length - 1;
+            if (l.producerNode[y] = l.producerNode[V], l.producerIndexOfThis[y] = l.producerIndexOfThis[V], l.producerNode.length--, l.producerIndexOfThis.length--, l.nextProducerIndex--, y < l.producerNode.length) {
+              const Te = l.producerIndexOfThis[y], ie = l.producerNode[y];
+              oe(ie), ie.liveConsumerIndexOfThis[Te] = y;
+            }
+          }
+      }
+      // Returns the set of computeds in the Watcher's set which are still yet
+      // to be re-evaluated
+      getPending() {
+        if (!(0, e.isWatcher)(this))
+          throw new TypeError("Called getPending without Watcher receiver");
+        return this[$].producerNode.filter((l) => l.dirty).map((l) => l.wrapper);
+      }
+    }
+    n = $, u = /* @__PURE__ */ new WeakSet(), d = /* @__PURE__ */ new WeakSet(), c = function(f) {
+      for (const p of f)
+        if (!(0, e.isComputed)(p) && !(0, e.isState)(p))
+          throw new TypeError("Called watch/unwatch without a Computed or State argument");
+    }, e.isWatcher = (f) => Y(u, f), h.Watcher = z;
+    function xe() {
+      var f;
+      return (f = De()) == null ? void 0 : f.wrapper;
+    }
+    h.currentComputed = xe, h.watched = Symbol("watched"), h.unwatched = Symbol("unwatched");
+  })(e.subtle || (e.subtle = {}));
+})(S || (S = {}));
+const ot = /* @__PURE__ */ new Set(["internals", "effect", "styleProps"]);
+function it(e) {
+  return `--${e.replaceAll(/([a-z0-9])([A-Z])/g, "$1-$2").replaceAll(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").toLowerCase()}`;
+}
+function ct(e, t, r) {
+  const { setup: s, attributes: o, styles: i } = Ce(e, t, r);
+  Ne({ setup: s, attributes: o, styles: i, useShadow: !1 });
+}
+function at(e, t, r) {
+  const { setup: s, attributes: o, styles: i } = Ce(e, t, r);
+  Ne({ setup: s, attributes: o, styles: i, useShadow: !0 });
+}
+function Ce(e, t, r) {
+  return typeof e == "function" ? { setup: e } : typeof e == "string" ? { styles: e, setup: t } : typeof t == "function" ? { attributes: e, setup: t } : { attributes: e, styles: t, setup: r };
+}
+const lt = (e) => new S.State(e);
+function Ne(e) {
+  const {
+    setup: t,
+    tagName: r,
+    attributes: s = [],
+    useShadow: o = !0,
+    formAssociated: i = !1,
+    styles: a
+  } = e, h = r ?? t.name.replaceAll(/([a-z0-9])([A-Z])/g, "$1-$2").replaceAll(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").toLowerCase();
+  if (!h.includes("-"))
+    throw new Error(`Function ${t.name} must include at least one capital letter to be converted to a valid custom element name`);
+  if (customElements.get(h))
+    throw new Error(`Custom element with name ${h} already defined`);
+  for (const u of s)
+    if (ot.has(u))
+      throw new Error(`Attribute name "${u}" conflicts with a reserved context property.`);
+  let n;
+  a !== void 0 && (n = new CSSStyleSheet(), o ? n.replaceSync(a) : (n.replaceSync(`@scope (${h}) { ${a} }`), document.adoptedStyleSheets = [
+    ...document.adoptedStyleSheets,
+    n
+  ])), customElements.define(h, class extends HTMLElement {
+    #e;
+    #t;
+    #s = [];
+    #r = [];
+    #o = /* @__PURE__ */ new Map();
+    static get observedAttributes() {
+      return s;
+    }
+    static get formAssociated() {
+      return i;
+    }
+    constructor() {
+      super(), o && this.attachShadow({ mode: "open" }), n && this.shadowRoot && (this.shadowRoot.adoptedStyleSheets = [
+        ...this.shadowRoot.adoptedStyleSheets,
+        n
+      ]);
+      const u = {
+        internals: this.attachInternals(),
+        effect: (m) => {
+          this.#s.push(m);
+        },
+        styleProps: (m) => {
+          for (const _ in m) {
+            const N = m[_], g = it(_);
+            N === null ? this.style.removeProperty(g) : this.style.setProperty(g, String(N));
+          }
+        }
+      };
+      s.forEach((m) => {
+        const _ = new S.State(this.getAttribute(m), {
+          equals: (g, z) => g === z
+        });
+        this.#o.set(m, _), u[m] = _, Object.defineProperty(this, m, {
+          get() {
+            return _.get();
+          },
+          set(g) {
+            if (g !== null && typeof g != "string")
+              throw new TypeError(`Attribute "${m}" only accepts strings or null, got ${typeof g}.`);
+            _.set(g);
+          },
+          enumerable: !0,
+          configurable: !0
+        });
+        const N = new S.subtle.Watcher(() => {
+          queueMicrotask(() => {
+            const g = _.get();
+            g === null ? this.removeAttribute(m) : this.setAttribute(m, g), N.watch();
+          });
+        });
+        N.watch(_);
+      });
+      const d = t.call(this, u);
+      this.#e = new S.Computed(() => d());
+      const c = () => He(this.#e.get(), o ? this.shadowRoot : this);
+      let v = !1;
+      this.#t = new S.subtle.Watcher(() => {
+        v || (v = !0, queueMicrotask(() => {
+          v = !1, c(), this.#t.watch();
+        }));
+      }), this.#t.watch(this.#e), c();
+    }
+    connectedCallback() {
+      this.#t.watch(this.#e), this.#r = this.#s.map((u) => u()).filter(
+        (u) => typeof u == "function"
+      );
+    }
+    disconnectedCallback() {
+      this.#t.unwatch(this.#e), this.#r.forEach((u) => u()), this.#r = [];
+    }
+    attributeChangedCallback(u, d, c) {
+      this.#o.get(u)?.set(c);
+    }
+  });
+}
+export {
+  Ne as define,
+  nt as html,
+  ct as lightElement,
+  at as shadowElement,
+  lt as state,
+  ut as svg
+};