elements-kit 0.0.17 → 0.0.19

package/dist/jsx-runtime/index.d.mts

@@ -1,73 +1,2 @@
-import { t as CustomElementRegistry } from "../define-CjbTZ3VG.mjs";
-import { a as Props, c as ComponentClass, i as MaybeReactiveProps, l as ComponentFn, n as ComponentProps, o as Require, r as ElementProps, s as Child, t as AnyElementCtor } from "../infer-BfzRJoCn.mjs";
-import { n as MaybeReactive } from "../index-DydGTqZU.mjs";
-import { JSX as JSX$1 } from "dom-expressions/src/jsx-h";
-
-//#region src/jsx-runtime/element.d.ts
-declare function createElement(type: string | Element | DocumentFragment | ComponentClass | ComponentFn, {
-  ref,
-  ...props
-}?: Record<string | symbol, unknown> & {
-  ref?: (el: Element) => void;
-}): Element | DocumentFragment | null;
-//#endregion
-//#region src/jsx-runtime/fragment.d.ts
-/**
- * Used by the JSX transform for `<>...</>` fragments.
- *
- * createElement wraps this in effectScope + attachDisposables, so children's
- * Symbol.dispose functions are collected via onCleanup and fired when the
- * fragment's own dispose is called.
- */
-declare function Fragment(props: {
-  children?: unknown;
-}): DocumentFragment;
-//#endregion
-//#region src/jsx-runtime/index.d.ts
-/** A value or a reactive zero-argument getter. */
-type FunctionMaybe<T> = JSX$1.FunctionMaybe<T>;
-/**
- * Maps slot names to `Child` content.
- * Use this to type `slot:name` JSX props on a custom component.
- *
- * @example
- * ```tsx
- * function Card(props: { title: string } & SlotProps<"header" | "footer">) { … }
- * // caller: <Card title="…" slot:header={<h1>…</h1>} slot:footer={<p>…</p>} />
- * ```
- */
-type SlotProps<K extends string> = { [P in K as `slot:${P}`]?: Child };
-/**
- * Get the full JSX prop types for a given tag name, including reactive
- * attributes, events, and all our namespace extensions.
- *
- * @example
- * ```ts
- * type InputProps = Attrs<"input">;   // typed props for <input>
- * type DivProps   = Attrs<"div">;     // typed props for <div>
- * ```
- */
-type Attrs<K extends keyof JSX.IntrinsicElements> = JSX.IntrinsicElements[K];
-/** Extra props injected into every intrinsic element beyond dom-expressions defaults. */
-type OurProps = {
-  ref?: (el: Element) => void;
-  [slot: `slot:${string}`]: Child;
-  [cls: `class:${string}`]: FunctionMaybe<boolean>;
-  [sty: `style:${string}`]: FunctionMaybe<string | null>;
-  [prop: `prop:${string}`]: unknown;
-};
-type WithOurProps<T> = T & OurProps;
-declare namespace JSX {
-  export type Element = globalThis.Element | globalThis.DocumentFragment | null;
-  export type ElementType = Child | ComponentClass;
-  export interface ElementChildrenAttribute {
-    children: {};
-  }
-  type RegisteredElements = { [K in keyof CustomElementRegistry]: CustomElementRegistry[K] extends AnyElementCtor ? ElementProps<CustomElementRegistry[K]> : never };
-  export type IntrinsicElements = { [K in keyof JSX$1.IntrinsicElements]: WithOurProps<JSX$1.IntrinsicElements[K]> } & RegisteredElements & {
-    /** Unregistered custom elements (`x-foo`, `my-component`, …) — loose fallback. */[customElement: `${string}-${string}`]: WithOurProps<JSX$1.DOMAttributes<HTMLElement>> & Record<string, unknown>;
-  };
-  export {};
-}
-//#endregion
-export { Attrs, type ComponentProps, type ElementProps, Fragment, FunctionMaybe, JSX, type MaybeReactive, type MaybeReactiveProps, type Props, type Require, SlotProps, createElement as h, createElement as jsx, createElement as jsxDEV, createElement as jsxs };
+import { U as createElement, _ as SlotProps, a as RawProps, b as MaybeReactive, c as ResolveProps, d as ComponentClass, f as ComponentFn, g as JSX, h as Attrs, i as Props, l as Child, m as PropsTarget, n as ElementProps, o as ReactiveProps, p as ComponentInstance, r as MaybeReactiveProps, s as Require, t as ComponentProps, u as Component, v as Fragment } from "../infer-Dv5Wk-7E.mjs";
+export { Attrs, Child, Component, ComponentClass, ComponentFn, ComponentInstance, ComponentProps, ElementProps, Fragment, JSX, MaybeReactive, MaybeReactiveProps, Props, PropsTarget, RawProps, ReactiveProps, Require, ResolveProps, SlotProps, createElement as h, createElement as jsx, createElement as jsxDEV, createElement as jsxs };

