@tempots/dom 31.5.0 → 31.6.1

package/index.js

@@ -1,66 +1,56 @@
-var We = Object.defineProperty;
-var pe = (s) => {
-  throw TypeError(s);
-};
-var Ue = (s, e, t) => e in s ? We(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
-var o = (s, e, t) => Ue(s, typeof e != "symbol" ? e + "" : e, t), ge = (s, e, t) => e.has(s) || pe("Cannot " + t);
-var J = (s, e, t) => (ge(s, e, "read from private field"), t ? t.call(s) : e.get(s)), me = (s, e, t) => e.has(s) ? pe("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(s) : e.set(s, t), le = (s, e, t, r) => (ge(s, e, "write to private field"), r ? r.call(s, t) : e.set(s, t), t);
-const Je = (s, e, t) => s + (e - s) * t;
-const Ge = (s, e, t) => {
-  const r = Math.max(s.length, e.length);
+const ke = (t, e, s) => t + (e - t) * s;
+const $e = (t, e, s) => {
+  const r = Math.max(t.length, e.length);
   let n = "";
   for (let i = 0; i < r; i++) {
-    let l = s.charCodeAt(i);
-    isNaN(l) && (l = 97);
-    let c = e.charCodeAt(i);
-    isNaN(c) && (c = 97), n += String.fromCharCode(l + (c - l) * t);
+    let o = t.charCodeAt(i);
+    isNaN(o) && (o = 97);
+    let l = e.charCodeAt(i);
+    isNaN(l) && (l = 97), n += String.fromCharCode(o + (l - o) * s);
   }
   return n;
-}, Xe = (s, e, t) => new Date(s.getTime() + (e.getTime() - s.getTime()) * t), Ye = (s, e) => e, Qe = (s) => typeof s == "number" ? Je : typeof s == "string" ? Ge : s instanceof Date ? Xe : Ye;
-var M;
-class ce {
+}, Ne = (t, e, s) => new Date(t.getTime() + (e.getTime() - t.getTime()) * s), Re = (t, e) => e, Ve = (t) => typeof t == "number" ? ke : typeof t == "string" ? $e : t instanceof Date ? Ne : Re;
+class se {
   /**
    * Creates a new instance of `ElementPosition`.
    * @param index - The index of the element.
    * @param total - The total number of elements in the collection.
    */
-  constructor(e, t) {
-    /**
-     * The counter of the element starting from 1.
-     */
-    o(this, "counter");
-    /**
-     * Checks if the element is the first element in the collection.
-     * @returns `true` if the element is the first element, `false` otherwise.
-     */
-    o(this, "isFirst");
-    /**
-     * Checks if the counter of the element is even.
-     * @returns `true` if the counter is even, `false` otherwise.
-     */
-    o(this, "isEven");
-    /**
-     * Checks if the counter of the element is odd.
-     * @returns `true` if the counter is odd, `false` otherwise.
-     */
-    o(this, "isOdd");
-    me(this, M);
-    o(this, "dispose", () => {
-      var e;
-      (e = J(this, M)) == null || e.dispose(), le(this, M, void 0);
-    });
-    this.index = e, this.total = t, this.counter = e + 1, this.isFirst = e === 0, this.isEven = e % 2 === 1, this.isOdd = e % 2 === 0;
+  constructor(e, s) {
+    this.index = e, this.total = s, this.counter = e + 1, this.isFirst = e === 0, this.isEven = e % 2 === 1, this.isOdd = e % 2 === 0;
   }
+  /**
+   * The counter of the element starting from 1.
+   */
+  counter;
+  /**
+   * Checks if the element is the first element in the collection.
+   * @returns `true` if the element is the first element, `false` otherwise.
+   */
+  isFirst;
+  /**
+   * Checks if the counter of the element is even.
+   * @returns `true` if the counter is even, `false` otherwise.
+   */
+  isEven;
+  /**
+   * Checks if the counter of the element is odd.
+   * @returns `true` if the counter is odd, `false` otherwise.
+   */
+  isOdd;
+  #e;
   /**
    * Checks if the element is the last element in the collection.
    * @returns `true` if the element is the last element, `false` otherwise.
    */
   get isLast() {
-    return J(this, M) == null && le(this, M, this.total.map((e) => this.counter === e)), J(this, M);
+    return this.#e == null && (this.#e = this.total.map((e) => this.counter === e)), this.#e;
   }
+  dispose = () => {
+    this.#e?.dispose(), this.#e = void 0;
+  };
 }
-M = new WeakMap();
-const F = class F {
+class m {
   /**
    * Represents a signal with a value of type T.
    *
@@ -68,316 +58,94 @@ const F = class F {
    * @param equals - A function that determines whether two values of type T are equal.
    * @public
    */
-  constructor(e, t) {
-    /**
-     * @internal
-     */
-    o(this, "$__signal__", !0);
-    /**
-     * @internal
-     */
-    o(this, "_value");
-    /**
-     * @internal
-     */
-    o(this, "_derivatives", []);
-    /**
-     * @internal
-     */
-    o(this, "_onValueListeners", []);
-    /**
-     * @internal
-     */
-    o(this, "_onDisposeListeners", []);
-    /**
-     * Gets the current value of the signal.
-     * @returns The current value of the signal.
-     */
-    o(this, "get", () => this._value);
-    /**
-     * Checks if the signal has any registered listeners.
-     * @returns `true` if the signal has listeners, `false` otherwise.
-     */
-    o(this, "hasListeners", () => this._onValueListeners.length > 0);
-    /**
-     * Registers a listener function to be called whenever the value of the signal changes.
-     * The listener function will be immediately called with the current value of the signal.
-     * Returns a function that can be called to unregister the listener.
-     *
-     * @param listener - The listener function to be called when the value of the signal changes.
-     * @param options - Options for the listener.
-     */
-    o(this, "on", (e, t = {}) => {
-      t.skipInitial || e(this.get(), void 0);
-      const r = t.once ? (i, l) => {
-        n(), e(i, l);
-      } : e;
-      this._onValueListeners.push(r);
-      const n = () => {
-        this._onValueListeners.splice(
-          this._onValueListeners.indexOf(r),
-          1
-        ), t.abortSignal != null && t.abortSignal.removeEventListener("abort", n);
-      };
-      return t.abortSignal != null && t.abortSignal.addEventListener("abort", n), n;
-    });
-    /**
-     * @internal
-     */
-    o(this, "_setAndNotify", (e) => {
-      if (this._disposed) return;
-      const t = this._value;
-      this.equals(t, e) || (this._value = e, this._onValueListeners.forEach((n) => n(e, t)));
-    });
-    /**
-     * @internal
-     */
-    o(this, "_disposed", !1);
-    /**
-     * Checks whether the signal is disposed.
-     * @returns True if the signal is disposed, false otherwise.
-     */
-    o(this, "isDisposed", () => this._disposed);
-    /**
-     * Adds a listener function to be called when the object is disposed.
-     * @param listener - The listener function to be called when the object is disposed.
-     * @returns A function that can be called to remove the listener.
-     */
-    o(this, "onDispose", (e) => {
-      this._onDisposeListeners.push(e);
-    });
-    /**
-     * Disposes the signal, releasing any resources associated with it.
-     */
-    o(this, "dispose", () => {
-      this._disposed || (this._disposed = !0, this._onDisposeListeners.forEach((e) => e()), this._onDisposeListeners.length = 0, this._derivatives.length = 0);
-    });
-    /**
-     * Creates a new computed signal by applying a transformation function to this signal's value.
-     *
-     * The `map` method is one of the most commonly used signal operations. It creates a new
-     * computed signal that automatically updates whenever the source signal changes. The
-     * transformation function is called with the current value and should return the new value.
-     *
-     * @example
-     * ```typescript
-     * const count = prop(5)
-     *
-     * // Transform to different types
-     * const doubled = count.map(n => n * 2)
-     * const message = count.map(n => `Count is ${n}`)
-     * const isEven = count.map(n => n % 2 === 0)
-     *
-     * // Use in UI
-     * html.div(
-     *   html.div('Original: ', count.map(String)),
-     *   html.div('Doubled: ', doubled.map(String)),
-     *   html.div('Message: ', message),
-     *   html.div('Is even: ', isEven.map(String))
-     * )
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Chain multiple transformations
-     * const user = prop({ name: 'John', age: 30 })
-     * const greeting = user
-     *   .map(u => u.name)
-     *   .map(name => name.toUpperCase())
-     *   .map(name => `Hello, ${name}!`)
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // With custom equality function for objects
-     * const items = prop([{ id: 1, name: 'Item 1' }])
-     * const itemNames = items.map(
-     *   items => items.map(item => item.name),
-     *   (a, b) => JSON.stringify(a) === JSON.stringify(b) // deep equality
-     * )
-     * ```
-     *
-     * @typeParam O - The type of the transformed value
-     * @param fn - Function that transforms the signal's value to a new value
-     * @param equals - Optional function to determine if two transformed values are equal (defaults to strict equality)
-     * @returns A new computed signal with the transformed value
-     */
-    o(this, "map", (e, t = (r, n) => r === n) => {
-      const r = new N(() => {
-        try {
-          return e(this.get());
-        } catch (n) {
-          throw console.error("Error in Signal.map:", n), n;
-        }
-      }, t);
-      return this.setDerivative(r), r;
-    });
-    /**
-     * Returns a new Signal that applies the given function to the value of the current Signal,
-     * and then flattens the resulting Signal.
-     *
-     * @typeParam O - The type of the value emitted by the resulting Signal.
-     * @param fn - The function to apply to the value of the current Signal.
-     * @param equals - A function that determines whether two values of type O are equal.
-     *               Defaults to a strict equality check (===).
-     * @returns A new Signal that emits the values of the resulting Signal.
-     */
-    o(this, "flatMap", (e, t = (r, n) => r === n) => {
-      const r = new N(() => {
-        try {
-          return e(this.get()).get();
-        } catch (n) {
-          throw console.error("Error in Signal.flatMap:", n), n;
-        }
-      }, t);
-      return this.setDerivative(r), r;
-    });
-    /**
-     * Invokes a callback function with the current value of the signal, without modifying the signal.
-     *
-     * @param fn - The callback function to be invoked with the current value of the signal.
-     * @returns A new signal that emits the same value as the original signal and invokes the callback function.
-     */
-    o(this, "tap", (e) => this.map((t) => (e(t), t)));
-    /**
-     * Returns a new Signal that emits the value at the specified key of the current value.
-     *
-     * @param key - The key of the value to retrieve.
-     * @returns A new Signal that emits the value at the specified key.
-     */
-    o(this, "at", (e) => this.map((t) => t[e]));
-    /**
-     * @internal
-     */
-    o(this, "_$");
-    o(this, "filter", (e, t) => {
-      let r = t ?? this.get();
-      const n = new N(() => {
-        try {
-          const i = this.get();
-          return r = e(i) ? i : r;
-        } catch (i) {
-          throw console.error("Error in Signal.filter:", i), i;
-        }
-      }, this.equals);
-      return this.setDerivative(n), n;
-    });
-    /**
-     * Returns a new Computed object that applies the provided mapping function to the value of this Signal,
-     * and filters out values that are `undefined` or `null`.
-     *
-     * @typeParam O - The type of the mapped value.
-     * @param fn - The mapping function to apply to the value of this Signal.
-     * @param startValue - The initial value for the Computed object.
-     * @param equals - Optional equality function to determine if two values are equal.
-     * @returns - A new Computed object with the mapped and filtered values.
-     */
-    o(this, "filterMap", (e, t, r = (n, i) => n === i) => {
-      let n = t;
-      const i = new N(() => {
-        try {
-          const l = this.get(), c = e(l);
-          return n = c ?? n;
-        } catch (l) {
-          throw console.error("Error in Signal.filterMap:", l), l;
-        }
-      }, r);
-      return this.setDerivative(i), i;
-    });
-    /**
-     * Maps the values emitted by the signal to a new value asynchronously using the provided function.
-     * If the function throws an error, it will be caught and logged.
-     * If a recovery function is provided, it will be called with the error and its return value will be used as the mapped value.
-     * If no recovery function is provided, the error will be logged as an unhandled promise rejection.
-     *
-     * @typeParam O - The type of the mapped value.
-     * @param fn - The function to map the values emitted by the signal. The second argument to this function allows to cancel the previously running mapping function if it has not completed by the time a new value is emitted.
-     * @param alt - The alternate value to use if the signal is disposed or the mapping function throws an error.
-     * @param recover - The recovery function to handle errors thrown by the mapping function.
-     * @param equals - The equality function to compare the mapped values for equality.
-     * @returns A property that holds the mapped value and can be observed for changes.
-     */
-    o(this, "mapAsync", (e, t, r, n = (i, l) => i === l) => {
-      const i = w(t, n);
-      let l = 0, c = new AbortController();
-      return i.onDispose(
-        this.on(async (a) => {
-          const u = ++l;
-          c.abort(), c = new AbortController();
-          try {
-            const h = await e(a, { abortSignal: c.signal });
-            u === l && i.set(h);
-          } catch (h) {
-            if (u === l)
-              if (r != null)
-                i.set(r(h));
-              else
-                throw h;
-          }
-        })
-      ), i;
-    });
-    /**
-     * Maps the values of the signal using the provided function `fn`, and returns a new signal
-     * containing the mapped values. If the mapped value is `undefined` or `null`, it is replaced
-     * with the provided `alt` value.
-     *
-     * @typeParam O - The type of the mapped value.
-     * @param fn - The function used to map the values of the signal.
-     * @param alt - The alternative value to use when the mapped value is `undefined` or `null`.
-     * @returns A new signal containing the mapped values.
-     */
-    o(this, "mapMaybe", (e, t) => this.map((r) => e(r) ?? t));
-    /**
-     * Feeds a property into the signal and sets up disposal behavior.
-     * @param prop - The property to feed into the signal.
-     * @param autoDisposeProp - Determines whether the property should be automatically disposed when the signal is disposed.
-     * @returns The input property.
-     */
-    o(this, "feedProp", (e, t = !1) => {
-      const r = this.on(e.set);
-      return e.onDispose(r), t ? this.onDispose(e.dispose) : this.onDispose(r), e;
-    });
-    /**
-     * Derives a new property from the current signal.
-     * @param options - The options for the derived property.
-     * @param options.autoDisposeProp - Determines whether the derived property should be automatically disposed.
-     * @param options.equals - A function that determines if two values are equal.
-     * @returns The derived property.
-     */
-    o(this, "deriveProp", ({
-      autoDisposeProp: e = !0,
-      equals: t
-    } = {}) => this.feedProp(w(this.get(), t), e));
-    /**
-     * Derives a new signal from the current signal. Useful to create a new signal that emits the same values as the current signal but can be disposed independently.
-     * @returns A new signal that emits the same values as the current signal.
-     */
-    o(this, "derive", () => this.map((e) => e));
-    /**
-     * Returns a signal that emits the count of values received so far.
-     * @returns A signal that emits the count of values received so far.
-     */
-    o(this, "count", () => {
-      let e = 0;
-      return this.map(() => ++e);
-    });
-    /**
-     * Adds a computed value as a derivative of the signal.
-     * When the computed value is disposed, it is automatically removed from the derivatives list.
-     * Additionally, when the computed value is disposed, it sets the signal as dirty.
-     * @param computed - The computed value to add as a derivative.
-     */
-    o(this, "setDerivative", (e) => {
-      this._derivatives.push(e), e.onDispose(() => {
-        this._derivatives.splice(
-          this._derivatives.indexOf(e),
-          1
-        );
-      }), e.onDispose(this.on(e.setDirty)), this.onDispose(e.dispose);
-    });
-    this.equals = t, this._value = e;
+  constructor(e, s) {
+    this.equals = s, this._value = e;
   }
+  /**
+   * Creates a Signal that holds the result of a Promise, with proper error handling.
+   *
+   * This static method creates a signal that starts with an initial value and updates
+   * when the promise resolves. If the promise rejects, an optional recovery function
+   * can provide a fallback value.
+   *
+   * @example
+   * ```typescript
+   * // Basic usage with API call
+   * const userData = Signal.ofPromise(
+   *   fetch('/api/user').then(r => r.json()),
+   *   { loading: true }, // initial state
+   *   error => ({ error: error.message, loading: false }) // error recovery
+   * )
+   *
+   * // Use in UI
+   * Ensure(userData,
+   *   (user) => html.div('Welcome, ', user.map(u => u.name)),
+   *   () => html.div('Loading...')
+   * )
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // With custom equality function
+   * const config = Signal.ofPromise(
+   *   loadConfig(),
+   *   {},
+   *   () => ({}),
+   *   (a, b) => JSON.stringify(a) === JSON.stringify(b) // deep equality
+   * )
+   * ```
+   *
+   * @typeParam O - The type of the value returned by the Promise
+   * @param promise - The Promise to use to feed the Signal
+   * @param init - The initial value of the Signal before the Promise resolves
+   * @param recover - Optional function to recover from Promise rejection and provide an alternative value
+   * @param equals - Function to compare two values for equality (defaults to strict equality)
+   * @returns A Signal that represents the result of the Promise
+   */
+  static ofPromise = (e, s, r, n = (i, o) => i === o) => {
+    const i = new m(s, n);
+    return e.then((o) => i._setAndNotify(o)).catch((o) => {
+      r != null ? i._setAndNotify(r(o)) : console.error(
+        "Unhandled promise rejection in Signal.ofPromise:",
+        o
+      );
+    }), i;
+  };
+  /**
+   * Checks if a value is a Signal.
+   *
+   * @param value - The value to check.
+   * @returns `true` if the value is a Signal, `false` otherwise.
+   */
+  static is = (e) => (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    e != null && e.$__signal__ === !0
+  );
+  /**
+   * @internal
+   */
+  $__signal__ = !0;
+  /**
+   * @internal
+   */
+  _value;
+  /**
+   * @internal
+   */
+  _derivatives = [];
+  /**
+   * @internal
+   */
+  _onValueListeners = [];
+  /**
+   * @internal
+   */
+  _onDisposeListeners = [];
+  /**
+   * Gets the current value of the signal.
+   * @returns The current value of the signal.
+   */
+  get = () => this._value;
   /**
    * Gets the value of the signal.
    * @returns The current value of the signal.
@@ -385,119 +153,307 @@ const F = class F {
   get value() {
     return this._value;
   }
+  /**
+   * Checks if the signal has any registered listeners.
+   * @returns `true` if the signal has listeners, `false` otherwise.
+   */
+  hasListeners = () => this._onValueListeners.length > 0;
+  /**
+   * Registers a listener function to be called whenever the value of the signal changes.
+   * The listener function will be immediately called with the current value of the signal.
+   * Returns a function that can be called to unregister the listener.
+   *
+   * @param listener - The listener function to be called when the value of the signal changes.
+   * @param options - Options for the listener.
+   */
+  on = (e, s = {}) => {
+    s.skipInitial || e(this.get(), void 0);
+    const r = s.once ? (i, o) => {
+      n(), e(i, o);
+    } : e;
+    this._onValueListeners.push(r);
+    const n = () => {
+      this._onValueListeners.splice(
+        this._onValueListeners.indexOf(r),
+        1
+      ), s.abortSignal != null && s.abortSignal.removeEventListener("abort", n);
+    };
+    return s.abortSignal != null && s.abortSignal.addEventListener("abort", n), n;
+  };
+  /**
+   * @internal
+   */
+  _setAndNotify = (e) => {
+    if (this._disposed) return;
+    const s = this._value;
+    this.equals(s, e) || (this._value = e, this._onValueListeners.forEach((n) => n(e, s)));
+  };
+  /**
+   * @internal
+   */
+  _disposed = !1;
+  /**
+   * Checks whether the signal is disposed.
+   * @returns True if the signal is disposed, false otherwise.
+   */
+  isDisposed = () => this._disposed;
+  /**
+   * Adds a listener function to be called when the object is disposed.
+   * @param listener - The listener function to be called when the object is disposed.
+   * @returns A function that can be called to remove the listener.
+   */
+  onDispose = (e) => {
+    this._onDisposeListeners.push(e);
+  };
+  /**
+   * Disposes the signal, releasing any resources associated with it.
+   */
+  dispose = () => {
+    this._disposed || (this._disposed = !0, this._onDisposeListeners.forEach((e) => e()), this._onDisposeListeners.length = 0, this._derivatives.length = 0);
+  };
+  /**
+   * Creates a new computed signal by applying a transformation function to this signal's value.
+   *
+   * The `map` method is one of the most commonly used signal operations. It creates a new
+   * computed signal that automatically updates whenever the source signal changes. The
+   * transformation function is called with the current value and should return the new value.
+   *
+   * @example
+   * ```typescript
+   * const count = prop(5)
+   *
+   * // Transform to different types
+   * const doubled = count.map(n => n * 2)
+   * const message = count.map(n => `Count is ${n}`)
+   * const isEven = count.map(n => n % 2 === 0)
+   *
+   * // Use in UI
+   * html.div(
+   *   html.div('Original: ', count.map(String)),
+   *   html.div('Doubled: ', doubled.map(String)),
+   *   html.div('Message: ', message),
+   *   html.div('Is even: ', isEven.map(String))
+   * )
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Chain multiple transformations
+   * const user = prop({ name: 'John', age: 30 })
+   * const greeting = user
+   *   .map(u => u.name)
+   *   .map(name => name.toUpperCase())
+   *   .map(name => `Hello, ${name}!`)
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // With custom equality function for objects
+   * const items = prop([{ id: 1, name: 'Item 1' }])
+   * const itemNames = items.map(
+   *   items => items.map(item => item.name),
+   *   (a, b) => JSON.stringify(a) === JSON.stringify(b) // deep equality
+   * )
+   * ```
+   *
+   * @typeParam O - The type of the transformed value
+   * @param fn - Function that transforms the signal's value to a new value
+   * @param equals - Optional function to determine if two transformed values are equal (defaults to strict equality)
+   * @returns A new computed signal with the transformed value
+   */
+  map = (e, s = (r, n) => r === n) => {
+    const r = new H(() => {
+      try {
+        return e(this.get());
+      } catch (n) {
+        throw console.error("Error in Signal.map:", n), n;
+      }
+    }, s);
+    return this.setDerivative(r), r;
+  };
+  /**
+   * Returns a new Signal that applies the given function to the value of the current Signal,
+   * and then flattens the resulting Signal.
+   *
+   * @typeParam O - The type of the value emitted by the resulting Signal.
+   * @param fn - The function to apply to the value of the current Signal.
+   * @param equals - A function that determines whether two values of type O are equal.
+   *               Defaults to a strict equality check (===).
+   * @returns A new Signal that emits the values of the resulting Signal.
+   */
+  flatMap = (e, s = (r, n) => r === n) => {
+    const r = new H(() => {
+      try {
+        return e(this.get()).get();
+      } catch (n) {
+        throw console.error("Error in Signal.flatMap:", n), n;
+      }
+    }, s);
+    return this.setDerivative(r), r;
+  };
+  /**
+   * Invokes a callback function with the current value of the signal, without modifying the signal.
+   *
+   * @param fn - The callback function to be invoked with the current value of the signal.
+   * @returns A new signal that emits the same value as the original signal and invokes the callback function.
+   */
+  tap = (e) => this.map((s) => (e(s), s));
+  /**
+   * Returns a new Signal that emits the value at the specified key of the current value.
+   *
+   * @param key - The key of the value to retrieve.
+   * @returns A new Signal that emits the value at the specified key.
+   */
+  at = (e) => this.map((s) => s[e]);
+  /**
+   * @internal
+   */
+  _$;
   /**
    * Represents a collection of signals mapping to each key/field in the wrapped value.
    * @typeParam T - The type of the signals.
    */
   get $() {
     return this._$ !== void 0 ? this._$ : this._$ = new Proxy(this, {
-      get: (e, t) => this.at(t)
+      get: (e, s) => this.at(s)
     });
   }
-};
-/**
- * Creates a Signal that holds the result of a Promise, with proper error handling.
- *
- * This static method creates a signal that starts with an initial value and updates
- * when the promise resolves. If the promise rejects, an optional recovery function
- * can provide a fallback value.
- *
- * @example
- * ```typescript
- * // Basic usage with API call
- * const userData = Signal.ofPromise(
- *   fetch('/api/user').then(r => r.json()),
- *   { loading: true }, // initial state
- *   error => ({ error: error.message, loading: false }) // error recovery
- * )
- *
- * // Use in UI
- * Ensure(userData,
- *   (user) => html.div('Welcome, ', user.map(u => u.name)),
- *   () => html.div('Loading...')
- * )
- * ```
- *
- * @example
- * ```typescript
- * // With custom equality function
- * const config = Signal.ofPromise(
- *   loadConfig(),
- *   {},
- *   () => ({}),
- *   (a, b) => JSON.stringify(a) === JSON.stringify(b) // deep equality
- * )
- * ```
- *
- * @typeParam O - The type of the value returned by the Promise
- * @param promise - The Promise to use to feed the Signal
- * @param init - The initial value of the Signal before the Promise resolves
- * @param recover - Optional function to recover from Promise rejection and provide an alternative value
- * @param equals - Function to compare two values for equality (defaults to strict equality)
- * @returns A Signal that represents the result of the Promise
- */
-o(F, "ofPromise", (e, t, r, n = (i, l) => i === l) => {
-  const i = new F(t, n);
-  return e.then((l) => i._setAndNotify(l)).catch((l) => {
-    r != null ? i._setAndNotify(r(l)) : console.error(
-      "Unhandled promise rejection in Signal.ofPromise:",
-      l
-    );
-  }), i;
-}), /**
- * Checks if a value is a Signal.
- *
- * @param value - The value to check.
- * @returns `true` if the value is a Signal, `false` otherwise.
- */
-o(F, "is", (e) => (
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  e != null && e.$__signal__ === !0
-));
-let d = F;
-const Ze = typeof queueMicrotask == "function" ? queueMicrotask : (s) => Promise.resolve().then(s);
-class N extends d {
+  filter = (e, s) => {
+    let r = s ?? this.get();
+    const n = new H(() => {
+      try {
+        const i = this.get();
+        return r = e(i) ? i : r;
+      } catch (i) {
+        throw console.error("Error in Signal.filter:", i), i;
+      }
+    }, this.equals);
+    return this.setDerivative(n), n;
+  };
+  /**
+   * Returns a new Computed object that applies the provided mapping function to the value of this Signal,
+   * and filters out values that are `undefined` or `null`.
+   *
+   * @typeParam O - The type of the mapped value.
+   * @param fn - The mapping function to apply to the value of this Signal.
+   * @param startValue - The initial value for the Computed object.
+   * @param equals - Optional equality function to determine if two values are equal.
+   * @returns - A new Computed object with the mapped and filtered values.
+   */
+  filterMap = (e, s, r = (n, i) => n === i) => {
+    let n = s;
+    const i = new H(() => {
+      try {
+        const o = this.get(), l = e(o);
+        return n = l ?? n;
+      } catch (o) {
+        throw console.error("Error in Signal.filterMap:", o), o;
+      }
+    }, r);
+    return this.setDerivative(i), i;
+  };
+  /**
+   * Maps the values emitted by the signal to a new value asynchronously using the provided function.
+   * If the function throws an error, it will be caught and logged.
+   * If a recovery function is provided, it will be called with the error and its return value will be used as the mapped value.
+   * If no recovery function is provided, the error will be logged as an unhandled promise rejection.
+   *
+   * @typeParam O - The type of the mapped value.
+   * @param fn - The function to map the values emitted by the signal. The second argument to this function allows to cancel the previously running mapping function if it has not completed by the time a new value is emitted.
+   * @param alt - The alternate value to use if the signal is disposed or the mapping function throws an error.
+   * @param recover - The recovery function to handle errors thrown by the mapping function.
+   * @param equals - The equality function to compare the mapped values for equality.
+   * @returns A property that holds the mapped value and can be observed for changes.
+   */
+  mapAsync = (e, s, r, n = (i, o) => i === o) => {
+    const i = _(s, n);
+    let o = 0, l = new AbortController();
+    return i.onDispose(
+      this.on(async (c) => {
+        const a = ++o;
+        l.abort(), l = new AbortController();
+        try {
+          const u = await e(c, { abortSignal: l.signal });
+          a === o && i.set(u);
+        } catch (u) {
+          if (a === o)
+            if (r != null)
+              i.set(r(u));
+            else
+              throw u;
+        }
+      })
+    ), i;
+  };
+  /**
+   * Maps the values of the signal using the provided function `fn`, and returns a new signal
+   * containing the mapped values. If the mapped value is `undefined` or `null`, it is replaced
+   * with the provided `alt` value.
+   *
+   * @typeParam O - The type of the mapped value.
+   * @param fn - The function used to map the values of the signal.
+   * @param alt - The alternative value to use when the mapped value is `undefined` or `null`.
+   * @returns A new signal containing the mapped values.
+   */
+  mapMaybe = (e, s) => this.map((r) => e(r) ?? s);
+  /**
+   * Feeds a property into the signal and sets up disposal behavior.
+   * @param prop - The property to feed into the signal.
+   * @param autoDisposeProp - Determines whether the property should be automatically disposed when the signal is disposed.
+   * @returns The input property.
+   */
+  feedProp = (e, s = !1) => {
+    const r = this.on(e.set);
+    return e.onDispose(r), s ? this.onDispose(e.dispose) : this.onDispose(r), e;
+  };
+  /**
+   * Derives a new property from the current signal.
+   * @param options - The options for the derived property.
+   * @param options.autoDisposeProp - Determines whether the derived property should be automatically disposed.
+   * @param options.equals - A function that determines if two values are equal.
+   * @returns The derived property.
+   */
+  deriveProp = ({
+    autoDisposeProp: e = !0,
+    equals: s
+  } = {}) => this.feedProp(_(this.get(), s), e);
+  /**
+   * Derives a new signal from the current signal. Useful to create a new signal that emits the same values as the current signal but can be disposed independently.
+   * @returns A new signal that emits the same values as the current signal.
+   */
+  derive = () => this.map((e) => e);
+  /**
+   * Returns a signal that emits the count of values received so far.
+   * @returns A signal that emits the count of values received so far.
+   */
+  count = () => {
+    let e = 0;
+    return this.map(() => ++e);
+  };
+  /**
+   * Adds a computed value as a derivative of the signal.
+   * When the computed value is disposed, it is automatically removed from the derivatives list.
+   * Additionally, when the computed value is disposed, it sets the signal as dirty.
+   * @param computed - The computed value to add as a derivative.
+   */
+  setDerivative = (e) => {
+    this._derivatives.push(e), e.onDispose(() => {
+      this._derivatives.splice(
+        this._derivatives.indexOf(e),
+        1
+      );
+    }), e.onDispose(this.on(e.setDirty)), this.onDispose(e.dispose);
+  };
+}
+const je = typeof queueMicrotask == "function" ? queueMicrotask : (t) => Promise.resolve().then(t);
+class H extends m {
   /**
    * Represents a Signal object.
    * @param _fn - The function that returns the value of the signal.
    * @param equals - The function used to compare two values of type T for equality.
    */
-  constructor(t, r) {
-    super(void 0, r);
-    /**
-     * @internal
-     */
-    o(this, "$__computed__", !0);
-    /**
-     * @internal
-     */
-    o(this, "_isDirty", !1);
-    /**
-     * Marks the signal as dirty, indicating that its value has changed and needs to be recalculated.
-     * If the signal is already dirty or disposed, this method does nothing.
-     * It also marks all dependent signals as dirty and schedules a notification to update their values.
-     */
-    o(this, "setDirty", () => {
-      this._isDirty || this._disposed || (this._isDirty = !0, this._derivatives.forEach((t) => t.setDirty()), this._scheduleNotify());
-    });
-    /**
-     * @internal
-     */
-    o(this, "_scheduleCount", 0);
-    /**
-     * Schedules a notification to be executed asynchronously.
-     * If the signal is dirty, it will be updated and notified.
-     * @internal
-     */
-    o(this, "_scheduleNotify", () => {
-      const t = ++this._scheduleCount;
-      Ze(() => {
-        this._scheduleCount !== t || this._disposed || this._isDirty && (this._isDirty = !1, this._setAndNotify(this._fn()));
-      });
-    });
-    /** {@inheritDoc Signal.get} */
-    o(this, "get", () => (this._isDirty && (this._isDirty = !1, this._setAndNotify(this._fn())), this._value));
-    this._fn = t, this.setDirty();
+  constructor(e, s) {
+    super(void 0, s), this._fn = e, this.setDirty();
   }
   /**
    * Checks if a value is an instance of `Computed`.
@@ -505,135 +461,164 @@ class N extends d {
    * @param value - The value to check.
    * @returns `true` if the value is an instance of `Computed`, `false` otherwise.
    */
-  static is(t) {
-    return t != null && t.$__computed__ === !0;
+  static is(e) {
+    return e != null && e.$__computed__ === !0;
   }
+  /**
+   * @internal
+   */
+  $__computed__ = !0;
+  /**
+   * @internal
+   */
+  _isDirty = !1;
+  /**
+   * Marks the signal as dirty, indicating that its value has changed and needs to be recalculated.
+   * If the signal is already dirty or disposed, this method does nothing.
+   * It also marks all dependent signals as dirty and schedules a notification to update their values.
+   */
+  setDirty = () => {
+    this._isDirty || this._disposed || (this._isDirty = !0, this._derivatives.forEach((e) => e.setDirty()), this._scheduleNotify());
+  };
+  /**
+   * @internal
+   */
+  _scheduleCount = 0;
+  /**
+   * Schedules a notification to be executed asynchronously.
+   * If the signal is dirty, it will be updated and notified.
+   * @internal
+   */
+  _scheduleNotify = () => {
+    const e = ++this._scheduleCount;
+    je(() => {
+      this._scheduleCount !== e || this._disposed || this._isDirty && (this._isDirty = !1, this._setAndNotify(this._fn()));
+    });
+  };
+  /** {@inheritDoc Signal.get} */
+  get = () => (this._isDirty && (this._isDirty = !1, this._setAndNotify(this._fn())), this._value);
   /** {@inheritDoc Signal.value} */
   get value() {
     return this.get();
   }
 }
-const te = class te extends d {
-  constructor() {
-    super(...arguments);
-    /**
-     * @internal
-     */
-    o(this, "$__prop__", !0);
-    /**
-     * Changes the value of the property and notifies its listeners.
-     *
-     * @param value - The new value of the property.
-     */
-    o(this, "set", (t) => {
-      this._setAndNotify(t);
-    });
-    /**
-     * Updates the value of the signal by applying the provided function to the current value.
-     * @param fn - The function to apply to the current value.
-     */
-    o(this, "update", (t) => {
-      this._setAndNotify(t(this.get()));
-    });
-    /**
-     * Creates a reducer function that combines the provided reducer function and effects.
-     * @param fn - The reducer function that takes the current state and an action, and returns the new state.
-     * @param effects - An array of effects to be executed after the state is updated.
-     * @returns A dispatch function that can be used to update the state and trigger the effects.
-     */
-    o(this, "reducer", (t, ...r) => {
-      const n = this;
-      return function i(l) {
-        const c = n.value;
-        n.update((a) => t(a, l)), !n.equals(c, n.value) && r.forEach(
-          (a) => a({
-            previousState: c,
-            state: n.value,
-            action: l,
-            dispatch: i
-          })
-        );
-      };
-    });
-    /**
-     * Creates an isomorphism for the Signal.
-     * An isomorphism is a pair of functions that convert values between two types,
-     * along with an equality function to compare values of the second type.
-     *
-     * @param to - A function that converts values from type T to type O.
-     * @param from - A function that converts values from type O to type T.
-     * @param equals - An optional function that compares values of type O for equality.
-     *                Defaults to a strict equality check (===).
-     * @returns A Prop object representing the isomorphism.
-     */
-    o(this, "iso", (t, r, n = (i, l) => i === l) => {
-      const i = new te(t(this.get()), n);
-      return i.onDispose(this.on((l) => i.set(t(l)))), i.on((l) => this._setAndNotify(r(l))), i;
-    });
-    /**
-     * Returns a `Prop` that represents the value at the specified key of the current value.
-     *
-     * @param key - The key of the value to access.
-     * @returns A `Prop` that represents the value at the specified key.
-     */
-    o(this, "atProp", (t) => this.iso(
-      (r) => r[t],
-      (r) => ({ ...this.value, [t]: r })
-    ));
-  }
+class Y extends m {
+  /**
+   * Checks if a value is a Prop.
+   * @param value - The value to check.
+   * @returns `true` if the value is a Prop, `false` otherwise.
+   */
+  static is = (e) => (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    e != null && e.$__prop__ === !0
+  );
+  /**
+   * @internal
+   */
+  $__prop__ = !0;
+  /**
+   * Changes the value of the property and notifies its listeners.
+   *
+   * @param value - The new value of the property.
+   */
+  set = (e) => {
+    this._setAndNotify(e);
+  };
+  /**
+   * Updates the value of the signal by applying the provided function to the current value.
+   * @param fn - The function to apply to the current value.
+   */
+  update = (e) => {
+    this._setAndNotify(e(this.get()));
+  };
+  /**
+   * Creates a reducer function that combines the provided reducer function and effects.
+   * @param fn - The reducer function that takes the current state and an action, and returns the new state.
+   * @param effects - An array of effects to be executed after the state is updated.
+   * @returns A dispatch function that can be used to update the state and trigger the effects.
+   */
+  reducer = (e, ...s) => {
+    const r = this;
+    return function n(i) {
+      const o = r.value;
+      r.update((l) => e(l, i)), !r.equals(o, r.value) && s.forEach(
+        (l) => l({
+          previousState: o,
+          state: r.value,
+          action: i,
+          dispatch: n
+        })
+      );
+    };
+  };
+  /**
+   * Creates an isomorphism for the Signal.
+   * An isomorphism is a pair of functions that convert values between two types,
+   * along with an equality function to compare values of the second type.
+   *
+   * @param to - A function that converts values from type T to type O.
+   * @param from - A function that converts values from type O to type T.
+   * @param equals - An optional function that compares values of type O for equality.
+   *                Defaults to a strict equality check (===).
+   * @returns A Prop object representing the isomorphism.
+   */
+  iso = (e, s, r = (n, i) => n === i) => {
+    const n = new Y(e(this.get()), r);
+    return n.onDispose(this.on((i) => n.set(e(i)))), n.on((i) => this._setAndNotify(s(i))), n;
+  };
+  /**
+   * Returns a `Prop` that represents the value at the specified key of the current value.
+   *
+   * @param key - The key of the value to access.
+   * @returns A `Prop` that represents the value at the specified key.
+   */
+  atProp = (e) => this.iso(
+    (s) => s[e],
+    (s) => ({ ...this.value, [e]: s })
+  );
   /**
    *  Access for the current value of the property.
    */
   get value() {
     return this.get();
   }
-  set value(t) {
-    this._setAndNotify(t);
+  set value(e) {
+    this._setAndNotify(e);
   }
-};
-/**
- * Checks if a value is a Prop.
- * @param value - The value to check.
- * @returns `true` if the value is a Prop, `false` otherwise.
- */
-o(te, "is", (t) => (
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  t != null && t.$__prop__ === !0
-));
-let X = te;
-const ae = (s, e, t = (r, n) => r === n) => {
-  const r = new N(s, t);
+}
+const re = (t, e, s = (r, n) => r === n) => {
+  const r = new H(t, s);
   return e.forEach((n) => n.setDerivative(r)), r;
-}, ze = (s, e, t = {}) => {
-  let r = t.once ? () => {
-    i(), s();
-  } : s;
-  if (t.skipInitial) {
-    let l = !1;
-    const c = r;
+}, qe = (t, e, s = {}) => {
+  let r = s.once ? () => {
+    i(), t();
+  } : t;
+  if (s.skipInitial) {
+    let o = !1;
+    const l = r;
     r = () => {
-      l ? c() : l = !0;
+      o ? l() : o = !0;
     };
   }
-  const n = ae(r, e), i = () => {
-    n.dispose(), t.abortSignal != null && t.abortSignal.removeEventListener("abort", i);
+  const n = re(r, e), i = () => {
+    n.dispose(), s.abortSignal != null && s.abortSignal.removeEventListener("abort", i);
   };
-  return t.abortSignal != null && t.abortSignal.addEventListener("abort", i), i;
-}, w = (s, e = (t, r) => t === r) => new X(s, e), se = (s, e = (t, r) => t === r) => new d(s, e), ue = () => (
+  return s.abortSignal != null && s.abortSignal.addEventListener("abort", i), i;
+}, _ = (t, e = (s, r) => s === r) => new Y(t, e), Q = (t, e = (s, r) => s === r) => new m(t, e), ne = () => (
   /* c8 ignore next */
   typeof window < "u" ? window : void 0
 );
-function Se(s) {
-  return s != null && s !== !1 && s !== 0 && s !== "";
+function he(t) {
+  return t != null && t !== !1 && t !== 0 && t !== "";
 }
-function Ke(s) {
-  return !Se(s);
+function Fe(t) {
+  return !he(t);
 }
-function et(s) {
-  return s == null;
+function Be(t) {
+  return t == null;
 }
-function tt(s) {
-  return s != null;
+function We(t) {
+  return t != null;
 }
 const y = {
   /**
@@ -647,7 +632,7 @@ const y = {
    * @param fn - The function to map the value.
    * @returns The mapped value.
    */
-  map: (s, e) => d.is(s) ? s.map(e) : e(s),
+  map: (t, e) => m.is(t) ? t.map(e) : e(t),
   /**
    * Wraps a value or a Signal instance into a Signal.
    * If the value is already a Signal, it returns the value itself.
@@ -658,30 +643,30 @@ const y = {
    * @param equals - A function that determines if two values are equal. Defaults to strict equality (===).
    * @returns A Signal instance.
    */
-  toSignal: (s, e) => d.is(s) ? s : se(s, e),
+  toSignal: (t, e) => m.is(t) ? t.derive() : Q(t, e),
   /**
    * Wraps a value in a `Signal` if it is not already a `Signal`.
    * If the value is `null` or `undefined`, it returns `null` or `undefined` respectively.
    * @param value - The value to wrap or check.
    * @returns The wrapped value if it is not `null` or `undefined`, otherwise `null` or `undefined`.
    */
-  maybeToSignal: (s, e) => {
-    if (s != null)
-      return y.toSignal(s, e);
+  maybeToSignal: (t, e) => {
+    if (t != null)
+      return y.toSignal(t, e);
   },
   /**
    * Gets the value from a `Signal` or the value itself if it is not a `Signal`.
    * @param value - The value or Signal instance to get the value from.
    * @returns The value.
    */
-  get: (s) => d.is(s) ? s.get() : s,
+  get: (t) => m.is(t) ? t.get() : t,
   /**
    * Adds a listener to a `Signal` or calls the listener immediately if it is not a `Signal`.
    * @param value - The value or Signal instance to add the listener to.
    * @param listener - The listener to call when the value changes.
    * @returns A function to remove the listener.
    */
-  on: (s, e) => d.is(s) ? s.on(e) : (e(s), () => {
+  on: (t, e) => m.is(t) ? t.on(e) : (e(t), () => {
   }),
   /**
    * Disposes of a value or a Signal.
@@ -689,8 +674,8 @@ const y = {
    * If the value is not a Signal, it does nothing.
    * @param value - The value or Signal instance to dispose of.
    */
-  dispose: (s) => {
-    d.is(s) && s.dispose();
+  dispose: (t) => {
+    m.is(t) && t.dispose();
   },
   /**
    * Derives a Prop from a Signal.
@@ -702,522 +687,271 @@ const y = {
    * @param options.equals - A function that determines if two values are equal.
    * @returns A Prop instance.
    */
-  deriveProp: (s, {
+  deriveProp: (t, {
     autoDisposeProp: e = !0,
-    equals: t
-  } = {}) => d.is(s) ? s.deriveProp({ autoDisposeProp: e, equals: t }) : w(s, t),
+    equals: s
+  } = {}) => m.is(t) ? t.deriveProp({ autoDisposeProp: e, equals: s }) : _(t, s),
   /**
    * Creates a new signal that emits `true` if the value is truthy, `false` otherwise.
    * @param value - The value or signal to check.
    * @returns A signal that emits `true` if the value is truthy, `false` otherwise.
    */
-  truthy: (s) => y.map(s, Se),
+  truthy: (t) => y.map(t, he),
   /**
    * Creates a new signal that emits `true` if the value is falsy, `false` otherwise.
    * @param value - The value or signal to check.
    * @returns A signal that emits `true` if the value is falsy, `false` otherwise.
    */
-  falsy: (s) => y.map(s, Ke),
+  falsy: (t) => y.map(t, Fe),
   /**
    * Creates a new signal that emits `true` if the value is null or undefined, `false` otherwise.
    * @param value - The value or signal to check.
    * @returns A signal that emits `true` if the value is null or undefined, `false` otherwise.
    */
-  nil: (s) => y.map(s, et),
+  nil: (t) => y.map(t, Be),
   /**
    * Creates a new signal that emits `true` if the value is not null or undefined, `false` otherwise.
    * @param value - The value or signal to check.
    * @returns A signal that emits `true` if the value is not null or undefined, `false` otherwise.
    */
-  defined: (s) => y.map(s, tt)
-}, he = (...s) => (e, t) => {
-  if (s.length === 1)
-    return y.toSignal(s[0]).map(e);
-  const r = s.filter((n) => d.is(n));
-  return ae(
-    () => e(...s.map((n) => y.get(n))),
+  defined: (t) => y.map(t, We)
+}, ie = (...t) => (e, s) => {
+  if (t.length === 1)
+    return y.toSignal(t[0]).map(e);
+  const r = t.filter((n) => m.is(n));
+  return re(
+    () => e(...t.map((n) => y.get(n))),
     r,
-    t
+    s
   );
-}, qt = (s) => {
-  const e = Object.keys(s);
-  return he(...Object.values(s))(
-    (...t) => Object.fromEntries(e.map((r, n) => [r, t[n]]))
+}, Ht = (t) => {
+  const e = Object.keys(t);
+  return ie(...Object.values(t))(
+    (...s) => Object.fromEntries(e.map((r, n) => [r, s[n]]))
   );
-}, Ft = (...s) => (e, t = {}) => {
-  const r = s.filter((n) => d.is(n));
-  return ze(
-    () => e(...s.map(y.get)),
+}, kt = (...t) => (e, s = {}) => {
+  const r = t.filter((n) => m.is(n));
+  return qe(
+    () => e(...t.map(y.get)),
     r,
-    t
+    s
   );
 };
-class Ae {
-  constructor() {
-    o(this, "_store", /* @__PURE__ */ new Map());
-    /**
-     * Retrieves the value associated with the specified key from the memory store.
-     * @param key - The key to retrieve the value for.
-     * @returns The value associated with the key, or `null` if the key is not found.
-     */
-    o(this, "getItem", (e) => this._store.get(e) ?? null);
-    /**
-     * Sets the value associated with the specified key in the memory store.
-     * @param key - The key to set the value for.
-     * @param value - The value to set.
-     */
-    o(this, "setItem", (e, t) => {
-      this._store.set(e, t);
-    });
-  }
+class fe {
+  _store = /* @__PURE__ */ new Map();
+  /**
+   * Retrieves the value associated with the specified key from the memory store.
+   * @param key - The key to retrieve the value for.
+   * @returns The value associated with the key, or `null` if the key is not found.
+   */
+  getItem = (e) => this._store.get(e) ?? null;
+  /**
+   * Sets the value associated with the specified key in the memory store.
+   * @param key - The key to set the value for.
+   * @param value - The value to set.
+   */
+  setItem = (e, s) => {
+    this._store.set(e, s);
+  };
 }
-const ve = ({
-  key: s,
+const de = ({
+  key: t,
   defaultValue: e,
-  store: t,
+  store: s,
   serialize: r = JSON.stringify,
   deserialize: n = JSON.parse,
-  equals: i = (u, h) => u === h,
-  onLoad: l = (u) => u,
-  syncTabs: c = !0,
-  onKeyChange: a = "load"
+  equals: i = (a, u) => a === u,
+  onLoad: o = (a) => a,
+  syncTabs: l = !0,
+  onKeyChange: c = "load"
 }) => {
-  let u = y.get(s);
-  const h = t.getItem(u), p = new X(
-    h != null ? l(n(h)) : typeof e == "function" ? e() : e,
+  let a = y.get(t);
+  const u = s.getItem(a), p = new Y(
+    u != null ? o(n(u)) : typeof e == "function" ? e() : e,
     i
-  ), T = ue(), g = c && typeof (T == null ? void 0 : T.BroadcastChannel) == "function";
-  let m = !1, S = null, P = null;
-  const v = (b) => {
-    if (!g) return null;
-    const k = `tempo:storedProp:${b}`, A = new T.BroadcastChannel(k), H = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`, O = (U) => {
-      const E = U.data;
-      if (!(E == null || typeof E != "object" || E.key !== b || typeof E.value != "string" || E.sourceId != null && E.sourceId === H))
+  ), d = ne(), f = l && typeof d?.BroadcastChannel == "function";
+  let g = !1, w = null, C = null;
+  const S = (b) => {
+    if (!f) return null;
+    const D = `tempo:storedProp:${b}`, A = new d.BroadcastChannel(D), O = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`, x = (j) => {
+      const v = j.data;
+      if (!(v == null || typeof v != "object" || v.key !== b || typeof v.value != "string" || v.sourceId != null && v.sourceId === O))
         try {
-          m = !0;
-          const oe = l(n(E.value));
-          p.set(oe);
-        } catch (oe) {
+          g = !0;
+          const te = o(n(v.value));
+          p.set(te);
+        } catch (te) {
           console.warn(
             `Failed to sync storedProp for key "${b}" via BroadcastChannel`,
-            oe
+            te
           );
         } finally {
-          m = !1;
+          g = !1;
         }
     };
-    return A.addEventListener("message", O), p.onDispose(() => {
-      A == null || A.removeEventListener("message", O), A == null || A.close();
-    }), { channel: A, instanceId: H, handleMessage: O };
-  }, D = v(u);
-  D && (S = D.channel, P = D.instanceId);
-  const ie = (b) => {
-    const k = u;
-    if (k === b) return;
-    const A = p.get(), H = r(A);
-    if (t.setItem(k, H), S != null && (S.close(), S = null, P = null), u = b, a === "load") {
-      const U = t.getItem(b);
-      if (U != null)
+    return A.addEventListener("message", x), p.onDispose(() => {
+      A?.removeEventListener("message", x), A?.close();
+    }), { channel: A, instanceId: O, handleMessage: x };
+  }, P = S(a);
+  P && (w = P.channel, C = P.instanceId);
+  const ee = (b) => {
+    const D = a;
+    if (D === b) return;
+    const A = p.get(), O = r(A);
+    if (s.setItem(D, O), w != null && (w.close(), w = null, C = null), a = b, c === "load") {
+      const j = s.getItem(b);
+      if (j != null)
         try {
-          const E = l(n(U));
-          p.set(E);
-        } catch (E) {
+          const v = o(n(j));
+          p.set(v);
+        } catch (v) {
           console.warn(
             `Failed to load storedProp from new key "${b}"`,
-            E
+            v
           );
         }
       else
-        t.setItem(b, H);
-    } else a === "migrate" && t.setItem(b, H);
-    const O = v(b);
-    O && (S = O.channel, P = O.instanceId);
+        s.setItem(b, O);
+    } else c === "migrate" && s.setItem(b, O);
+    const x = S(b);
+    x && (w = x.channel, C = x.instanceId);
   };
-  return d.is(s) && p.onDispose(s.on(ie)), p.on((b, k) => {
+  return m.is(t) && p.onDispose(t.on(ee)), p.on((b, D) => {
     const A = r(b);
-    t.setItem(u, A), S != null && !m && k !== void 0 && P != null && S.postMessage({
-      key: u,
+    s.setItem(a, A), w != null && !g && D !== void 0 && C != null && w.postMessage({
+      key: a,
       value: A,
-      sourceId: P
+      sourceId: C
     });
   }), p;
-}, Bt = (s) => {
-  var e;
-  return ve({
-    ...s,
-    /* c8 ignore next 3 */
-    store: ((e = ue()) == null ? void 0 : e.localStorage) ?? new Ae()
-  });
-}, Wt = (s) => {
-  var e;
-  return ve({
-    ...s,
-    /* c8 ignore next 3 */
-    store: ((e = ue()) == null ? void 0 : e.sessionStorage) ?? new Ae()
-  });
-};
-function ye(s) {
-  return typeof requestAnimationFrame == "function" ? requestAnimationFrame(s) : setTimeout(s, 0);
+}, $t = (t) => de({
+  ...t,
+  /* c8 ignore next 3 */
+  store: ne()?.localStorage ?? new fe()
+}), Nt = (t) => de({
+  ...t,
+  /* c8 ignore next 3 */
+  store: ne()?.sessionStorage ?? new fe()
+});
+function ae(t) {
+  return typeof requestAnimationFrame == "function" ? requestAnimationFrame(t) : setTimeout(t, 0);
 }
-const st = (s, e, t, r) => {
-  const n = (r == null ? void 0 : r.duration) ?? 300, i = (r == null ? void 0 : r.easing) ?? ((v) => v), l = (r == null ? void 0 : r.equals) ?? ((v, D) => v === D);
-  let c = r == null ? void 0 : r.interpolate, a = s, u = e(), h = performance.now(), p = null, T = !0;
-  const g = new N(e, l), m = w(s, l);
-  m.onDispose(() => {
+const Ue = (t, e, s, r) => {
+  const n = r?.duration ?? 300, i = r?.easing ?? ((S) => S), o = r?.equals ?? ((S, P) => S === P);
+  let l = r?.interpolate, c = t, a = e(), u = performance.now(), p = null, d = !0;
+  const f = new H(e, o), g = _(t, o);
+  g.onDispose(() => {
     p !== null && cancelAnimationFrame(p);
-  }), m.onDispose(g.dispose), t.forEach((v) => {
-    v.setDerivative(g), v.onDispose(m.dispose);
+  }), g.onDispose(f.dispose), s.forEach((S) => {
+    S.setDerivative(f), S.onDispose(g.dispose);
   });
-  const S = (v) => {
-    u = v, h = performance.now(), a = m.value, T && (T = !1, p = ye(P));
-  }, P = () => {
-    const D = (performance.now() - h) / y.get(n), ie = i(D);
-    c == null && (c = Qe(a));
-    let b = c(a, u, ie);
-    D >= 1 ? (T = !0, b = u) : p = ye(P), m.set(b);
-  };
-  return g.on(S), m;
-}, Ut = (s, e) => {
-  const { initialValue: t, ...r } = e ?? {};
-  return st(
+  const w = (S) => {
+    a = S, u = performance.now(), c = g.value, d && (d = !1, p = ae(C));
+  }, C = () => {
+    const P = (performance.now() - u) / y.get(n), ee = i(P);
+    l == null && (l = Ve(c));
+    let b = l(c, a, ee);
+    P >= 1 ? (d = !0, b = a) : p = ae(C), g.set(b);
+  };
+  return f.on(w), g;
+}, Rt = (t, e) => {
+  const { initialValue: s, ...r } = e ?? {};
+  return Ue(
     /* c8 ignore next 2 */
-    t ?? s.get(),
-    s.get,
-    [s],
+    s ?? t.get(),
+    t.get,
+    [t],
     r
   );
-}, rt = (s, e) => {
-  const t = Object.values(s).filter(d.is), r = Object.keys(s);
-  return ae(() => {
+}, Je = (t, e) => {
+  const s = Object.values(t).filter(m.is), r = Object.keys(t);
+  return re(() => {
     const n = {};
     for (const i of r)
-      n[i] = y.get(s[i]);
+      n[i] = y.get(t[i]);
     return e(n);
-  }, t);
-}, Jt = (s) => rt(s, (e) => e), Gt = (s, e) => {
-  const t = w(s.get());
+  }, s);
+}, Vt = (t) => Je(t, (e) => e), jt = (t, e) => {
+  const s = _(t.get());
   let r = null;
-  const n = s.on((i) => {
+  const n = t.on((i) => {
     r != null && clearTimeout(r), r = setTimeout(
       () => {
-        r = null, t.set(i);
+        r = null, s.set(i);
       },
       typeof e == "function" ? e(i) : e
     );
   });
-  return t.onDispose(() => {
+  return s.onDispose(() => {
     n(), r != null && clearTimeout(r);
-  }), t;
-}, Xt = (s) => {
+  }), s;
+}, qt = (t) => {
   let e;
-  return s.map((t) => {
+  return t.map((s) => {
     const r = e;
-    return e = t, r;
+    return e = s, r;
   });
-}, Yt = ({
-  size: s = void 0,
+}, Ft = ({
+  size: t = void 0,
   signal: e
 }) => {
-  const t = [];
-  return e.map((r) => (t.push(r), s != null && t.length > s && t.shift(), t.slice()));
-}, Qt = (s) => (...e) => he(
-  s,
+  const s = [];
+  return e.map((r) => (s.push(r), t != null && s.length > t && s.shift(), s.slice()));
+}, Bt = (t) => (...e) => ie(
+  t,
   ...e
-)((t, ...r) => t(...r));
-function Zt(...s) {
-  return he(...s)((...e) => {
-    for (const t of e) if (t != null) return t;
+)((s, ...r) => s(...r));
+function Wt(...t) {
+  return ie(...t)((...e) => {
+    for (const s of e) if (s != null) return s;
   });
 }
-const _e = /* @__PURE__ */ new Set(["checked", "disabled", "hidden"]), Ee = /* @__PURE__ */ new Set(["selected"]), Ce = /* @__PURE__ */ new Set([
+const pe = /* @__PURE__ */ new Set(["checked", "disabled", "hidden"]), me = /* @__PURE__ */ new Set(["selected"]), ge = /* @__PURE__ */ new Set([
   "rowSpan",
   "colSpan",
   "tabIndex",
-  "valueAsNumber"
-]), we = /* @__PURE__ */ new Set(["valueAsDate"]), xe = /* @__PURE__ */ new Set([
-  "value",
-  "textContent",
-  "innerText",
-  "innerHTML",
-  "outerHTML",
-  "className",
-  "classList"
-]), nt = (s, e) => Ee.has(s) ? (t) => {
-  t == null || t !== !0 ? e.removeAttribute(s) : e.setAttribute(s, "");
-} : _e.has(s) ? (t) => {
-  t == null ? e[s] = null : e[s] = !!t;
-} : Ce.has(s) ? (t) => {
-  t == null ? e[s] = null : e[s] = Number(t);
-} : we.has(s) ? (t) => {
-  t == null ? e[s] = null : e[s] = t;
-} : xe.has(s) ? (t) => {
-  t == null ? e[s] = null : e[s] = String(t);
-} : (t) => {
-  t == null ? e.removeAttribute(s) : e.setAttribute(s, t);
-}, it = (s, e) => Ee.has(s) ? () => e.hasAttribute(s) : _e.has(s) ? () => !!e[s] : Ce.has(s) ? () => Number(e[s]) : we.has(s) ? () => e[s] : xe.has(s) ? () => String(e[s]) : () => e.getAttribute(s), Y = (s) => {
-  const e = s;
-  e && e.onblur && (e.onblur = null), !(!s || s.ownerDocument === void 0) && s.parentElement && s.parentElement.removeChild(s);
-}, ot = (s) => Pe(s) ? s : s.parentElement, Pe = (s) => s.nodeType === 1;
-class De extends Error {
-  constructor(e) {
-    super(`Provider not found: ${e.description}`);
-  }
-}
-class R {
-  /**
-   * Constructs a new `DOMContext` instance.
-   *
-   * @param document - The `Document` instance associated with this context.
-   * @param element - The `Element` instance associated with this context.
-   * @param reference - An optional `Node` instance that serves as a reference for this context.
-   * @param providers - The `Providers` instance associated with this context.
-   * @param isFirstLevel - A boolean value indicating whether this context is at the first level, meaning the outermost node in the generated DOM.
-   */
-  constructor(e, t, r, n) {
-    /**
-     * Creates a new DOM element (eg: HTML or SVG) with the specified tag name and namespace.
-     *
-     * @param tagName - The tag name of the element to create.
-     * @param namespace - The namespace URI to create the element in, or `undefined` to create a standard HTML element.
-     * @returns The newly created element.
-     */
-    o(this, "createElement", (e, t) => t !== void 0 ? this.document.createElementNS(t, e) : this.document.createElement(e));
-    /**
-     * Creates a new child element and appends it to the current element, returning a new context.
-     *
-     * This method creates a new DOM element with the specified tag name and namespace,
-     * appends it to the current element, and returns a new DOMContext focused on the
-     * newly created child element. This is the primary method for building DOM trees.
-     *
-     * @example
-     * ```typescript
-     * // Create HTML elements
-     * const divCtx = ctx.makeChildElement('div', undefined)
-     * const spanCtx = divCtx.makeChildElement('span', undefined)
-     *
-     * // Create SVG elements
-     * const svgCtx = ctx.makeChildElement('svg', 'http://www.w3.org/2000/svg')
-     * const circleCtx = svgCtx.makeChildElement('circle', 'http://www.w3.org/2000/svg')
-     * ```
-     *
-     * @param tagName - The tag name of the element to create (e.g., 'div', 'span', 'svg')
-     * @param namespace - The namespace URI for the element, or undefined for HTML elements
-     * @returns A new DOMContext focused on the newly created child element
-     */
-    o(this, "makeChildElement", (e, t) => {
-      const r = this.createElement(e, t);
-      return this.appendOrInsert(r), this.withElement(r);
-    });
-    /**
-     * Creates a new text node with the specified text content.
-     * @param text - The text content for the new text node.
-     * @returns A new `Text` node with the specified text content.
-     */
-    o(this, "createText", (e) => this.document.createTextNode(e));
-    /**
-     * Creates a new text node with the specified text content and appends it to the current element.
-     * @param text - The text content for the new text node.
-     * @returns A new `DOMContext` with a reference to the new text node.
-     */
-    o(this, "makeChildText", (e) => {
-      const t = this.createText(e);
-      return this.appendOrInsert(t), this.withReference(t);
-    });
-    /**
-     * Sets the text content of the current element.
-     * @param text - The text content to set.
-     */
-    o(this, "setText", (e) => {
-      this.reference.nodeValue = e;
-    });
-    /**
-     * Gets the text content of the current element or text node.
-     * @returns The text content of the current element or text node.
-     */
-    o(this, "getText", () => {
-      var e;
-      return ((e = this.reference) == null ? void 0 : e.nodeValue) ?? this.element.textContent ?? "";
-    });
-    /**
-     * Creates a new `DOMContext` with a reference to a newly created text node.
-     * The text node is appended or inserted to the current `DOMContext`.
-     * The new `DOMContext` with the reference is returned.
-     */
-    o(this, "makeRef", () => {
-      const e = this.createText("");
-      return this.appendOrInsert(e), this.withReference(e);
-    });
-    /**
-     * Appends or inserts a child node to the element, depending on whether a reference node is provided.
-     *
-     * @param child - The child node to append or insert.
-     */
-    o(this, "appendOrInsert", (e) => {
-      this.reference === void 0 ? this.element.appendChild(e) : this.element.insertBefore(e, this.reference);
-    });
-    /**
-     * Creates a new `DOMContext` instance with the provided `element`.
-     * @param element - The DOM element to use in the new `DOMContext` instance.
-     * @returns A new `DOMContext` instance with the provided `element`.
-     */
-    o(this, "withElement", (e) => new R(this.document, e, void 0, this.providers));
-    /**
-     * Creates a portal to render content in a different part of the DOM tree.
-     *
-     * Portals allow you to render child components into a DOM node that exists outside
-     * the parent component's DOM hierarchy. This is useful for modals, tooltips,
-     * dropdowns, and other UI elements that need to break out of their container's
-     * styling or z-index context.
-     *
-     * @example
-     * ```typescript
-     * // Portal to a modal container
-     * const modalCtx = ctx.makePortal('#modal-root')
-     * const modal = modalCtx.makeChildElement('div', undefined)
-     *
-     * // Add modal content
-     * modal.makeChildText('This renders in #modal-root')
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Portal to an existing element reference
-     * const tooltipContainer = document.getElementById('tooltip-container')!
-     * const tooltipCtx = ctx.makePortal(tooltipContainer)
-     *
-     * // Render tooltip content
-     * const tooltip = tooltipCtx.makeChildElement('div', undefined)
-     * tooltip.addClasses(['tooltip', 'tooltip-top'])
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Portal for dropdown menu
-     * const dropdownCtx = ctx.makePortal('body') // Render at body level
-     * const dropdown = dropdownCtx.makeChildElement('div', undefined)
-     * dropdown.addClasses(['dropdown-menu'])
-     * dropdown.setStyle('position', 'absolute')
-     * dropdown.setStyle('top', '100px')
-     * dropdown.setStyle('left', '50px')
-     * ```
-     *
-     * @param selector - CSS selector string or HTMLElement reference for the portal target
-     * @returns A new DOMContext focused on the portal target element
-     * @throws {Error} When the selector doesn't match any element in the document
-     */
-    o(this, "makePortal", (e) => {
-      const t = typeof e == "string" ? this.document.querySelector(e) : e;
-      if (t == null)
-        throw new Error(`Cannot find element by selector for portal: ${e}`);
-      return this.withElement(t);
-    });
-    /**
-     * Creates a new `DOMContext` instance with the specified reference.
-     *
-     * @param reference - The optional `Text` node to use as the reference for the new `DOMContext`.
-     * @returns A new `DOMContext` instance with the specified reference.
-     */
-    o(this, "withReference", (e) => new R(this.document, this.element, e, this.providers));
-    /**
-     * Sets a provider for the given provider mark.
-     *
-     * @param mark - The provider mark to set the provider for.
-     * @param value - The provider to set for the given mark.
-     * @returns A new `DOMContext` instance with the specified provider.
-     */
-    o(this, "setProvider", (e, t, r) => new R(this.document, this.element, this.reference, {
-      ...this.providers,
-      [e]: [t, r]
-    }));
-    /**
-     * Retrieves a provider for the given provider mark.
-     *
-     * @param mark - The provider mark to retrieve the provider for.
-     * @returns The provider for the given mark.
-     * @throws Throws `ProviderNotFoundError` if the provider for the given mark is not found.
-     */
-    o(this, "getProvider", (e) => {
-      if (this.providers[e] === void 0)
-        throw new De(e);
-      const [t, r] = this.providers[e];
-      return { value: t, onUse: r };
-    });
-    o(this, "clear", (e) => {
-      e && (this.reference !== void 0 ? Y(this.reference) : Y(this.element));
-    });
-    /**
-     * Adds classes to the element.
-     * @param tokens - The class names to add.
-     */
-    o(this, "addClasses", (e) => {
-      this.element.classList.add(...e);
-    });
-    /**
-     * Removes classes from the element.
-     * @param tokens - The class names to remove.
-     */
-    o(this, "removeClasses", (e) => {
-      this.element.classList.remove(...e);
-    });
-    /**
-     * Gets the classes of the element.
-     * @returns The classes of the element.
-     */
-    o(this, "getClasses", () => Array.from(this.element.classList));
-    /**
-     * Adds an event listener to the element.
-     * @param event - The event to listen for.
-     * @param listener - The listener to call when the event occurs.
-     * @param options - The options for the event listener.
-     * @returns A function to remove the event listener.
-     */
-    o(this, "on", (e, t, r) => {
-      const n = (i) => t(i, this);
-      return this.element.addEventListener(e, n, r), (i) => {
-        i && this.element.removeEventListener(e, n, r);
-      };
-    });
-    /**
-     * Returns `true` if the context is a browser DOM context.
-     * @returns `true` if the context is a browser DOM context.
-     * @deprecated Use `isBrowser()` instead.
-     */
-    o(this, "isBrowserDOM", () => !0);
-    /**
-     * Returns `true` if the context is a browser context.
-     * @returns `true` if the context is a browser context.
-     */
-    o(this, "isBrowser", () => !0);
-    /**
-     * Returns `true` if the context is a headless DOM context.
-     * @returns `true` if the context is a headless DOM context.
-     */
-    o(this, "isHeadlessDOM", () => !1);
-    /**
-     * Returns `true` if the context is a headless context.
-     * @returns `true` if the context is a headless context.
-     */
-    o(this, "isHeadless", () => !1);
-    /**
-     * Sets the style of the element.
-     * @param name - The name of the style to set.
-     * @param value - The value of the style to set.
-     */
-    o(this, "setStyle", (e, t) => {
-      this.element.style[e] = t;
-    });
-    /**
-     * Gets the style of the element.
-     * @param name - The name of the style to get.
-     * @returns The value of the style.
-     */
-    o(this, "getStyle", (e) => this.element.style[e]);
-    o(this, "makeAccessors", (e) => ({
-      get: it(e, this.element),
-      set: nt(e, this.element)
-    }));
-    o(this, "getWindow", () => this.document.defaultView);
-    this.document = e, this.element = t, this.reference = r, this.providers = n;
+  "valueAsNumber"
+]), ye = /* @__PURE__ */ new Set(["valueAsDate"]), be = /* @__PURE__ */ new Set([
+  "value",
+  "textContent",
+  "innerText",
+  "innerHTML",
+  "outerHTML",
+  "className",
+  "classList"
+]), Ge = (t, e) => me.has(t) ? (s) => {
+  s == null || s !== !0 ? e.removeAttribute(t) : e.setAttribute(t, "");
+} : pe.has(t) ? (s) => {
+  s == null ? e[t] = null : e[t] = !!s;
+} : ge.has(t) ? (s) => {
+  s == null ? e[t] = null : e[t] = Number(s);
+} : ye.has(t) ? (s) => {
+  s == null ? e[t] = null : e[t] = s;
+} : be.has(t) ? (s) => {
+  s == null ? e[t] = null : e[t] = String(s);
+} : (s) => {
+  s == null ? e.removeAttribute(t) : e.setAttribute(t, s);
+}, Xe = (t, e) => me.has(t) ? () => e.hasAttribute(t) : pe.has(t) ? () => !!e[t] : ge.has(t) ? () => Number(e[t]) : ye.has(t) ? () => e[t] : be.has(t) ? () => String(e[t]) : () => e.getAttribute(t), B = (t) => {
+  const e = t;
+  e && e.onblur && (e.onblur = null), !(!t || t.ownerDocument === void 0) && t.parentElement && t.parentElement.removeChild(t);
+}, Ye = (t) => we(t) ? t : t.parentElement, we = (t) => t.nodeType === 1;
+class Se extends Error {
+  constructor(e) {
+    super(`Provider not found: ${e.description}`);
+  }
+}
+class k {
+  /**
+   * Constructs a new `DOMContext` instance.
+   *
+   * @param document - The `Document` instance associated with this context.
+   * @param element - The `Element` instance associated with this context.
+   * @param reference - An optional `Node` instance that serves as a reference for this context.
+   * @param providers - The `Providers` instance associated with this context.
+   * @param isFirstLevel - A boolean value indicating whether this context is at the first level, meaning the outermost node in the generated DOM.
+   */
+  constructor(e, s, r, n) {
+    this.document = e, this.element = s, this.reference = r, this.providers = n;
   }
   /**
    * Creates a new `DOMContext` instance for the given `Element` and optional reference `Node`.
@@ -1227,509 +961,739 @@ class R {
    * @param providers - The providers to associate with the `DOMContext`.
    * @returns A new `DOMContext` instance.
    */
-  static of(e, t, r) {
-    return new R(e.ownerDocument, e, t, r);
+  static of(e, s, r) {
+    return new k(e.ownerDocument, e, s, r);
   }
+  /**
+   * Creates a new DOM element (eg: HTML or SVG) with the specified tag name and namespace.
+   *
+   * @param tagName - The tag name of the element to create.
+   * @param namespace - The namespace URI to create the element in, or `undefined` to create a standard HTML element.
+   * @returns The newly created element.
+   */
+  createElement = (e, s) => s !== void 0 ? this.document.createElementNS(s, e) : this.document.createElement(e);
+  /**
+   * Creates a new child element and appends it to the current element, returning a new context.
+   *
+   * This method creates a new DOM element with the specified tag name and namespace,
+   * appends it to the current element, and returns a new DOMContext focused on the
+   * newly created child element. This is the primary method for building DOM trees.
+   *
+   * @example
+   * ```typescript
+   * // Create HTML elements
+   * const divCtx = ctx.makeChildElement('div', undefined)
+   * const spanCtx = divCtx.makeChildElement('span', undefined)
+   *
+   * // Create SVG elements
+   * const svgCtx = ctx.makeChildElement('svg', 'http://www.w3.org/2000/svg')
+   * const circleCtx = svgCtx.makeChildElement('circle', 'http://www.w3.org/2000/svg')
+   * ```
+   *
+   * @param tagName - The tag name of the element to create (e.g., 'div', 'span', 'svg')
+   * @param namespace - The namespace URI for the element, or undefined for HTML elements
+   * @returns A new DOMContext focused on the newly created child element
+   */
+  makeChildElement = (e, s) => {
+    const r = this.createElement(e, s);
+    return this.appendOrInsert(r), this.withElement(r);
+  };
+  /**
+   * Creates a new text node with the specified text content.
+   * @param text - The text content for the new text node.
+   * @returns A new `Text` node with the specified text content.
+   */
+  createText = (e) => this.document.createTextNode(e);
+  /**
+   * Creates a new text node with the specified text content and appends it to the current element.
+   * @param text - The text content for the new text node.
+   * @returns A new `DOMContext` with a reference to the new text node.
+   */
+  makeChildText = (e) => {
+    const s = this.createText(e);
+    return this.appendOrInsert(s), this.withReference(s);
+  };
+  /**
+   * Sets the text content of the current element.
+   * @param text - The text content to set.
+   */
+  setText = (e) => {
+    this.reference.nodeValue = e;
+  };
+  /**
+   * Gets the text content of the current element or text node.
+   * @returns The text content of the current element or text node.
+   */
+  getText = () => this.reference?.nodeValue ?? this.element.textContent ?? "";
+  /**
+   * Creates a new `DOMContext` with a reference to a newly created text node.
+   * The text node is appended or inserted to the current `DOMContext`.
+   * The new `DOMContext` with the reference is returned.
+   */
+  makeRef = () => {
+    const e = this.createText("");
+    return this.appendOrInsert(e), this.withReference(e);
+  };
+  /**
+   * Appends or inserts a child node to the element, depending on whether a reference node is provided.
+   *
+   * @param child - The child node to append or insert.
+   */
+  appendOrInsert = (e) => {
+    this.reference === void 0 ? this.element.appendChild(e) : this.element.insertBefore(e, this.reference);
+  };
+  /**
+   * Creates a new `DOMContext` instance with the provided `element`.
+   * @param element - The DOM element to use in the new `DOMContext` instance.
+   * @returns A new `DOMContext` instance with the provided `element`.
+   */
+  withElement = (e) => new k(this.document, e, void 0, this.providers);
+  /**
+   * Creates a portal to render content in a different part of the DOM tree.
+   *
+   * Portals allow you to render child components into a DOM node that exists outside
+   * the parent component's DOM hierarchy. This is useful for modals, tooltips,
+   * dropdowns, and other UI elements that need to break out of their container's
+   * styling or z-index context.
+   *
+   * @example
+   * ```typescript
+   * // Portal to a modal container
+   * const modalCtx = ctx.makePortal('#modal-root')
+   * const modal = modalCtx.makeChildElement('div', undefined)
+   *
+   * // Add modal content
+   * modal.makeChildText('This renders in #modal-root')
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Portal to an existing element reference
+   * const tooltipContainer = document.getElementById('tooltip-container')!
+   * const tooltipCtx = ctx.makePortal(tooltipContainer)
+   *
+   * // Render tooltip content
+   * const tooltip = tooltipCtx.makeChildElement('div', undefined)
+   * tooltip.addClasses(['tooltip', 'tooltip-top'])
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Portal for dropdown menu
+   * const dropdownCtx = ctx.makePortal('body') // Render at body level
+   * const dropdown = dropdownCtx.makeChildElement('div', undefined)
+   * dropdown.addClasses(['dropdown-menu'])
+   * dropdown.setStyle('position', 'absolute')
+   * dropdown.setStyle('top', '100px')
+   * dropdown.setStyle('left', '50px')
+   * ```
+   *
+   * @param selector - CSS selector string or HTMLElement reference for the portal target
+   * @returns A new DOMContext focused on the portal target element
+   * @throws {Error} When the selector doesn't match any element in the document
+   */
+  makePortal = (e) => {
+    const s = typeof e == "string" ? this.document.querySelector(e) : e;
+    if (s == null)
+      throw new Error(`Cannot find element by selector for portal: ${e}`);
+    return this.withElement(s);
+  };
+  /**
+   * Creates a new `DOMContext` instance with the specified reference.
+   *
+   * @param reference - The optional `Text` node to use as the reference for the new `DOMContext`.
+   * @returns A new `DOMContext` instance with the specified reference.
+   */
+  withReference = (e) => new k(this.document, this.element, e, this.providers);
+  /**
+   * Sets a provider for the given provider mark.
+   *
+   * @param mark - The provider mark to set the provider for.
+   * @param value - The provider to set for the given mark.
+   * @returns A new `DOMContext` instance with the specified provider.
+   */
+  setProvider = (e, s, r) => new k(this.document, this.element, this.reference, {
+    ...this.providers,
+    [e]: [s, r]
+  });
+  /**
+   * Retrieves a provider for the given provider mark.
+   *
+   * @param mark - The provider mark to retrieve the provider for.
+   * @returns The provider for the given mark.
+   * @throws Throws `ProviderNotFoundError` if the provider for the given mark is not found.
+   */
+  getProvider = (e) => {
+    if (this.providers[e] === void 0)
+      throw new Se(e);
+    const [s, r] = this.providers[e];
+    return { value: s, onUse: r };
+  };
+  clear = (e) => {
+    e && (this.reference !== void 0 ? B(this.reference) : B(this.element));
+  };
+  /**
+   * Adds classes to the element.
+   * @param tokens - The class names to add.
+   */
+  addClasses = (e) => {
+    this.element.classList.add(...e);
+  };
+  /**
+   * Removes classes from the element.
+   * @param tokens - The class names to remove.
+   */
+  removeClasses = (e) => {
+    this.element.classList.remove(...e);
+  };
+  /**
+   * Gets the classes of the element.
+   * @returns The classes of the element.
+   */
+  getClasses = () => Array.from(this.element.classList);
+  /**
+   * Adds an event listener to the element.
+   * @param event - The event to listen for.
+   * @param listener - The listener to call when the event occurs.
+   * @param options - The options for the event listener.
+   * @returns A function to remove the event listener.
+   */
+  on = (e, s, r) => {
+    const n = (i) => s(i, this);
+    return this.element.addEventListener(e, n, r), (i) => {
+      i && this.element.removeEventListener(e, n, r);
+    };
+  };
+  /**
+   * Returns `true` if the context is a browser DOM context.
+   * @returns `true` if the context is a browser DOM context.
+   * @deprecated Use `isBrowser()` instead.
+   */
+  isBrowserDOM = () => !0;
+  /**
+   * Returns `true` if the context is a browser context.
+   * @returns `true` if the context is a browser context.
+   */
+  isBrowser = () => !0;
+  /**
+   * Returns `true` if the context is a headless DOM context.
+   * @returns `true` if the context is a headless DOM context.
+   */
+  isHeadlessDOM = () => !1;
+  /**
+   * Returns `true` if the context is a headless context.
+   * @returns `true` if the context is a headless context.
+   */
+  isHeadless = () => !1;
+  /**
+   * Sets the style of the element.
+   * @param name - The name of the style to set.
+   * @param value - The value of the style to set.
+   */
+  setStyle = (e, s) => {
+    this.element.style[e] = s;
+  };
+  /**
+   * Gets the style of the element.
+   * @param name - The name of the style to get.
+   * @returns The value of the style.
+   */
+  getStyle = (e) => this.element.style[e];
+  makeAccessors = (e) => ({
+    get: Xe(e, this.element),
+    set: Ge(e, this.element)
+  });
+  getWindow = () => this.document.defaultView;
 }
-const lt = (s) => Symbol(s), fe = (s, e) => {
-  const t = s(e);
-  return (r = !0) => t(r);
-}, zt = (s, e, { doc: t, clear: r, disposeWithParent: n = !0, providers: i = {} } = {}) => {
-  const l = typeof e == "string" ? (t ?? document).querySelector(e) : e;
-  if (l === null)
-    throw new ct(
+const Qe = (t) => Symbol(t), oe = (t, e) => {
+  const s = t(e);
+  return (r = !0) => s(r);
+}, Ut = (t, e, { doc: s, clear: r, disposeWithParent: n = !0, providers: i = {} } = {}) => {
+  const o = typeof e == "string" ? (s ?? document).querySelector(e) : e;
+  if (o === null)
+    throw new Ze(
       `Cannot find element by selector for render: ${e}`
     );
-  r !== !1 && (t ?? l.ownerDocument) != null && l.nodeType === 1 && (l.innerHTML = "");
-  const c = ot(l), a = Pe(l) ? void 0 : l, u = R.of(c, a, i), h = fe(s, u);
+  r !== !1 && (s ?? o.ownerDocument) != null && o.nodeType === 1 && (o.innerHTML = "");
+  const l = Ye(o), c = we(o) ? void 0 : o, a = k.of(l, c, i), u = oe(t, a);
   let p;
-  return n && (p = new MutationObserver((T) => {
-    var g;
-    (g = T[0]) == null || g.removedNodes.forEach((m) => {
-      m === l && (p == null || p.disconnect(), h(l.nodeType !== 1));
+  return n && (p = new MutationObserver((d) => {
+    d[0]?.removedNodes.forEach((f) => {
+      f === o && (p?.disconnect(), u(o.nodeType !== 1));
     });
-  }), p.observe(l.parentElement, {
+  }), p.observe(o.parentElement, {
     childList: !0,
     subtree: !1,
     attributes: !1
   })), () => {
-    p == null || p.disconnect(), h(!0);
+    p?.disconnect(), u(!0);
   };
-}, Kt = (s, {
+}, Jt = (t, {
   startUrl: e = "https://example.com",
-  selector: t,
+  selector: s,
   providers: r = {}
 } = {
   selector: "body"
 }) => {
-  const n = y.toSignal(e).deriveProp(), i = new ke(t, void 0), l = new V(i, void 0, { currentURL: n }, r);
+  const n = y.toSignal(e).deriveProp(), i = new Ee(s, void 0), o = new $(i, void 0, { currentURL: n }, r);
   return {
-    clear: fe(s(), l),
+    clear: oe(t(), o),
     root: i,
     currentURL: n
   };
 };
-class ct extends Error {
+class Ze extends Error {
   constructor(e) {
     super(e);
   }
 }
-const Le = "data-tts-node", Q = "data-tts-class", Z = "data-tts-style", z = "data-tts-html", K = "data-tts-text", ee = "data-tts-attrs";
-class es {
+const Te = "data-tts-node", W = "data-tts-class", U = "data-tts-style", J = "data-tts-html", G = "data-tts-text", X = "data-tts-attrs";
+class Gt {
+  /**
+   * Selects elements from the headless environment.
+   * @param selector - The selector to select elements from. The supported selectors are CSS selectors whose complexity depends on the adapter implementation.
+   * @returns An array of elements.
+   */
+  select;
+  /**
+   * Gets the value of an attribute from an element.
+   * @param el - The element to get the attribute from.
+   * @param attr - The attribute to get the value from.
+   * @returns The value of the attribute or null if the attribute is not set.
+   */
+  getAttribute;
+  /**
+   * Sets the value of an attribute on an element.
+   * @param el - The element to set the attribute on.
+   * @param attr - The attribute to set the value of.
+   * @param value - The value to set the attribute to.
+   */
+  setAttribute;
+  /**
+   * Gets the class of an element.
+   * @param el - The element to get the class from.
+   * @returns The class of the element or an empty string if the class is not set.
+   */
+  getClass;
+  /**
+   * Sets the class of an element.
+   * @param el - The element to set the class on.
+   * @param cls - The class to set.
+   */
+  setClass;
+  /**
+   * Gets the styles of an element.
+   * @param el - The element to get the styles from.
+   * @returns The styles of the element.
+   */
+  getStyles;
+  /**
+   * Sets the styles of an element.
+   * @param el - The element to set the styles on.
+   */
+  setStyles;
+  /**
+   * Appends HTML to an element.
+   * @param el - The element to append the HTML to.
+   * @param html - The HTML to append.
+   */
+  appendHTML;
+  /**
+   * Gets the inner HTML of an element.
+   * @param el - The element to get the inner HTML from.
+   * @returns The inner HTML of the element or an empty string if the inner HTML is not set.
+   */
+  getInnerHTML;
+  /**
+   * Sets the inner HTML of an element.
+   * @param el - The element to set the inner HTML on.
+   * @param html - The inner HTML to set.
+   */
+  setInnerHTML;
+  /**
+   * Gets the inner text of an element.
+   * @param el - The element to get the inner text from.
+   * @returns The inner text of the element or an empty string if the inner text is not set.
+   */
+  getInnerText;
+  /**
+   * Sets the inner text of an element.
+   * @param el - The element to set the inner text on.
+   * @param text - The inner text to set.
+   */
+  setInnerText;
   constructor({
     select: e,
-    getAttribute: t,
+    getAttribute: s,
     setAttribute: r,
     getClass: n,
     setClass: i,
-    getStyles: l,
-    setStyles: c,
-    appendHTML: a,
-    getInnerHTML: u,
-    setInnerHTML: h,
+    getStyles: o,
+    setStyles: l,
+    appendHTML: c,
+    getInnerHTML: a,
+    setInnerHTML: u,
     getInnerText: p,
-    setInnerText: T
+    setInnerText: d
   }) {
-    /**
-     * Selects elements from the headless environment.
-     * @param selector - The selector to select elements from. The supported selectors are CSS selectors whose complexity depends on the adapter implementation.
-     * @returns An array of elements.
-     */
-    o(this, "select");
-    /**
-     * Gets the value of an attribute from an element.
-     * @param el - The element to get the attribute from.
-     * @param attr - The attribute to get the value from.
-     * @returns The value of the attribute or null if the attribute is not set.
-     */
-    o(this, "getAttribute");
-    /**
-     * Sets the value of an attribute on an element.
-     * @param el - The element to set the attribute on.
-     * @param attr - The attribute to set the value of.
-     * @param value - The value to set the attribute to.
-     */
-    o(this, "setAttribute");
-    /**
-     * Gets the class of an element.
-     * @param el - The element to get the class from.
-     * @returns The class of the element or an empty string if the class is not set.
-     */
-    o(this, "getClass");
-    /**
-     * Sets the class of an element.
-     * @param el - The element to set the class on.
-     * @param cls - The class to set.
-     */
-    o(this, "setClass");
-    /**
-     * Gets the styles of an element.
-     * @param el - The element to get the styles from.
-     * @returns The styles of the element.
-     */
-    o(this, "getStyles");
-    /**
-     * Sets the styles of an element.
-     * @param el - The element to set the styles on.
-     */
-    o(this, "setStyles");
-    /**
-     * Appends HTML to an element.
-     * @param el - The element to append the HTML to.
-     * @param html - The HTML to append.
-     */
-    o(this, "appendHTML");
-    /**
-     * Gets the inner HTML of an element.
-     * @param el - The element to get the inner HTML from.
-     * @returns The inner HTML of the element or an empty string if the inner HTML is not set.
-     */
-    o(this, "getInnerHTML");
-    /**
-     * Sets the inner HTML of an element.
-     * @param el - The element to set the inner HTML on.
-     * @param html - The inner HTML to set.
-     */
-    o(this, "setInnerHTML");
-    /**
-     * Gets the inner text of an element.
-     * @param el - The element to get the inner text from.
-     * @returns The inner text of the element or an empty string if the inner text is not set.
-     */
-    o(this, "getInnerText");
-    /**
-     * Sets the inner text of an element.
-     * @param el - The element to set the inner text on.
-     * @param text - The inner text to set.
-     */
-    o(this, "setInnerText");
-    /**
-     * Sets the content of the root element from a HeadlessPortal. Generally this will be the same instance that is
-     * returned by `runHeadless`.
-     *
-     * @param root - The HeadlessPortal containing the content to set.
-     * @param setPlaceholders - Whether to set placeholders for the content. This allows you to restore the original content
-     * when you render on the server and then hydrate on the client.
-     */
-    o(this, "setFromRoot", (e, t) => {
-      e.getPortals().forEach((n) => {
-        const i = typeof n.selector == "string" ? this.select(n.selector) : [n.selector];
-        for (const l of i) {
-          if (l == null)
-            throw new Error(
-              `Cannot find element by selector for render: ${n.selector}`
-            );
-          if (n.hasChildren() && this.appendHTML(l, n.contentToHTML(t)), n.hasInnerHTML()) {
-            if (t) {
-              const c = this.getInnerHTML(l);
-              c != null && this.setAttribute(l, z, c);
-            }
-            this.setInnerHTML(l, n.getInnerHTML());
+    this.select = e, this.getAttribute = s, this.setAttribute = r, this.getClass = n, this.setClass = i, this.getStyles = o, this.setStyles = l, this.appendHTML = c, this.getInnerHTML = a, this.setInnerHTML = u, this.getInnerText = p, this.setInnerText = d;
+  }
+  /**
+   * Sets the content of the root element from a HeadlessPortal. Generally this will be the same instance that is
+   * returned by `runHeadless`.
+   *
+   * @param root - The HeadlessPortal containing the content to set.
+   * @param setPlaceholders - Whether to set placeholders for the content. This allows you to restore the original content
+   * when you render on the server and then hydrate on the client.
+   */
+  setFromRoot = (e, s) => {
+    e.getPortals().forEach((n) => {
+      const i = typeof n.selector == "string" ? this.select(n.selector) : [n.selector];
+      for (const o of i) {
+        if (o == null)
+          throw new Error(
+            `Cannot find element by selector for render: ${n.selector}`
+          );
+        if (n.hasChildren() && this.appendHTML(o, n.contentToHTML(s)), n.hasInnerHTML()) {
+          if (s) {
+            const l = this.getInnerHTML(o);
+            l != null && this.setAttribute(o, J, l);
           }
-          if (n.hasInnerText()) {
-            if (t) {
-              const c = this.getInnerText(l);
-              c != null && this.setAttribute(l, K, c);
-            }
-            this.setInnerText(l, n.getInnerText());
+          this.setInnerHTML(o, n.getInnerHTML());
+        }
+        if (n.hasInnerText()) {
+          if (s) {
+            const l = this.getInnerText(o);
+            l != null && this.setAttribute(o, G, l);
           }
-          if (n.hasClasses()) {
-            if (t) {
-              const c = this.getClass(l);
-              c != null && this.setAttribute(l, Q, c);
-            }
-            this.setClass(l, n.getClasses().join(" "));
+          this.setInnerText(o, n.getInnerText());
+        }
+        if (n.hasClasses()) {
+          if (s) {
+            const l = this.getClass(o);
+            l != null && this.setAttribute(o, W, l);
           }
-          if (n.hasStyles()) {
-            if (t) {
-              const c = this.getStyles(l);
-              Object.keys(c).length > 0 && this.setAttribute(
-                l,
-                Z,
-                JSON.stringify(c)
-              );
-            }
-            this.setStyles(l, n.getStyles());
+          this.setClass(o, n.getClasses().join(" "));
+        }
+        if (n.hasStyles()) {
+          if (s) {
+            const l = this.getStyles(o);
+            Object.keys(l).length > 0 && this.setAttribute(
+              o,
+              U,
+              JSON.stringify(l)
+            );
           }
-          if (n.hasAttributes()) {
-            const c = n.getAttributes();
-            if (t) {
-              const a = [];
-              c.forEach(([u]) => {
-                const h = this.getAttribute(l, u);
-                h != null && a.push([u, h]);
-              }), a.length > 0 && this.setAttribute(
-                l,
-                ee,
-                JSON.stringify(Object.fromEntries(a))
-              );
-            }
-            c.forEach(([a, u]) => {
-              this.setAttribute(l, a, u);
-            });
+          this.setStyles(o, n.getStyles());
+        }
+        if (n.hasAttributes()) {
+          const l = n.getAttributes();
+          if (s) {
+            const c = [];
+            l.forEach(([a]) => {
+              const u = this.getAttribute(o, a);
+              u != null && c.push([a, u]);
+            }), c.length > 0 && this.setAttribute(
+              o,
+              X,
+              JSON.stringify(Object.fromEntries(c))
+            );
           }
+          l.forEach(([c, a]) => {
+            this.setAttribute(o, c, a);
+          });
         }
-      });
+      }
     });
-    this.select = e, this.getAttribute = t, this.setAttribute = r, this.getClass = n, this.setClass = i, this.getStyles = l, this.setStyles = c, this.appendHTML = a, this.getInnerHTML = u, this.setInnerHTML = h, this.getInnerText = p, this.setInnerText = T;
-  }
+  };
 }
-const at = () => {
-  document.querySelectorAll(`[${Le}]`).forEach(Y);
-}, ut = (s) => {
-  const e = s.getAttribute(Q);
-  s.removeAttribute(Q), e != null && s.setAttribute("class", e);
-}, ht = () => {
-  document.querySelectorAll(`[${Q}]`).forEach((e) => ut(e));
-}, ft = (s) => {
-  const e = s.getAttribute(z);
-  s.removeAttribute(z), e != null && (s.innerHTML = e);
-}, dt = () => {
-  document.querySelectorAll(`[${z}]`).forEach((e) => ft(e));
-}, pt = (s) => {
-  const e = s.getAttribute(K);
-  s.removeAttribute(K), e != null && (s.innerText = e);
-}, gt = () => {
-  document.querySelectorAll(`[${K}]`).forEach((e) => pt(e));
-}, Me = (s) => JSON.parse(s.replace(/&quot;/g, '"')), mt = (s) => {
-  const e = s.getAttribute(Z);
-  if (s.removeAttribute(Z), e != null) {
-    const t = Me(e);
-    Object.entries(t).forEach(([r, n]) => {
-      s.style.setProperty(r, n);
+const ze = () => {
+  document.querySelectorAll(`[${Te}]`).forEach(B);
+}, Ke = (t) => {
+  const e = t.getAttribute(W);
+  t.removeAttribute(W), e != null && t.setAttribute("class", e);
+}, et = () => {
+  document.querySelectorAll(`[${W}]`).forEach((e) => Ke(e));
+}, tt = (t) => {
+  const e = t.getAttribute(J);
+  t.removeAttribute(J), e != null && (t.innerHTML = e);
+}, st = () => {
+  document.querySelectorAll(`[${J}]`).forEach((e) => tt(e));
+}, rt = (t) => {
+  const e = t.getAttribute(G);
+  t.removeAttribute(G), e != null && (t.innerText = e);
+}, nt = () => {
+  document.querySelectorAll(`[${G}]`).forEach((e) => rt(e));
+}, ve = (t) => JSON.parse(t.replace(/&quot;/g, '"')), it = (t) => {
+  const e = t.getAttribute(U);
+  if (t.removeAttribute(U), e != null) {
+    const s = ve(e);
+    Object.entries(s).forEach(([r, n]) => {
+      t.style.setProperty(r, n);
     });
   }
-}, yt = () => {
-  document.querySelectorAll(`[${Z}]`).forEach((e) => mt(e));
-}, Tt = (s) => {
-  const e = s.getAttribute(ee);
-  if (s.removeAttribute(ee), e != null) {
-    const t = Me(e);
-    Object.entries(t).forEach(([r, n]) => {
-      n == null ? s.removeAttribute(r) : s.setAttribute(r, n);
+}, ot = () => {
+  document.querySelectorAll(`[${U}]`).forEach((e) => it(e));
+}, lt = (t) => {
+  const e = t.getAttribute(X);
+  if (t.removeAttribute(X), e != null) {
+    const s = ve(e);
+    Object.entries(s).forEach(([r, n]) => {
+      n == null ? t.removeAttribute(r) : t.setAttribute(r, n);
     });
   }
-}, bt = () => {
-  document.querySelectorAll(`[${ee}]`).forEach((e) => Tt(e));
-}, ts = () => {
-  at(), ht(), gt(), dt(), yt(), bt();
-}, C = Symbol("class"), L = Symbol("style"), $ = Symbol("handler"), Oe = () => Math.random().toString(36).substring(2, 15), St = (s) => s.replace(/<[^>]*>?/g, "");
-class Ie {
+}, ct = () => {
+  document.querySelectorAll(`[${X}]`).forEach((e) => lt(e));
+}, Xt = () => {
+  ze(), et(), nt(), st(), ot(), ct();
+}, M = Symbol("class"), I = Symbol("style"), q = Symbol("handler"), Ae = () => Math.random().toString(36).substring(2, 15), at = (t) => t.replace(/<[^>]*>?/g, "");
+class _e {
   constructor(e) {
-    o(this, "id", Oe());
-    o(this, "properties", {});
-    o(this, "children", []);
-    o(this, "isElement", () => !0);
-    o(this, "isText", () => !1);
-    o(this, "getText", () => this.properties.innerText != null ? this.properties.innerText : this.properties.innerHTML != null ? St(this.properties.innerHTML) : this.children.map((e) => e.getText()).join(""));
-    o(this, "removeChild", (e) => {
-      const t = this.children.indexOf(e);
-      t !== -1 && this.children.splice(t, 1);
-    });
-    o(this, "remove", () => {
-      if (this.parent != null)
-        this.parent.removeChild(this);
-      else
-        throw new Error("Parent is undefined");
-    });
-    o(this, "getPortals", () => {
-      const e = this.elements().flatMap((t) => t.isPortal() ? [t, ...t.getPortals()] : t.getPortals());
-      return this.isPortal() && e.unshift(this), e;
-    });
-    o(this, "elements", () => this.children.filter((e) => e.isElement()));
-    o(this, "hasInnerHTML", () => this.properties.innerHTML != null);
-    o(this, "getInnerHTML", () => this.properties.innerHTML ?? "");
-    o(this, "getInnerText", () => this.properties.innerText ?? "");
-    o(this, "hasInnerText", () => this.properties.innerText != null);
-    o(this, "hasChildren", () => this.children.length > 0);
-    o(this, "hasClasses", () => this.properties[C] != null);
-    o(this, "hasStyles", () => this.properties[L] != null);
-    o(this, "hasAttributes", () => Object.keys(this.properties).length > 0);
-    o(this, "hasHandlers", () => this.properties[$] != null);
-    o(this, "hasRenderableProperties", () => this.hasClasses() || this.hasAttributes() || this.hasStyles());
-    o(this, "getById", (e) => {
-      if (this.properties.id === e)
-        return this;
-      for (const t of this.elements()) {
-        const r = t.getById(e);
-        if (r != null)
-          return r;
-      }
-    });
-    o(this, "trigger", (e, t) => {
-      ((this.properties[$] ?? {})[e] ?? []).forEach((n) => n(t));
-    });
-    o(this, "click", () => {
-      this.trigger("click", {});
-    });
-    o(this, "on", (e, t, r, n) => {
-      var a;
-      const i = (a = this.properties)[$] ?? (a[$] = {}), l = n != null && n.once ? (u) => {
-        c(), t(u, r);
-      } : (u) => t(u, r);
-      i[e] = [...i[e] ?? [], l];
-      const c = () => {
-        const u = i[e] ?? [], h = u.indexOf(l);
-        h !== -1 && (u.splice(h, 1), u.length === 0 ? (delete i[e], Object.keys(i).length === 0 && delete this.properties[$]) : i[e] = u, (n == null ? void 0 : n.signal) != null && n.signal.removeEventListener("abort", c));
-      };
-      return (n == null ? void 0 : n.signal) != null && n.signal.addEventListener("abort", c), c;
-    });
-    o(this, "addClasses", (e) => {
-      var r;
-      if (e.length === 0)
-        return;
-      const t = (r = this.properties)[C] ?? (r[C] = []);
-      e.forEach((n) => {
-        t.includes(n) || t.push(n);
-      });
-    });
-    o(this, "removeClasses", (e) => {
-      var r;
-      if (e.length === 0)
-        return;
-      const t = (r = this.properties)[C] ?? (r[C] = []);
-      e.forEach((n) => {
-        const i = t.indexOf(n);
-        i !== -1 && t.splice(i, 1);
-      }), t.length === 0 && delete this.properties[C];
-    });
-    o(this, "getClasses", () => this.properties[C] ?? []);
-    o(this, "getAttributes", () => Object.entries(this.properties).filter(
-      ([e]) => !["innerText", "innerHTML"].includes(e)
-    ));
-    o(this, "getVisibleAttributes", () => Reflect.ownKeys(this.properties).flatMap(
-      (e) => e === C ? [["class", this.getClasses()]] : e === L ? [["style", this.getStyles()]] : typeof e == "string" ? [[e, String(this.properties[e])]] : []
-    ));
-    o(this, "setStyle", (e, t) => {
-      var n;
-      const r = (n = this.properties)[L] ?? (n[L] = {});
-      r[e] = t, t === "" && (delete r[e], Object.keys(r).length === 0 && delete this.properties[L]);
-    });
-    o(this, "getStyle", (e) => {
-      var t;
-      return ((t = this.properties[L]) == null ? void 0 : t[e]) ?? "";
-    });
-    o(this, "getStyles", () => this.properties[L] ?? {});
-    o(this, "makeAccessors", (e) => {
-      const t = this.properties;
-      return {
-        get: () => t[e],
-        set: (r) => t[e] = r
-      };
-    });
     this.parent = e;
   }
-}
-const At = (s) => s.replace(/"/g, "&quot;"), vt = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-class _t extends Ie {
-  constructor(t, r, n) {
-    super(n);
-    o(this, "isPortal", () => !1);
-    o(this, "toHTML", (t = !1) => {
-      const r = this.children.map((a) => a.toHTML()).join(""), n = this.namespace ? ` xmlns="${this.namespace}"` : "";
-      let i = null;
-      const l = this.getVisibleAttributes().map(([a, u]) => a === "class" ? ` class="${u.join(" ")}"` : a === "style" ? typeof u == "string" ? ` style="${u}"` : ` style="${Object.entries(u).map(([h, p]) => `${h}: ${p};`).join(" ")}"` : Ct.has(a) ? ` ${a}` : a === "innerHTML" ? (i = u, "") : a === "innerText" ? (i = vt(u), "") : ` ${a}="${At(u)}"`).join(""), c = t ? ` ${Le}` : "";
-      return wt.has(this.tagName) && r === "" ? `<${this.tagName}${n}${l}${c} />` : `<${this.tagName}${n}${l}${c}>${i ?? r}</${this.tagName}>`;
+  id = Ae();
+  properties = {};
+  children = [];
+  isElement = () => !0;
+  isText = () => !1;
+  getText = () => this.properties.innerText != null ? this.properties.innerText : this.properties.innerHTML != null ? at(this.properties.innerHTML) : this.children.map((e) => e.getText()).join("");
+  removeChild = (e) => {
+    const s = this.children.indexOf(e);
+    s !== -1 && this.children.splice(s, 1);
+  };
+  remove = () => {
+    if (this.parent != null)
+      this.parent.removeChild(this);
+    else
+      throw new Error("Parent is undefined");
+  };
+  getPortals = () => {
+    const e = this.elements().flatMap((s) => s.isPortal() ? [s, ...s.getPortals()] : s.getPortals());
+    return this.isPortal() && e.unshift(this), e;
+  };
+  elements = () => this.children.filter((e) => e.isElement());
+  hasInnerHTML = () => this.properties.innerHTML != null;
+  getInnerHTML = () => this.properties.innerHTML ?? "";
+  getInnerText = () => this.properties.innerText ?? "";
+  hasInnerText = () => this.properties.innerText != null;
+  hasChildren = () => this.children.length > 0;
+  hasClasses = () => this.properties[M] != null;
+  hasStyles = () => this.properties[I] != null;
+  hasAttributes = () => Object.keys(this.properties).length > 0;
+  hasHandlers = () => this.properties[q] != null;
+  hasRenderableProperties = () => this.hasClasses() || this.hasAttributes() || this.hasStyles();
+  getById = (e) => {
+    if (this.properties.id === e)
+      return this;
+    for (const s of this.elements()) {
+      const r = s.getById(e);
+      if (r != null)
+        return r;
+    }
+  };
+  trigger = (e, s) => {
+    ((this.properties[q] ?? {})[e] ?? []).forEach((n) => n(s));
+  };
+  click = () => {
+    this.trigger("click", {});
+  };
+  on = (e, s, r, n) => {
+    const i = this.properties[q] ??= {}, o = n?.once ? (c) => {
+      l(), s(c, r);
+    } : (c) => s(c, r);
+    i[e] = [...i[e] ?? [], o];
+    const l = () => {
+      const c = i[e] ?? [], a = c.indexOf(o);
+      a !== -1 && (c.splice(a, 1), c.length === 0 ? (delete i[e], Object.keys(i).length === 0 && delete this.properties[q]) : i[e] = c, n?.signal != null && n.signal.removeEventListener("abort", l));
+    };
+    return n?.signal != null && n.signal.addEventListener("abort", l), l;
+  };
+  addClasses = (e) => {
+    if (e.length === 0)
+      return;
+    const s = this.properties[M] ??= [];
+    e.forEach((r) => {
+      s.includes(r) || s.push(r);
     });
-    this.tagName = t, this.namespace = r;
+  };
+  removeClasses = (e) => {
+    if (e.length === 0)
+      return;
+    const s = this.properties[M] ??= [];
+    e.forEach((r) => {
+      const n = s.indexOf(r);
+      n !== -1 && s.splice(n, 1);
+    }), s.length === 0 && delete this.properties[M];
+  };
+  getClasses = () => this.properties[M] ?? [];
+  getAttributes = () => Object.entries(this.properties).filter(
+    ([e]) => !["innerText", "innerHTML"].includes(e)
+  );
+  getVisibleAttributes = () => Reflect.ownKeys(this.properties).flatMap(
+    (e) => e === M ? [["class", this.getClasses()]] : e === I ? [["style", this.getStyles()]] : typeof e == "string" ? [[e, String(this.properties[e])]] : []
+  );
+  setStyle = (e, s) => {
+    const r = this.properties[I] ??= {};
+    r[e] = s, s === "" && (delete r[e], Object.keys(r).length === 0 && delete this.properties[I]);
+  };
+  getStyle = (e) => this.properties[I]?.[e] ?? "";
+  getStyles = () => this.properties[I] ?? {};
+  makeAccessors = (e) => {
+    const s = this.properties;
+    return {
+      get: () => s[e],
+      set: (r) => s[e] = r
+    };
+  };
+}
+const ut = (t) => t.replace(/"/g, "&quot;"), ht = (t) => t.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+class ft extends _e {
+  constructor(e, s, r) {
+    super(r), this.tagName = e, this.namespace = s;
   }
+  isPortal = () => !1;
+  toHTML = (e = !1) => {
+    const s = this.children.map((l) => l.toHTML()).join(""), r = this.namespace ? ` xmlns="${this.namespace}"` : "";
+    let n = null;
+    const i = this.getVisibleAttributes().map(([l, c]) => l === "class" ? ` class="${c.join(" ")}"` : l === "style" ? typeof c == "string" ? ` style="${c}"` : ` style="${Object.entries(c).map(([a, u]) => `${a}: ${u};`).join(" ")}"` : pt.has(l) ? ` ${l}` : l === "innerHTML" ? (n = c, "") : l === "innerText" ? (n = ht(c), "") : ` ${l}="${ut(c)}"`).join(""), o = e ? ` ${Te}` : "";
+    return mt.has(this.tagName) && s === "" ? `<${this.tagName}${r}${i}${o} />` : `<${this.tagName}${r}${i}${o}>${n ?? s}</${this.tagName}>`;
+  };
 }
-class ke extends Ie {
-  constructor(t, r) {
-    super(r);
-    o(this, "isPortal", () => !0);
-    o(this, "toHTML", () => "");
-    o(this, "contentToHTML", (t = !1) => this.children.map((r) => r.toHTML(t)).join(""));
-    this.selector = t;
+class Ee extends _e {
+  constructor(e, s) {
+    super(s), this.selector = e;
   }
+  isPortal = () => !0;
+  toHTML = () => "";
+  contentToHTML = (e = !1) => this.children.map((s) => s.toHTML(e)).join("");
 }
-class Et {
+class dt {
   constructor(e) {
-    o(this, "id", Oe());
-    o(this, "isElement", () => !1);
-    o(this, "isText", () => !0);
-    o(this, "getText", () => this.text);
-    o(this, "toHTML", () => this.text);
     this.text = e;
   }
+  id = Ae();
+  isElement = () => !1;
+  isText = () => !0;
+  getText = () => this.text;
+  toHTML = () => this.text;
 }
-class V {
-  constructor(e, t, r, n) {
-    o(this, "appendOrInsert", (e) => {
-      if (this.reference != null) {
-        const t = this.element.children.indexOf(this.reference);
-        this.element.children.splice(t, 0, e);
-      } else
-        this.element.children.push(e);
-    });
-    o(this, "makeChildElement", (e, t) => {
-      const r = new _t(e, t, this.element);
-      return this.appendOrInsert(r), new V(
-        r,
-        void 0,
-        this.container,
-        this.providers
-      );
-    });
-    o(this, "makeChildText", (e) => {
-      const t = new Et(e);
-      return this.appendOrInsert(t), new V(
-        this.element,
-        t,
-        this.container,
-        this.providers
-      );
-    });
-    o(this, "setText", (e) => {
-      this.reference && this.reference.isText() && (this.reference.text = e);
-    });
-    o(this, "getText", () => {
-      var e;
-      return ((e = this.reference) == null ? void 0 : e.getText()) ?? this.element.getText();
-    });
-    o(this, "makeRef", () => this.makeChildText(""));
-    o(this, "makePortal", (e) => {
-      const t = new ke(e, this.element);
-      return this.appendOrInsert(t), new V(
-        t,
-        void 0,
-        this.container,
-        this.providers
-      );
-    });
-    /**
-     * Sets a provider for the given provider mark.
-     *
-     * @param mark - The provider mark to set the provider for.
-     * @param value - The provider to set for the given mark.
-     * @returns A new `DOMContext` instance with the specified provider.
-     */
-    o(this, "setProvider", (e, t, r) => new V(this.element, this.reference, this.container, {
-      ...this.providers,
-      [e]: [t, r]
-    }));
-    o(this, "getProvider", (e) => {
-      if (this.providers[e] === void 0)
-        throw new De(e);
-      const [t, r] = this.providers[e];
-      return { value: t, onUse: r };
-    });
-    o(this, "clear", (e) => {
-      e && (this.reference !== void 0 ? this.element.removeChild(this.reference) : this.element.remove());
-    });
-    o(this, "on", (e, t) => this.element.on(e, t, this));
-    o(this, "addClasses", (e) => this.element.addClasses(e));
-    o(this, "removeClasses", (e) => this.element.removeClasses(e));
-    o(this, "getClasses", () => this.element.getClasses());
-    o(this, "isBrowserDOM", () => !1);
-    o(this, "isBrowser", () => !1);
-    o(this, "isHeadlessDOM", () => !0);
-    o(this, "isHeadless", () => !0);
-    o(this, "setStyle", (e, t) => this.element.setStyle(e, t));
-    o(this, "getStyle", (e) => this.element.getStyle(e));
-    o(this, "makeAccessors", (e) => this.element.makeAccessors(e));
-    this.element = e, this.reference = t, this.container = r, this.providers = n;
+class $ {
+  constructor(e, s, r, n) {
+    this.element = e, this.reference = s, this.container = r, this.providers = n;
   }
+  appendOrInsert = (e) => {
+    if (this.reference != null) {
+      const s = this.element.children.indexOf(this.reference);
+      this.element.children.splice(s, 0, e);
+    } else
+      this.element.children.push(e);
+  };
+  makeChildElement = (e, s) => {
+    const r = new ft(e, s, this.element);
+    return this.appendOrInsert(r), new $(
+      r,
+      void 0,
+      this.container,
+      this.providers
+    );
+  };
+  makeChildText = (e) => {
+    const s = new dt(e);
+    return this.appendOrInsert(s), new $(
+      this.element,
+      s,
+      this.container,
+      this.providers
+    );
+  };
+  setText = (e) => {
+    this.reference && this.reference.isText() && (this.reference.text = e);
+  };
+  getText = () => this.reference?.getText() ?? this.element.getText();
+  makeRef = () => this.makeChildText("");
+  makePortal = (e) => {
+    const s = new Ee(e, this.element);
+    return this.appendOrInsert(s), new $(
+      s,
+      void 0,
+      this.container,
+      this.providers
+    );
+  };
+  /**
+   * Sets a provider for the given provider mark.
+   *
+   * @param mark - The provider mark to set the provider for.
+   * @param value - The provider to set for the given mark.
+   * @returns A new `DOMContext` instance with the specified provider.
+   */
+  setProvider = (e, s, r) => new $(this.element, this.reference, this.container, {
+    ...this.providers,
+    [e]: [s, r]
+  });
+  getProvider = (e) => {
+    if (this.providers[e] === void 0)
+      throw new Se(e);
+    const [s, r] = this.providers[e];
+    return { value: s, onUse: r };
+  };
+  clear = (e) => {
+    e && (this.reference !== void 0 ? this.element.removeChild(this.reference) : this.element.remove());
+  };
+  on = (e, s) => this.element.on(e, s, this);
+  addClasses = (e) => this.element.addClasses(e);
+  removeClasses = (e) => this.element.removeClasses(e);
+  getClasses = () => this.element.getClasses();
+  isBrowserDOM = () => !1;
+  isBrowser = () => !1;
+  isHeadlessDOM = () => !0;
+  isHeadless = () => !0;
+  setStyle = (e, s) => this.element.setStyle(e, s);
+  getStyle = (e) => this.element.getStyle(e);
+  makeAccessors = (e) => this.element.makeAccessors(e);
 }
-const Ct = /* @__PURE__ */ new Set([
+const pt = /* @__PURE__ */ new Set([
   "checked",
   "disabled",
   "multiple",
   "readonly",
   "required",
   "selected"
-]), wt = /* @__PURE__ */ new Set(["img", "br", "hr", "input", "link", "meta"]), He = (s) => (e) => e.makeChildText(s).clear, $e = (s) => (e) => {
-  const t = e.makeChildText(s.value), r = s.on(t.setText);
+]), mt = /* @__PURE__ */ new Set(["img", "br", "hr", "input", "link", "meta"]), Ce = (t) => (e) => e.makeChildText(t).clear, Pe = (t) => (e) => {
+  const s = e.makeChildText(t.value), r = t.on(s.setText);
   return (n) => {
-    r(), t.clear(n);
+    r(), s.clear(n);
   };
-}, ss = (s) => d.is(s) ? $e(s) : He(s), _ = (...s) => (e) => {
-  const t = s.map((r) => f(r)(e));
+}, Yt = (t) => m.is(t) ? Pe(t) : Ce(t), T = (...t) => (e) => {
+  const s = t.map((r) => h(r)(e));
   return (r) => {
-    t.forEach((n) => n(r));
-  };
-}, x = () => () => {
-}, xt = (s) => (e) => (e.addClasses(s), (t) => {
-  t && e.removeClasses(s);
-}), Pt = (s) => (e) => {
-  let t = [];
-  const r = s.on((n) => {
-    e.removeClasses(t), t = (n ?? "").split(" ").filter((i) => i.length > 0), e.addClasses(t);
+    s.forEach((n) => n(r));
+  };
+}, E = () => () => {
+}, gt = (t) => (e) => (e.addClasses(t), (s) => {
+  s && e.removeClasses(t);
+}), yt = (t) => (e) => {
+  let s = [];
+  const r = t.on((n) => {
+    e.removeClasses(s), s = (n ?? "").split(" ").filter((i) => i.length > 0), e.addClasses(s);
   });
   return (n) => {
-    r(), n && e.removeClasses(t), t.length = 0;
+    r(), n && e.removeClasses(s), s.length = 0;
   };
-}, B = (s, e) => (t) => {
-  const { get: r, set: n } = t.makeAccessors(s), i = r();
-  return n(e), (l) => {
-    l && n(i);
+}, bt = (t, e) => (s) => {
+  const { get: r, set: n } = s.makeAccessors(t), i = r();
+  return n(e), (o) => {
+    o && n(i);
   };
-}, W = (s, e) => (t) => {
-  const { get: r, set: n } = t.makeAccessors(s), i = r(), l = e.on(n);
-  return (c) => {
-    l(), c && n(i);
+}, wt = (t, e) => (s) => {
+  const { get: r, set: n } = s.makeAccessors(t), i = r(), o = e.on(n);
+  return (l) => {
+    o(), l && n(i);
   };
-}, j = new Proxy(
+}, N = (t, e) => m.is(e) ? wt(t, e) : bt(t, e), Z = (t = "") => (e, s) => {
+  const r = t ? `${t}${e}` : e;
+  return N(r, s);
+}, R = new Proxy(
   {},
   {
     /**
@@ -1743,18 +1707,12 @@ const Ct = /* @__PURE__ */ new Set([
      * @returns The renderable component for the specified attribute.
      *
      */
-    get: (s, e) => e === "class" ? (t) => d.is(t) ? Pt(t) : xt(
+    get: (t, e) => e === "class" ? (s) => m.is(s) ? yt(s) : gt(
       /* c8 ignore next */
-      (t ?? "").split(" ").filter((r) => r.length > 0)
-    ) : (t) => d.is(t) ? W(
-      e,
-      t
-    ) : B(
-      e,
-      t
-    )
+      (s ?? "").split(" ").filter((r) => r.length > 0)
+    ) : e === "set" ? Z() : (s) => N(e, s)
   }
-), rs = new Proxy(
+), Qt = new Proxy(
   {},
   {
     /**
@@ -1765,12 +1723,9 @@ const Ct = /* @__PURE__ */ new Set([
      * @returns The renderable component for the specified attribute.
      *
      */
-    get: (s, e) => (t) => d.is(t) ? W(
-      `data-${e}`,
-      t
-    ) : B(`data-${e}`, t)
+    get: (t, e) => e === "set" ? Z("data-") : (s) => N(`data-${e}`, s)
   }
-), ns = new Proxy(
+), Zt = new Proxy(
   {},
   {
     /**
@@ -1781,15 +1736,9 @@ const Ct = /* @__PURE__ */ new Set([
      * @returns The renderable component for the specified attribute.
      *
      */
-    get: (s, e) => (t) => d.is(t) ? W(
-      `aria-${e}`,
-      t
-    ) : B(
-      `aria-${e}`,
-      t
-    )
+    get: (t, e) => e === "set" ? Z("aria-") : (s) => N(`aria-${e}`, s)
   }
-), is = new Proxy(
+), zt = new Proxy(
   {},
   {
     /**
@@ -1800,15 +1749,9 @@ const Ct = /* @__PURE__ */ new Set([
      * @returns The renderable component for the specified attribute.
      *
      */
-    get: (s, e) => (t) => d.is(t) ? W(
-      e,
-      t
-    ) : B(
-      e,
-      t
-    )
+    get: (t, e) => e === "set" ? Z() : (s) => N(e, s)
   }
-), os = new Proxy(
+), Kt = new Proxy(
   {},
   {
     /**
@@ -1818,37 +1761,31 @@ const Ct = /* @__PURE__ */ new Set([
      * @returns The renderable component for the specified attribute.
      *
      */
-    get: (s, e) => (t) => d.is(t) ? W(
-      e,
-      t
-    ) : B(
-      e,
-      t
-    )
+    get: (t, e) => (s) => N(e, s)
   }
-), f = (s) => {
-  if (s == null)
-    return x;
-  if (Array.isArray(s))
-    return _(...s.map(f));
-  if (typeof s == "string")
-    return He(s);
-  if (d.is(s))
-    return $e(s);
-  if (typeof s == "function")
-    return s;
-  throw new Error(`Unknown type: '${typeof s}' for child: ${s}`);
-}, Ne = (s, ...e) => (t) => {
-  const r = t.makeChildElement(s, void 0), n = e.map((i) => f(i)(r));
+), h = (t) => {
+  if (t == null)
+    return E;
+  if (Array.isArray(t))
+    return T(...t.map(h));
+  if (typeof t == "string")
+    return Ce(t);
+  if (m.is(t))
+    return Pe(t);
+  if (typeof t == "function")
+    return t;
+  throw new Error(`Unknown type: '${typeof t}' for child: ${t}`);
+}, xe = (t, ...e) => (s) => {
+  const r = s.makeChildElement(t, void 0), n = e.map((i) => h(i)(r));
   return (i) => {
-    n.forEach((l) => l(!1)), r.clear(i);
+    n.forEach((o) => o(!1)), r.clear(i);
   };
-}, Re = (s, e, ...t) => (r) => {
-  const n = r.makeChildElement(s, e), i = t.map((l) => f(l)(n));
-  return (l) => {
-    i.forEach((c) => c(!1)), n.clear(l);
+}, Le = (t, e, ...s) => (r) => {
+  const n = r.makeChildElement(t, e), i = s.map((o) => h(o)(n));
+  return (o) => {
+    i.forEach((l) => l(!1)), n.clear(o);
   };
-}, ls = new Proxy(
+}, es = new Proxy(
   {},
   {
     /**
@@ -1856,9 +1793,9 @@ const Ct = /* @__PURE__ */ new Set([
      * @param tagName - The HTML tag name.
      * @returns A renderable function that creates and appends the HTML element to the DOM.
      */
-    get: (s, e) => (...t) => Ne(e, t.flatMap(f))
+    get: (t, e) => (...s) => xe(e, s.flatMap(h))
   }
-), cs = new Proxy(
+), ts = new Proxy(
   {},
   {
     /**
@@ -1866,9 +1803,9 @@ const Ct = /* @__PURE__ */ new Set([
      * @param type - The input type name.
      * @returns A renderable function that creates and appends the HTMLInput element to the DOM.
      */
-    get: (s, e) => (...t) => Ne("input", j.type(e), ...t)
+    get: (t, e) => (...s) => xe("input", R.type(e), ...s)
   }
-), Dt = "http://www.w3.org/2000/svg", as = new Proxy(
+), St = "http://www.w3.org/2000/svg", ss = new Proxy(
   {},
   {
     /**
@@ -1876,9 +1813,9 @@ const Ct = /* @__PURE__ */ new Set([
      * @param tagName - The SVG tag name.
      * @returns A renderable function that creates and appends the SVG element to the DOM.
      */
-    get: (s, e) => (...t) => Re(e, Dt, t.flatMap(f))
+    get: (t, e) => (...s) => Le(e, St, s.flatMap(h))
   }
-), Lt = "http://www.w3.org/1998/Math/MathML", us = new Proxy(
+), Tt = "http://www.w3.org/1998/Math/MathML", rs = new Proxy(
   {},
   {
     /**
@@ -1886,35 +1823,35 @@ const Ct = /* @__PURE__ */ new Set([
      * @param tagName - The Math tag name.
      * @returns A renderable function that creates and appends the Math element to the DOM.
      */
-    get: (s, e) => (...t) => Re(e, Lt, t.flatMap(f))
+    get: (t, e) => (...s) => Le(e, Tt, s.flatMap(h))
   }
-), Ve = (s, e) => {
+), De = (t, e) => {
   if (typeof e == "function")
-    return Ve(s, { then: e });
-  const t = e.pending != null ? f(e.pending()) : x, r = e.then, n = e.error != null ? (i) => f(e.error(i)) : () => x;
+    return De(t, { then: e });
+  const s = e.pending != null ? h(e.pending()) : E, r = e.then, n = e.error != null ? (i) => h(e.error(i)) : () => E;
   return (i) => {
-    let l = !0;
-    const c = s(), a = i.makeRef();
-    let u = f(t)(a);
-    return c.then(
-      (h) => {
-        l && (u(!0), u = f(r(h))(a));
+    let o = !0;
+    const l = t(), c = i.makeRef();
+    let a = h(s)(c);
+    return l.then(
+      (u) => {
+        o && (a(!0), a = h(r(u))(c));
       },
-      (h) => {
-        l && (u(!0), u = f(n(h))(a));
+      (u) => {
+        o && (a(!0), a = h(n(u))(c));
       }
-    ), (h) => {
-      l = !1, u(h), a.clear(h);
+    ), (u) => {
+      o = !1, a(u), c.clear(u);
     };
   };
-}, hs = (s, e) => Ve(() => s, e), je = (s, e, t) => (r) => r.on(s, e, t), Mt = (s) => je("click", (e, t) => {
+}, ns = (t, e) => De(() => t, e), Oe = (t, e, s) => (r) => r.on(t, e, s), vt = (t) => Oe("click", (e, s) => {
   e.preventDefault();
   const r = e.target;
   setTimeout(() => {
-    const n = r.ownerDocument != null ? r == null ? void 0 : r.checked : void 0;
-    n != null && s(!n, t);
+    const n = r.ownerDocument != null ? r?.checked : void 0;
+    n != null && t(!n, s);
   }, 0);
-}), re = new Proxy(
+}), z = new Proxy(
   {},
   {
     /**
@@ -1922,321 +1859,334 @@ const Ct = /* @__PURE__ */ new Set([
      * @param fn - The function to call when the event is triggered.
      * @returns A `Renderable` function that adds the event listener to the element.
      */
-    get: (s, e) => (t) => je(e, t)
+    get: (t, e) => (s) => Oe(e, s)
   }
-), Ot = (s, e) => (t) => {
-  (e == null ? void 0 : e.preventDefault) === !0 && t.preventDefault(), (e == null ? void 0 : e.stopPropagation) === !0 && t.stopPropagation(), (e == null ? void 0 : e.stopImmediatePropagation) === !0 && t.stopImmediatePropagation(), s(t);
-}, I = (s, e) => Ot((t) => {
-  const r = t.target;
-  s(r, t);
-}, e), It = (s, e) => I(
-  (t, r) => s(t.value, r),
+), At = (t, e) => (s) => {
+  e?.preventDefault === !0 && s.preventDefault(), e?.stopPropagation === !0 && s.stopPropagation(), e?.stopImmediatePropagation === !0 && s.stopImmediatePropagation(), t(s);
+}, L = (t, e) => At((s) => {
+  const r = s.target;
+  t(r, s);
+}, e), _t = (t, e) => L(
+  (s, r) => t(s.value, r),
   e
-), kt = (s, e) => I(
-  (t, r) => s(t.valueAsNumber, r),
+), Et = (t, e) => L(
+  (s, r) => t(s.valueAsNumber, r),
   e
-), Ht = (s, e) => I((t, r) => {
-  if (t.value === "")
+), Ct = (t, e) => L((s, r) => {
+  if (s.value === "")
     return;
-  const n = t.value.split("-"), i = new Date(
+  const n = s.value.split("-"), i = new Date(
     Number(n[0]),
     Number(n[1]) - 1,
     Number(n[2].substring(0, 2))
   );
-  s(i, r);
-}, e), fs = (s, e) => I((t, r) => {
-  if (t.value === "") {
-    s(null, r);
+  t(i, r);
+}, e), is = (t, e) => L((s, r) => {
+  if (s.value === "") {
+    t(null, r);
     return;
   }
-  const n = t.value.split("-"), i = new Date(
+  const n = s.value.split("-"), i = new Date(
     Number(n[0]),
     Number(n[1]) - 1,
     Number(n[2].substring(0, 2))
   );
-  s(i, r);
-}, e), $t = (s, e) => I((t, r) => {
-  if (t.value === "")
+  t(i, r);
+}, e), Pt = (t, e) => L((s, r) => {
+  if (s.value === "")
     return;
-  const n = t.value.split("T"), i = n[0].split("-"), l = new Date(
+  const n = s.value.split("T"), i = n[0].split("-"), o = new Date(
     Number(i[0]),
     Number(i[1]) - 1,
     Number(i[2])
-  ), c = n[1].split(":");
-  l.setHours(Number(c[0])), l.setMinutes(Number(c[1])), l.setSeconds(Number(c[2])), s(l, r);
-}, e), ds = (s, e) => I((t, r) => {
-  if (t.value === "") {
-    s(null, r);
+  ), l = n[1].split(":");
+  o.setHours(Number(l[0])), o.setMinutes(Number(l[1])), o.setSeconds(Number(l[2])), t(o, r);
+}, e), os = (t, e) => L((s, r) => {
+  if (s.value === "") {
+    t(null, r);
     return;
   }
-  const n = t.value.split("T");
+  const n = s.value.split("T");
   if (n.length !== 2) {
-    s(null, r);
+    t(null, r);
     return;
   }
-  const i = n[0].split("-"), l = new Date(
+  const i = n[0].split("-"), o = new Date(
     Number(i[0]),
     Number(i[1]) - 1,
     Number(i[2])
-  ), c = n[1].split(":");
-  l.setHours(Number(c[0] ?? 0)), l.setMinutes(Number(c[1] ?? 0)), l.setSeconds(Number(c[2] ?? 0)), s(l, r);
-}, e), ps = (s, e) => I((t, r) => {
-  s(t.checked, r);
-}, e), gs = (s, e = "input") => _(j.valueAsDate(s), re[e](Ht(s.set))), ms = (s, e = "input") => _(j.valueAsDate(s), re[e]($t(s.set))), ys = (s, e = "input") => _(j.valueAsNumber(s), re[e](kt(s.set))), Ts = (s, e = "input") => _(j.value(s), re[e](It(s.set))), bs = (s) => _(j.checked(s), Mt(s.set)), ne = (s, e) => {
-  if (d.is(s))
-    return (r) => {
-      const n = r.makeRef();
-      let i, l;
-      const c = s.map((h) => Object.keys(h)[0]);
-      let a;
-      const u = c.on((h) => {
-        if (h !== a) {
-          a = h, l == null || l.dispose(), i == null || i(!0), l = s.map((T) => T[h]);
-          const p = e[h](l);
-          i = f(p)(n);
+  ), l = n[1].split(":");
+  o.setHours(Number(l[0] ?? 0)), o.setMinutes(Number(l[1] ?? 0)), o.setSeconds(Number(l[2] ?? 0)), t(o, r);
+}, e), ls = (t, e) => L((s, r) => {
+  t(s.checked, r);
+}, e), cs = (t, e = "input") => T(R.valueAsDate(t), z[e](Ct(t.set))), as = (t, e = "input") => T(R.valueAsDate(t), z[e](Pt(t.set))), us = (t, e = "input") => T(R.valueAsNumber(t), z[e](Et(t.set))), hs = (t, e = "input") => T(R.value(t), z[e](_t(t.set))), fs = (t) => T(R.checked(t), vt(t.set)), le = (t, e, s) => m.is(t) ? e(t) : s(t), xt = (t, e, s) => {
+  const r = t.makeRef();
+  let n = () => {
+  };
+  const i = e.on((o) => {
+    n(!0), n = h(s(o))(r);
+  });
+  return (o) => {
+    n(o), i(), r.clear(o);
+  };
+}, K = (t, e) => {
+  function s(n) {
+    return (i) => {
+      const o = i.makeRef();
+      let l, c;
+      const a = n.map((d) => Object.keys(d)[0]);
+      let u;
+      const p = a.on((d) => {
+        if (d !== u) {
+          u = d, c?.dispose(), l?.(!0), c = n.map((g) => g[d]);
+          const f = e[d](c);
+          l = h(f)(o);
         }
       });
-      return (h) => {
-        l == null || l.dispose(), u(), n.clear(h), i == null || i(h);
+      return (d) => {
+        c?.dispose(), p(), o.clear(d), l?.(d);
       };
     };
-  const t = Object.keys(s)[0];
-  return f(e[t](se(s[t])));
-}, qe = (s, e, t) => ne(
-  y.map(s, (r) => ({ [r[e]]: r })),
+  }
+  function r(n) {
+    const i = Object.keys(n)[0];
+    return h(e[i](Q(n[i])));
+  }
+  return le(t, s, r);
+}, Me = (t, e, s) => K(
+  y.map(t, (r) => ({ [r[e]]: r })),
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  t
-), Ss = (s, e) => qe(s, "kind", e), As = (s, e) => {
-  const t = y.map(s, ([r, n]) => ({ [r]: n }));
-  return ne(t, e);
-}, vs = (s, e) => qe(s, "type", e), Nt = (s, e) => ne(
-  y.map(s, (t) => ({ [t]: !0 })),
+  s
+), ds = (t, e) => Me(t, "kind", e), ps = (t, e) => {
+  const s = y.map(t, ([r, n]) => ({ [r]: n }));
+  return K(s, e);
+}, ms = (t, e) => Me(t, "type", e), Lt = (t, e) => K(
+  y.map(t, (s) => ({ [s]: !0 })),
   e
-), _s = (s, e = {}) => (t) => {
-  const r = (e == null ? void 0 : e.firstSeparator) ?? s, n = (e == null ? void 0 : e.lastSeparator) ?? s;
-  return Nt(
-    t.map((i) => i.isFirst ? "first" : i.isLast ? "last" : "other"),
+), gs = (t, e = {}) => (s) => {
+  const r = e?.firstSeparator ?? t, n = e?.lastSeparator ?? t;
+  return Lt(
+    s.map((i) => i.isFirst ? "first" : i.isLast ? "last" : "other"),
     {
       first: r,
       last: n,
-      other: s
+      other: t
     }
   );
-}, Es = (s) => (e) => (e.appendOrInsert(s), (t) => {
-  t && Y(s);
-}), Cs = (s, e, t) => {
-  if (d.is(s)) {
-    const r = s;
-    return (n) => {
-      const i = n.makeRef();
-      let l = () => {
-      }, c = !1, a = null;
-      const u = r.on((h) => {
-        h == null ? (l(!0), l = f(t == null ? void 0 : t())(i), c = !1, a == null || a.dispose(), a = null) : c ? a.set(h) : (a = w(h), l(!0), l = f(e(a))(
-          i
-        ), c = !0);
+}, ys = (t) => (e) => (e.appendOrInsert(t), (s) => {
+  s && B(t);
+}), bs = (t, e, s) => {
+  function r(i) {
+    return (o) => {
+      const l = o.makeRef();
+      let c = () => {
+      }, a = !1, u = null;
+      const p = i.on((d) => {
+        d == null ? (c(!0), c = h(s?.())(l), a = !1, u?.dispose(), u = null) : a ? u.set(d) : (u = _(d), c(!0), c = h(e(u))(
+          l
+        ), a = !0);
       });
-      return (h) => {
-        a == null || a.dispose(), u(), l == null || l(h), i.clear(h);
+      return (d) => {
+        u?.dispose(), p(), c?.(d), l.clear(d);
       };
     };
-  } else {
-    const r = s;
-    if (r == null) {
-      const n = t == null ? void 0 : t();
-      return n != null ? f(n) : x;
+  }
+  function n(i) {
+    if (i == null) {
+      const o = s?.();
+      return o != null ? h(o) : E;
     }
-    return f(e(se(r)));
+    return h(e(Q(i)));
   }
-}, ws = (...s) => (e, t) => (r) => {
+  return le(
+    t,
+    r,
+    n
+  );
+}, ws = (...t) => (e, s) => (r) => {
   const n = r.makeRef();
-  if (s.some(
-    (g) => !d.is(g) && g == null
+  if (t.some(
+    (f) => !m.is(f) && f == null
   ))
-    return (t != null ? f(t == null ? void 0 : t()) : x)(
+    return (s != null ? h(s?.()) : E)(
       n
     );
-  const l = s.map(() => null), c = s.map(
-    (g) => d.is(g) ? g.value != null : g != null
+  const o = t.map(() => null), l = t.map(
+    (f) => m.is(f) ? f.value != null : f != null
   );
-  let a = null;
-  const u = w(c.every((g) => g)), h = (g, m) => {
-    if (g.value != null) {
-      if (l[m] == null) {
-        const S = w(g.value);
-        l[m] = S;
+  let c = null;
+  const a = _(l.every((f) => f)), u = (f, g) => {
+    if (f.value != null) {
+      if (o[g] == null) {
+        const w = _(f.value);
+        o[g] = w;
       } else
-        l[m].value = g.value;
-      c[m] = !0;
+        o[g].value = f.value;
+      l[g] = !0;
     } else
-      c[m] = !1;
+      l[g] = !1;
   };
-  let p = s.length - 1;
-  const T = s.map((g, m) => {
-    if (!d.is(g)) {
-      const S = w(g);
-      return l[m] = S, () => {
+  let p = t.length - 1;
+  const d = t.map((f, g) => {
+    if (!m.is(f)) {
+      const w = _(f);
+      return o[g] = w, () => {
       };
     }
-    return g.on(() => {
-      h(g, m), p === 0 ? u.value = c.every((S) => S) : p--;
+    return f.on(() => {
+      u(f, g), p === 0 ? a.value = l.every((w) => w) : p--;
     });
   });
-  return u.on((g) => {
-    a == null || a(!0), a = null, g ? a = f(e(...l))(n) : a = f((t == null ? void 0 : t()) ?? x)(n);
-  }), (g) => {
-    l.forEach((m) => m == null ? void 0 : m.dispose()), u.dispose(), T.forEach((m) => m()), a == null || a(g), n.clear(g);
-  };
-}, q = (...s) => (e) => (t) => s.forEach((r) => r(t, e)), Fe = (s, e, t) => {
-  if (d.is(s)) {
-    const r = s;
-    return (n) => {
-      const i = n.makeRef();
-      let l = () => {
-      };
-      const c = r.on((a) => {
-        l(!0), a ? l = f(e())(i) : l = f(t == null ? void 0 : t())(i);
-      });
-      return (a) => {
-        l(a), c(), i.clear(a);
-      };
-    };
-  } else {
-    if (s) {
+  return a.on((f) => {
+    c?.(!0), c = null, f ? c = h(e(...o))(n) : c = h(s?.() ?? E)(n);
+  }), (f) => {
+    o.forEach((g) => g?.dispose()), a.dispose(), d.forEach((g) => g()), c?.(f), n.clear(f);
+  };
+}, V = (...t) => (e) => (s) => t.forEach((r) => {
+  typeof r == "function" ? r(s, e) : r.dispose(s, e);
+}), Ie = (t, e, s) => le(
+  t,
+  (r) => (n) => xt(
+    n,
+    r,
+    (i) => i ? e() : s?.()
+  ),
+  (r) => {
+    if (r) {
       const n = e();
-      return n != null ? f(n) : x;
+      return n != null ? h(n) : E;
     }
-    return f(t == null ? void 0 : t());
+    return h(s?.());
   }
-}, xs = (s, e, t) => Fe(
-  y.map(s, (r) => !r),
+), Ss = (t, e, s) => Ie(
+  y.map(t, (r) => !r),
   e,
-  t
-), Be = (s, e, t) => {
-  if (t != null)
-    return Be(s, (r) => {
-      const n = new ce(
+  s
+), He = (t, e, s) => {
+  if (s != null)
+    return He(t, (r) => {
+      const n = new se(
         r.index,
         r.total.map((i) => i - 1)
       );
-      return _(
-        q(n.dispose),
-        f(e(r)),
-        Fe(
+      return T(
+        V(n.dispose),
+        h(e(r)),
+        Ie(
           r.isLast,
-          () => x,
-          () => t(n)
+          () => E,
+          () => s(n)
         )
       );
     });
-  if (d.is(s))
+  if (m.is(t))
     return (r) => {
-      const n = s.derive(), i = r.makeRef(), l = [];
-      return n.on((c) => {
-        const a = l.splice(c);
-        for (const u of a)
-          u(!0);
-        for (let u = l.length; u < c; u++) {
-          const h = new ce(u, n);
-          l.push(
-            _(
-              q(h.dispose),
-              f(e(h))
+      const n = t.derive(), i = r.makeRef(), o = [];
+      return n.on((l) => {
+        const c = o.splice(l);
+        for (const a of c)
+          a(!0);
+        for (let a = o.length; a < l; a++) {
+          const u = new se(a, n);
+          o.push(
+            T(
+              V(u.dispose),
+              h(e(u))
             )(i)
           );
         }
-      }), (c) => {
+      }), (l) => {
         n.dispose();
-        for (const a of l)
-          a(c);
-        l.length = 0, i.clear(c);
+        for (const c of o)
+          c(l);
+        o.length = 0, i.clear(l);
       };
     };
   {
-    const r = se(s);
-    return _(
-      ...Array.from({ length: s }, (n, i) => i).map((n) => {
-        const i = new ce(n, r);
-        return _(
-          q(i.dispose),
-          f(e(i))
+    const r = Q(t);
+    return T(
+      ...Array.from({ length: t }, (n, i) => i).map((n) => {
+        const i = new se(n, r);
+        return T(
+          V(i.dispose),
+          h(e(i))
         );
       })
     );
   }
-}, Ps = (s, e, t) => {
-  const r = y.map(s, (i) => i.length), n = y.toSignal(s);
-  return Be(
+}, Ts = (t, e, s) => {
+  const r = y.map(t, (i) => i.length), n = y.toSignal(t);
+  return He(
     r,
     (i) => {
-      const l = n.map((c) => c[i.index]);
-      return _(
-        q(l.dispose),
-        f(e(l, i))
+      const o = n.map((l) => l[i.index]);
+      return T(
+        V(o.dispose),
+        h(e(o, i))
       );
     },
-    t
+    s
   );
-}, Ds = (s, e) => {
-  if (d.is(s)) {
-    const t = s;
+}, vs = (t, e) => {
+  if (m.is(t)) {
+    const s = t;
     return (r) => {
       r = r.makeRef();
-      const n = t.map((c) => f(e(c)));
+      const n = s.map((l) => h(e(l)));
       let i = () => {
       };
-      const l = n.on((c) => {
-        i(!0), i = c(r);
+      const o = n.on((l) => {
+        i(!0), i = l(r);
       });
-      return (c) => {
-        l(), i(c);
+      return (l) => {
+        o(), i(l);
       };
     };
   }
-  return f(e(s));
-}, Ls = (s, e, t = () => x) => ne(
+  return h(e(t));
+}, As = (t, e, s = () => E) => K(
   y.map(
-    s,
+    t,
     (r) => r.length > 0 ? { notEmpty: r } : { whenEmpty: null }
   ),
   {
     notEmpty: (r) => e(r),
-    whenEmpty: () => t()
+    whenEmpty: () => s()
   }
-), Ms = (s, e) => (t) => {
-  const r = t.makePortal(s), n = fe(f(e), r);
+), _s = (t, e) => (s) => {
+  const r = s.makePortal(t), n = oe(h(e), r);
   return () => n(!0);
-}, G = /* @__PURE__ */ new Map(), Rt = (s) => ({
-  mark: lt(`Probe(${s.description})`),
+}, F = /* @__PURE__ */ new Map(), Dt = (t) => ({
+  mark: Qe(`Probe(${t.description})`),
   create: ({ callback: e = () => {
-  }, timeout: t = 10 } = {}) => {
-    const r = (c) => {
-      clearTimeout(n), G.delete(s), e(c);
+  }, timeout: s = 10 } = {}) => {
+    const r = (l) => {
+      clearTimeout(n), F.delete(t), e(l);
     };
-    if (G.has(s))
-      throw new Error(`Probe already exists: ${s.description}`);
-    const n = setTimeout(() => r("timeout"), t), i = { counter: 0, timeoutId: n };
-    return G.set(s, i), {
+    if (F.has(t))
+      throw new Error(`Probe already exists: ${t.description}`);
+    const n = setTimeout(() => r("timeout"), s), i = { counter: 0, timeoutId: n };
+    return F.set(t, i), {
       value: () => {
         clearTimeout(n);
-        const c = G.get(s);
-        c != null && --c.counter === 0 && r("resolved");
+        const l = F.get(t);
+        l != null && --l.counter === 0 && r("resolved");
       },
       dispose: () => r("disposed"),
       onUse: () => i.counter++
     };
   }
-}), Os = Rt(Symbol("GlobalProbe")), Te = (s, e) => (t) => {
-  const r = t.getStyle(s);
-  return t.setStyle(s, e), (n) => {
-    n && t.setStyle(s, r);
+}), Es = Dt(Symbol("GlobalProbe")), Ot = (t, e) => (s) => {
+  const r = s.getStyle(t);
+  return s.setStyle(t, e), (n) => {
+    n && s.setStyle(t, r);
   };
-}, be = (s, e) => (t) => {
-  const r = t.getStyle(s), n = e.on((i) => t.setStyle(s, i));
+}, Mt = (t, e) => (s) => {
+  const r = s.getStyle(t), n = e.on((i) => s.setStyle(t, i));
   return (i) => {
-    n(), i && t.setStyle(s, r);
+    n(), i && s.setStyle(t, r);
   };
-}, Is = new Proxy({}, {
+}, ue = (t, e) => m.is(e) ? Mt(t, e) : Ot(t, e), Cs = new Proxy({}, {
   /**
    * Creates a renderable component for the specified `style` property.
    *
@@ -2245,168 +2195,168 @@ const Ct = /* @__PURE__ */ new Set([
    * @returns The renderable component for the specified attribute.
    *
    */
-  get: (s, e) => e === "variable" ? (t, r) => d.is(r) ? be(t, r) : Te(t, r) : (t) => d.is(t) ? be(e, t) : Te(e, t)
-}), Vt = (s) => (e) => {
+  get: (t, e) => e === "variable" ? (s, r) => ue(s, r) : (s) => ue(e, s)
+}), It = (t) => (e) => {
   if (e.isBrowser()) {
-    const t = s(e);
-    if (t != null)
-      return f(t)(e);
+    const s = t(e);
+    if (s != null)
+      return h(s)(e);
   }
   return () => {
   };
-}, ks = (s) => (e) => {
-  const t = s(e);
-  return t == null ? () => {
-  } : f(t)(e);
-}, Hs = (s) => Vt((e) => s(e.element)), $s = (s) => (e) => {
+}, Ps = (t) => (e) => {
+  const s = t(e);
+  return s == null ? () => {
+  } : h(s)(e);
+}, xs = (t) => It((e) => t(e.element)), Ls = (t) => (e) => {
   if (e.isHeadlessDOM()) {
-    const t = s(e);
-    if (t)
-      return f(t)(e);
+    const s = t(e);
+    if (s)
+      return h(s)(e);
   }
   return () => {
   };
-}, de = (s) => (e) => {
-  let t = e;
+}, ce = (t) => (e) => {
+  let s = e;
   function r() {
-    return t;
+    return s;
   }
-  function n(c) {
-    t = c;
+  function n(l) {
+    s = l;
   }
-  const i = [], l = s({
-    use: ({ mark: c }) => {
-      const { value: a, onUse: u } = r().getProvider(c);
-      return u == null || u(), a;
+  const i = [], o = t({
+    use: ({ mark: l }) => {
+      const { value: c, onUse: a } = r().getProvider(l);
+      return a?.(), c;
     },
-    set: ({ mark: c, create: a }, u) => {
-      const { value: h, dispose: p, onUse: T } = a(u, r());
-      i.push(p), n(r().setProvider(c, h, T));
+    set: ({ mark: l, create: c }, a) => {
+      const { value: u, dispose: p, onUse: d } = c(a, r());
+      i.push(p), n(r().setProvider(l, u, d));
     }
   });
-  return l == null ? () => {
-  } : _(
-    f(l),
-    q(() => i.forEach((c) => c()))
+  return o == null ? () => {
+  } : T(
+    h(o),
+    V(() => i.forEach((l) => l()))
   )(r());
-}, Ns = (s, e, t) => de(({ set: r }) => (r(s, e), t())), Rs = (s, e) => de(({ use: t }) => e(t(s))), Vs = (...s) => (e) => de(({ use: t }) => {
-  const r = s.map(t);
+}, Ds = (t, e, s) => ce(({ set: r }) => (r(t, e), s())), Os = (t, e) => ce(({ use: s }) => e(s(t))), Ms = (...t) => (e) => ce(({ use: s }) => {
+  const r = t.map(s);
   return e(...r);
 });
 export {
-  hs as Async,
-  bs as BindChecked,
-  gs as BindDate,
-  ms as BindDateTime,
-  ys as BindNumber,
-  Ts as BindText,
-  R as BrowserContext,
-  Q as CLASS_PLACEHOLDER_ATTR,
-  N as Computed,
-  _s as Conjunction,
-  Es as DOMNode,
-  Ne as El,
-  Re as ElNS,
-  ce as ElementPosition,
-  x as Empty,
-  Cs as Ensure,
+  ns as Async,
+  fs as BindChecked,
+  cs as BindDate,
+  as as BindDateTime,
+  us as BindNumber,
+  hs as BindText,
+  k as BrowserContext,
+  W as CLASS_PLACEHOLDER_ATTR,
+  H as Computed,
+  gs as Conjunction,
+  ys as DOMNode,
+  xe as El,
+  Le as ElNS,
+  se as ElementPosition,
+  E as Empty,
+  bs as Ensure,
   ws as EnsureAll,
-  Ps as ForEach,
-  _ as Fragment,
-  Os as GlobalProbe,
-  es as HeadlessAdapter,
-  V as HeadlessContext,
-  _t as HeadlessElement,
-  ke as HeadlessPortal,
-  Et as HeadlessText,
-  Ds as MapSignal,
-  Ae as MemoryStore,
-  Ls as NotEmpty,
-  Mt as OnChecked,
-  q as OnDispose,
-  ne as OneOf,
-  qe as OneOfField,
-  Ss as OneOfKind,
-  As as OneOfTuple,
-  vs as OneOfType,
-  Nt as OneOfValue,
-  Ms as Portal,
-  X as Prop,
-  Ns as Provide,
-  De as ProviderNotFoundError,
-  ct as RenderingError,
-  Be as Repeat,
-  d as Signal,
-  Ve as Task,
-  ss as TextNode,
-  xs as Unless,
-  Rs as Use,
-  Vs as UseMany,
+  Ts as ForEach,
+  T as Fragment,
+  Es as GlobalProbe,
+  Gt as HeadlessAdapter,
+  $ as HeadlessContext,
+  ft as HeadlessElement,
+  Ee as HeadlessPortal,
+  dt as HeadlessText,
+  vs as MapSignal,
+  fe as MemoryStore,
+  As as NotEmpty,
+  vt as OnChecked,
+  V as OnDispose,
+  K as OneOf,
+  Me as OneOfField,
+  ds as OneOfKind,
+  ps as OneOfTuple,
+  ms as OneOfType,
+  Lt as OneOfValue,
+  _s as Portal,
+  Y as Prop,
+  Ds as Provide,
+  Se as ProviderNotFoundError,
+  Ze as RenderingError,
+  He as Repeat,
+  m as Signal,
+  De as Task,
+  Yt as TextNode,
+  Ss as Unless,
+  Os as Use,
+  Ms as UseMany,
   y as Value,
-  Fe as When,
-  Vt as WithBrowserCtx,
-  ks as WithCtx,
-  Hs as WithElement,
-  $s as WithHeadlessCtx,
-  de as WithProvider,
-  Le as _NODE_PLACEHOLDER_ATTR,
-  ot as _getSelfOrParentElement,
-  Pe as _isElement,
-  it as _makeGetter,
-  nt as _makeSetter,
-  Y as _removeDOMNode,
-  $e as _signalText,
-  He as _staticText,
-  Ut as animateSignal,
-  st as animateSignals,
-  ns as aria,
-  j as attr,
-  Qt as bind,
-  Zt as coalesce,
-  ae as computed,
-  he as computedOf,
-  rt as computedRecord,
-  rs as dataAttr,
-  Gt as delaySignal,
-  ze as effect,
-  Ft as effectOf,
-  Ot as emit,
-  ps as emitChecked,
-  I as emitTarget,
-  It as emitValue,
-  Ht as emitValueAsDate,
-  $t as emitValueAsDateTime,
-  fs as emitValueAsNullableDate,
-  ds as emitValueAsNullableDateTime,
-  kt as emitValueAsNumber,
-  Ye as endInterpolate,
-  ue as getWindow,
-  Qe as guessInterpolate,
-  ls as html,
-  cs as input,
-  Xe as interpolateDate,
-  Je as interpolateNumber,
-  Ge as interpolateString,
-  qt as joinSignals,
-  Bt as localStorageProp,
-  Rt as makeProbe,
-  lt as makeProviderMark,
-  us as math,
-  os as mathAttr,
-  Jt as merge,
-  re as on,
-  Xt as previousSignal,
-  w as prop,
-  zt as render,
-  fe as renderWithContext,
-  f as renderableOfTNode,
-  ts as restoreTempoPlaceholders,
-  Kt as runHeadless,
-  Wt as sessionStorageProp,
-  se as signal,
-  Yt as slidingWindowSignal,
-  ve as storedProp,
-  Is as style,
-  as as svg,
-  is as svgAttr
+  Ie as When,
+  It as WithBrowserCtx,
+  Ps as WithCtx,
+  xs as WithElement,
+  Ls as WithHeadlessCtx,
+  ce as WithProvider,
+  Te as _NODE_PLACEHOLDER_ATTR,
+  Ye as _getSelfOrParentElement,
+  we as _isElement,
+  Xe as _makeGetter,
+  Ge as _makeSetter,
+  B as _removeDOMNode,
+  Pe as _signalText,
+  Ce as _staticText,
+  Rt as animateSignal,
+  Ue as animateSignals,
+  Zt as aria,
+  R as attr,
+  Bt as bind,
+  Wt as coalesce,
+  re as computed,
+  ie as computedOf,
+  Je as computedRecord,
+  Qt as dataAttr,
+  jt as delaySignal,
+  qe as effect,
+  kt as effectOf,
+  At as emit,
+  ls as emitChecked,
+  L as emitTarget,
+  _t as emitValue,
+  Ct as emitValueAsDate,
+  Pt as emitValueAsDateTime,
+  is as emitValueAsNullableDate,
+  os as emitValueAsNullableDateTime,
+  Et as emitValueAsNumber,
+  Re as endInterpolate,
+  ne as getWindow,
+  Ve as guessInterpolate,
+  es as html,
+  ts as input,
+  Ne as interpolateDate,
+  ke as interpolateNumber,
+  $e as interpolateString,
+  Ht as joinSignals,
+  $t as localStorageProp,
+  Dt as makeProbe,
+  Qe as makeProviderMark,
+  rs as math,
+  Kt as mathAttr,
+  Vt as merge,
+  z as on,
+  qt as previousSignal,
+  _ as prop,
+  Ut as render,
+  oe as renderWithContext,
+  h as renderableOfTNode,
+  Xt as restoreTempoPlaceholders,
+  Jt as runHeadless,
+  Nt as sessionStorageProp,
+  Q as signal,
+  Ft as slidingWindowSignal,
+  de as storedProp,
+  Cs as style,
+  ss as svg,
+  zt as svgAttr
 };