package/dist/jsx-runtime/index.mjs

@@ -1,26 +1,20 @@
-import { t as createElement } from "../element-CGVy_8TW.mjs";
-import { _ as onCleanup } from "../signals-J8dK_rA4.mjs";
+import { r as mountChild, t as createElement } from "../element-DxmInKJw.mjs";
 //#region src/jsx-runtime/fragment.ts
 /**
 * Used by the JSX transform for `<>...</>` fragments.
 *
-* createElement wraps this in effectScope + attachDisposables, so children's
-* Symbol.dispose functions are collected via onCleanup and fired when the
-* fragment's own dispose is called.
+* Each child is routed through `mountChild`, which handles Nodes, strings,
+* numbers, arrays, and reactive getters — matching the behavior of any other
+* JSX container. `mountChild` also wires each child's cleanup via its own
+* `effectScope`, which links to the enclosing `effectScope` created by
+* `createElement(Fragment, ...)` for disposal propagation.
 */
 function Fragment(props) {
 	const fragment = document.createDocumentFragment();
-	const raw = props.children;
+	const raw = props.children?.();
 	if (raw == null) return fragment;
 	const nodes = Array.isArray(raw) ? raw.flat(Infinity) : [raw];
-	const disposes = [];
-	for (const child of nodes) {
-		if (!(child instanceof Node)) continue;
-		const dispose = child[Symbol.dispose];
-		if (dispose) disposes.push(dispose);
-		fragment.appendChild(child);
-	}
-	if (disposes.length) onCleanup(() => disposes.forEach((fn) => fn()));
+	for (const child of nodes) mountChild(fragment, child);
 	return fragment;
 }
 //#endregion

package/dist/{signals-J8dK_rA4.mjs → lib-D6duEs38.mjs}

@@ -1,4 +1,3 @@
-import "./polyfill-B1lNNcum.mjs";
 //#region src/signals/system.ts
 /**
 * Creates and returns the five core graph-manipulation functions that together
@@ -908,107 +907,4 @@ function purgeDeps(sub) {
 	while (dep !== void 0) dep = unlink(dep, sub);
 }
 //#endregion
-//#region src/signals/index.ts
-function isReactive(value) {
-	return isSignal(value) || isComputed(value);
-}
-/**
-* A decorator that makes a class field reactive by automatically wrapping its value in a signal.
-*
-* The field behaves like a normal property (get/set) but reactivity is tracked under the hood.
-* Any reads will subscribe to the signal and any writes will trigger updates.
-*
-* @example
-* ```ts
-* class Counter {
-*   @reactive()
-*   count: number = 0;
-* }
-*
-* const counter = new Counter();
-* counter.count++;        // Triggers reactivity
-* console.log(counter.count); // Subscribes to changes
-* ```
-*
-* @remarks
-* Equivalent to manually creating a private signal and getter/setter:
-* ```ts
-* class Counter {
-*   #count = signal(0);
-*   get count() { return this.#count(); }
-*   set count(value) { this.#count(value); }
-* }
-* ```
-*/
-function reactive(source) {
-	const signalStore = /* @__PURE__ */ new WeakMap();
-	return (_target, context) => {
-		context.addInitializer(function() {
-			const sig = signalStore.get(this);
-			const writable = !isComputed(sig);
-			Object.defineProperty(this, context.name, {
-				get() {
-					return sig();
-				},
-				...writable && { set(value) {
-					sig(value);
-				} },
-				enumerable: true,
-				configurable: true
-			});
-		});
-		return function(initialValue) {
-			signalStore.set(this, source ? source(this) : signal(initialValue));
-			return initialValue;
-		};
-	};
-}
-/**
-* Resolve a {@link MaybeReactive} to its current value. Calls the getter
-* when reactive; returns the value as-is when static.
-*
-* @example
-* ```ts
-* resolve(5);              // 5
-* resolve(() => count());  // current count value
-* ```
-*/
-function resolve(value) {
-	return isReactive(value) ? value() : value;
-}
-/**
-* Turn a reactive-props object into a bag of per-key getters. Callers may
-* pass values or reactive sources (`signal`, `computed`); reading
-* `props.name()` inside an effect or JSX getter subscribes to whatever
-* drives it. Static values become stable thunks, signals and computed pass
-* through unchanged — so identity is preserved (`props.name === props.name`).
-*
-* @example
-* ```tsx
-* import { resolveProps } from "elements-kit/signals";
-*
-* function Greeting(raw: MaybeReactiveProps<{ name: string; excited?: boolean }>) {
-*   const props = resolveProps(raw);
-*   return (
-*     <p>
-*       Hello, {props.name}
-*       {() => (props.excited() ? "!" : ".")}
-*     </p>
-*   );
-* }
-* ```
-*/
-function resolveProps(raw) {
-	const cache = /* @__PURE__ */ new Map();
-	return new Proxy(raw, { get(target, key) {
-		let getter = cache.get(key);
-		if (!getter) {
-			const v = target[key];
-			getter = isReactive(v) ? v : () => v;
-			cache.set(key, getter);
-		}
-		return getter;
-	} });
-}
-//#endregion
-export { onCleanup as _, COMPUTED as a, untracked as b, SIGNAL as c, effect as d, effectScope as f, isSignal as g, isEffectScope as h, resolveProps as i, batch as l, isEffect as m, reactive as n, EFFECT as o, isComputed as p, resolve as r, EFFECT_SCOPE as s, isReactive as t, computed as u, signal as v, trigger as y };
+export { batch as a, effectScope as c, isEffectScope as d, isSignal as f, untracked as g, trigger as h, SIGNAL as i, isComputed as l, signal as m, EFFECT as n, computed as o, onCleanup as p, EFFECT_SCOPE as r, effect as s, COMPUTED as t, isEffect as u };

package/dist/render.d.mts

@@ -0,0 +1,21 @@
+//#region src/render.d.ts
+/**
+ * Mount a node into `target` with a scoped lifetime.
+ *
+ * `setup` runs inside a detached `effectScope`. The returned node is appended
+ * to `target`. Calling the returned `unmount` removes the node from the DOM,
+ * disposes its `Symbol.dispose` hook (JSX-created elements carry one), and
+ * tears down every `effect` / `onCleanup` registered inside `setup`.
+ *
+ * @example
+ * ```tsx
+ * import { render } from "elements-kit/render";
+ *
+ * const unmount = render(document.getElementById("app")!, () => <App />);
+ * // later
+ * unmount();
+ * ```
+ */
+declare function render(target: Element | DocumentFragment, setup: () => Node | null | undefined): () => void;
+//#endregion
+export { render };

package/dist/render.mjs

@@ -0,0 +1,32 @@
+import { t as scope } from "./scope-DM2gzOkb.mjs";
+//#region src/render.ts
+/**
+* Mount a node into `target` with a scoped lifetime.
+*
+* `setup` runs inside a detached `effectScope`. The returned node is appended
+* to `target`. Calling the returned `unmount` removes the node from the DOM,
+* disposes its `Symbol.dispose` hook (JSX-created elements carry one), and
+* tears down every `effect` / `onCleanup` registered inside `setup`.
+*
+* @example
+* ```tsx
+* import { render } from "elements-kit/render";
+*
+* const unmount = render(document.getElementById("app")!, () => <App />);
+* // later
+* unmount();
+* ```
+*/
+function render(target, setup) {
+	const [result, stop] = scope(setup);
+	if (result) target.appendChild(result);
+	return () => {
+		if (result) {
+			result[Symbol.dispose]?.();
+			result.remove?.();
+		}
+		stop();
+	};
+}
+//#endregion
+export { render };

package/dist/scope-DM2gzOkb.mjs

@@ -0,0 +1,45 @@
+import { c as effectScope, g as untracked } from "./lib-D6duEs38.mjs";
+//#region src/signals/scope.ts
+/**
+* Run `setup` inside a fresh `effectScope`. Returns `[result, stop]`.
+*
+* Use this wherever you need reactive code with an explicit lifetime outside
+* the JSX element flow — most commonly a custom element's `connectedCallback`.
+* `effect`, `onCleanup`, and any nested reactive registrations made in
+* `setup` are owned by the returned `stop`.
+*
+* `untracked` detaches the new scope from any enclosing effect so it isn't
+* torn down when that effect re-runs — its lifetime belongs solely to the
+* caller.
+*
+* @example
+* ```ts
+* class Clock extends HTMLElement {
+*   #stop?: () => void;
+*
+*   connectedCallback() {
+*     [, this.#stop] = scope(() => {
+*       const id = setInterval(() => (this.textContent = String(Date.now())), 1000);
+*       onCleanup(() => clearInterval(id));
+*     });
+*   }
+*
+*   disconnectedCallback() {
+*     this.#stop?.();
+*     this.#stop = undefined;
+*   }
+* }
+* ```
+*/
+function scope(setup) {
+	let result;
+	let stop;
+	untracked(() => {
+		stop = effectScope(() => {
+			result = setup();
+		});
+	});
+	return [result, stop];
+}
+//#endregion
+export { scope as t };

package/dist/signals/index.d.mts

@@ -1,2 +1,2 @@
-import { C as trigger, S as signal, _ as isComputed, a as isReactive, b as isSignal, c as resolveProps, d as EFFECT_SCOPE, f as SIGNAL, g as effectScope, h as effect, i as Updater, l as COMPUTED, m as computed, n as MaybeReactive, o as reactive, p as batch, r as Signal, s as resolve, t as Computed, u as EFFECT, v as isEffect, w as untracked, x as onCleanup, y as isEffectScope } from "../index-DydGTqZU.mjs";
+import { A as SIGNAL, B as signal, C as isReactive, D as COMPUTED, E as resolveProps, F as isComputed, H as untracked, I as isEffect, L as isEffectScope, M as computed, N as effect, O as EFFECT, P as effectScope, R as isSignal, S as Updater, T as resolve, V as trigger, b as MaybeReactive, j as batch, k as EFFECT_SCOPE, w as reactive, x as Signal, y as Computed, z as onCleanup } from "../infer-Dv5Wk-7E.mjs";
 export { COMPUTED, Computed, EFFECT, EFFECT_SCOPE, MaybeReactive, SIGNAL, Signal, Updater, batch, computed, effect, effectScope, isComputed, isEffect, isEffectScope, isReactive, isSignal, onCleanup, reactive, resolve, resolveProps, signal, trigger, untracked };

package/dist/signals/index.mjs

@@ -1,2 +1,116 @@
-import { _ as onCleanup, a as COMPUTED, b as untracked, c as SIGNAL, d as effect, f as effectScope, g as isSignal, h as isEffectScope, i as resolveProps, l as batch, m as isEffect, n as reactive, o as EFFECT, p as isComputed, r as resolve, s as EFFECT_SCOPE, t as isReactive, u as computed, v as signal, y as trigger } from "../signals-J8dK_rA4.mjs";
+import { a as batch, c as effectScope, d as isEffectScope, f as isSignal, g as untracked, h as trigger, i as SIGNAL, l as isComputed, m as signal, n as EFFECT, o as computed, p as onCleanup, r as EFFECT_SCOPE, s as effect, t as COMPUTED, u as isEffect } from "../lib-D6duEs38.mjs";
+import "../polyfill-B1lNNcum.mjs";
+//#region src/signals/index.ts
+function isReactive(value) {
+	return isSignal(value) || isComputed(value);
+}
+/**
+* A decorator that makes a class field reactive by automatically wrapping its value in a signal.
+*
+* The field behaves like a normal property (get/set) but reactivity is tracked under the hood.
+* Any reads will subscribe to the signal and any writes will trigger updates.
+*
+* @example
+* ```ts
+* class Counter {
+*   @reactive()
+*   count: number = 0;
+* }
+*
+* const counter = new Counter();
+* counter.count++;        // Triggers reactivity
+* console.log(counter.count); // Subscribes to changes
+* ```
+*
+* @remarks
+* Equivalent to manually creating a private signal and getter/setter:
+* ```ts
+* class Counter {
+*   #count = signal(0);
+*   get count() { return this.#count(); }
+*   set count(value) { this.#count(value); }
+* }
+* ```
+*/
+function reactive(source) {
+	const signalStore = /* @__PURE__ */ new WeakMap();
+	return (_target, context) => {
+		context.addInitializer(function() {
+			const sig = signalStore.get(this);
+			const writable = !isComputed(sig);
+			Object.defineProperty(this, context.name, {
+				get() {
+					return sig();
+				},
+				...writable && { set(value) {
+					sig(value);
+				} },
+				enumerable: true,
+				configurable: true
+			});
+		});
+		return function(initialValue) {
+			signalStore.set(this, source ? source(this) : signal(initialValue));
+			return initialValue;
+		};
+	};
+}
+/**
+* Resolve a {@link MaybeReactive} to its current value. Calls the getter
+* when reactive; returns the value as-is when static.
+*
+* @example
+* ```ts
+* resolve(5);              // 5
+* resolve(() => count());  // current count value
+* ```
+*/
+function resolve(value) {
+	return isReactive(value) ? value() : value;
+}
+/**
+* Turn a reactive-props object into a bag of per-key getters. Callers may
+* pass values or reactive sources (`signal`, `computed`); reading
+* `props.name()` inside an effect or JSX getter subscribes to whatever
+* drives it. Static values become stable thunks, signals and computed pass
+* through unchanged — so identity is preserved (`props.name === props.name`).
+*
+* The JSX runtime auto-applies this to function-component props — call
+* directly only for non-JSX call sites or nested prop bags.
+*
+* @example
+* ```ts
+* import { resolveProps } from "elements-kit/signals";
+* import { signal } from "elements-kit/signals";
+*
+* const count = signal(0);
+* const props = resolveProps({ count, label: "n" });
+* props.count();   // 0 — subscribes to count
+* props.label();   // "n"
+* ```
+*/
+function resolveProps(raw) {
+	const cache = /* @__PURE__ */ new Map();
+	const get = (key) => {
+		let getter = cache.get(key);
+		if (!getter) {
+			const v = raw[key];
+			getter = isReactive(v) ? v : () => v;
+			cache.set(key, getter);
+		}
+		return getter;
+	};
+	return new Proxy(raw, {
+		get: (_target, key) => get(key),
+		has: (_target, key) => key in raw,
+		ownKeys: (_target) => Reflect.ownKeys(raw),
+		getOwnPropertyDescriptor: (_target, key) => key in raw ? {
+			enumerable: true,
+			configurable: true,
+			writable: false,
+			value: get(key)
+		} : void 0
+	});
+}
+//#endregion
 export { COMPUTED, EFFECT, EFFECT_SCOPE, SIGNAL, batch, computed, effect, effectScope, isComputed, isEffect, isEffectScope, isReactive, isSignal, onCleanup, reactive, resolve, resolveProps, signal, trigger, untracked };

package/dist/{slot-C7GQZe-r.d.mts → slot-B5_VHB7E.d.mts}

@@ -1,6 +1,16 @@
 //#region src/lib.d.ts
 type PrimitiveNodeType = Node | string | boolean | number | bigint | symbol | Date | RegExp | null | undefined;
 //#endregion
+//#region src/polyfill.d.ts
+declare global {
+  interface SymbolConstructor {
+    readonly dispose: symbol;
+  }
+  interface Disposable {
+    [Symbol.dispose](): void;
+  }
+}
+//#endregion
 //#region src/slot.d.ts
 /**
  * A lightweight slot that reserves a region in the DOM using comment markers.

package/dist/slot.d.mts

@@ -1,2 +1,2 @@
-import { i as Slots, n as Slot, r as SlotInstance, t as SLOTS } from "./slot-C7GQZe-r.mjs";
+import { i as Slots, n as Slot, r as SlotInstance, t as SLOTS } from "./slot-B5_VHB7E.mjs";
 export { SLOTS, Slot, SlotInstance, Slots };

package/dist/{test.BmQO5GaM-DfGStnii.mjs → test.BmQO5GaM-BeO5pvCo.mjs}

@@ -10139,7 +10139,7 @@ function memo(fn) {
 	};
 }
 async function saveInlineSnapshots(environment, snapshots) {
-	const MagicString = (await import("./magic-string.es-i62WTP6J.mjs")).default;
+	const MagicString = (await import("./magic-string.es-cTgJnTCj.mjs")).default;
 	const files = new Set(snapshots.map((i) => i.file));
 	await Promise.all(Array.from(files).map(async (file) => {
 		const snaps = snapshots.filter((i) => i.file === file);

package/dist/utilities/_observe.mjs

@@ -1,4 +1,5 @@
-import { _ as onCleanup } from "../signals-J8dK_rA4.mjs";
+import { p as onCleanup } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
 //#region src/utilities/_observe.ts
 /**
 * Internal helper for observer wrappers (Intersection/Mutation/Resize).

package/dist/utilities/active-element.d.mts

@@ -1,4 +1,4 @@
-import { t as Computed } from "../index-DydGTqZU.mjs";
+import { y as Computed } from "../infer-Dv5Wk-7E.mjs";
 
 //#region src/utilities/active-element.d.ts
 declare const activeElement: Computed<Element | null>;

package/dist/utilities/active-element.mjs

@@ -1,4 +1,5 @@
-import { u as computed } from "../signals-J8dK_rA4.mjs";
+import { o as computed } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
 import { fromEvent, sync } from "./event-driven.mjs";
 import { isBrowser } from "./environment.mjs";
 //#region src/utilities/active-element.ts

package/dist/utilities/active-element.test.mjs

@@ -1,4 +1,4 @@
-import { o as describe, s as it, t as globalExpect } from "../test.BmQO5GaM-DfGStnii.mjs";
+import { o as describe, s as it, t as globalExpect } from "../test.BmQO5GaM-BeO5pvCo.mjs";
 import { activeElement } from "./active-element.mjs";
 //#region src/utilities/active-element.test.ts
 describe("activeElement (singleton)", () => {

package/dist/utilities/async.d.mts

@@ -1,4 +1,4 @@
-import { n as MaybeReactive } from "../index-DydGTqZU.mjs";
+import { b as MaybeReactive } from "../infer-Dv5Wk-7E.mjs";
 import { ComputedPromise } from "./promise.mjs";
 
 //#region src/utilities/async.d.ts

package/dist/utilities/async.mjs

@@ -1,4 +1,5 @@
-import { b as untracked, d as effect, r as resolve, v as signal } from "../signals-J8dK_rA4.mjs";
+import { g as untracked, m as signal, s as effect } from "../lib-D6duEs38.mjs";
+import { resolve } from "../signals/index.mjs";
 import { promise } from "./promise.mjs";
 //#region src/utilities/async.ts
 var Async = class {

package/dist/utilities/async.test.mjs

@@ -1,5 +1,6 @@
-import { _ as onCleanup, d as effect, v as signal } from "../signals-J8dK_rA4.mjs";
-import { n as vi, o as describe, s as it, t as globalExpect } from "../test.BmQO5GaM-DfGStnii.mjs";
+import { m as signal, p as onCleanup, s as effect } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
+import { n as vi, o as describe, s as it, t as globalExpect } from "../test.BmQO5GaM-BeO5pvCo.mjs";
 import { Async, async } from "./async.mjs";
 import { createInterval } from "./interval.mjs";
 //#region src/utilities/async.test.ts

package/dist/utilities/debounced.d.mts

@@ -1,4 +1,4 @@
-import { t as Computed } from "../index-DydGTqZU.mjs";
+import { y as Computed } from "../infer-Dv5Wk-7E.mjs";
 
 //#region src/utilities/debounced.d.ts
 /**

package/dist/utilities/debounced.mjs

@@ -1,4 +1,5 @@
-import { d as effect, v as signal } from "../signals-J8dK_rA4.mjs";
+import { m as signal, s as effect } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
 import { createTimeout } from "./timeout.mjs";
 //#region src/utilities/debounced.ts
 /**

package/dist/utilities/debounced.test.mjs

@@ -1,5 +1,6 @@
-import { f as effectScope, v as signal } from "../signals-J8dK_rA4.mjs";
-import { a as beforeEach, n as vi, o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-DfGStnii.mjs";
+import { c as effectScope, m as signal } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
+import { a as beforeEach, n as vi, o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-BeO5pvCo.mjs";
 import { createDebounced } from "./debounced.mjs";
 //#region src/utilities/debounced.test.ts
 beforeEach(() => {

package/dist/utilities/element-rect.d.mts

@@ -1,4 +1,4 @@
-import { t as Computed } from "../index-DydGTqZU.mjs";
+import { y as Computed } from "../infer-Dv5Wk-7E.mjs";
 
 //#region src/utilities/element-rect.d.ts
 type RectResult = {

package/dist/utilities/element-rect.mjs

@@ -1,4 +1,5 @@
-import { v as signal } from "../signals-J8dK_rA4.mjs";
+import { m as signal } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
 import { createResizeObserver } from "./resize-observer.mjs";
 //#region src/utilities/element-rect.ts
 /**

package/dist/utilities/element-rect.test.mjs

@@ -1,5 +1,6 @@
-import { f as effectScope } from "../signals-J8dK_rA4.mjs";
-import { n as vi, o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-DfGStnii.mjs";
+import { c as effectScope } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
+import { n as vi, o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-BeO5pvCo.mjs";
 import { createElementRect } from "./element-rect.mjs";
 //#region src/utilities/element-rect.test.ts
 afterEach(() => {

package/dist/utilities/element-scroll.d.mts

@@ -1,4 +1,4 @@
-import { r as Signal } from "../index-DydGTqZU.mjs";
+import { x as Signal } from "../infer-Dv5Wk-7E.mjs";
 
 //#region src/utilities/element-scroll.d.ts
 type ElementScrollResult = {

package/dist/utilities/element-scroll.test.mjs

@@ -1,5 +1,6 @@
-import { f as effectScope } from "../signals-J8dK_rA4.mjs";
-import { o as describe, s as it, t as globalExpect } from "../test.BmQO5GaM-DfGStnii.mjs";
+import { c as effectScope } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
+import { o as describe, s as it, t as globalExpect } from "../test.BmQO5GaM-BeO5pvCo.mjs";
 import { createElementScroll } from "./element-scroll.mjs";
 //#region src/utilities/element-scroll.test.ts
 describe("createElementScroll", () => {

package/dist/utilities/event-driven.d.mts

@@ -1,4 +1,4 @@
-import { r as Signal, t as Computed } from "../index-DydGTqZU.mjs";
+import { x as Signal, y as Computed } from "../infer-Dv5Wk-7E.mjs";
 
 //#region src/utilities/event-driven.d.ts
 /**

package/dist/utilities/event-driven.mjs

@@ -1,4 +1,5 @@
-import { _ as onCleanup, c as SIGNAL, u as computed, v as signal, y as trigger } from "../signals-J8dK_rA4.mjs";
+import { h as trigger, i as SIGNAL, m as signal, o as computed, p as onCleanup } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
 //#region src/utilities/event-driven.ts
 /**
 * Returns a `Subscribe` for one or more DOM events on a target.

package/dist/utilities/event-listener.d.mts

@@ -1,4 +1,4 @@
-import { t as Computed } from "../index-DydGTqZU.mjs";
+import { y as Computed } from "../infer-Dv5Wk-7E.mjs";
 
 //#region src/utilities/event-listener.d.ts
 /**

package/dist/utilities/event-listener.mjs

@@ -1,4 +1,5 @@
-import { _ as onCleanup, d as effect } from "../signals-J8dK_rA4.mjs";
+import { p as onCleanup, s as effect } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
 //#region src/utilities/event-listener.ts
 function on(target, type, handler, options) {
 	const add = (t) => options !== void 0 ? t.addEventListener(type, handler, options) : t.addEventListener(type, handler);