elements-kit 0.0.1 → 0.0.2

package/dist/element-B3gwJmBr.mjs

@@ -0,0 +1,277 @@
+import { effect, isReactive } from "./signals.mjs";
+import { $slots, Slot, Slots } from "./slot.mjs";
+import { t as resolveNode } from "./polyfill-DAalJpCO.mjs";
+
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+//#endregion
+//#region src/jsx-runtime/constants.ts
+var constants_exports = /* @__PURE__ */ __exportAll({ ReservedNameSpaces: () => ReservedNameSpaces });
+import * as import_dom_expressions_src_constants from "dom-expressions/src/constants";
+__reExport(constants_exports, import_dom_expressions_src_constants);
+const ReservedNameSpaces = new Set([
+	"class",
+	"on",
+	"style",
+	"prop"
+]);
+
+//#endregion
+//#region src/jsx-runtime/children.ts
+function hasSlots(node) {
+	return $slots in node;
+}
+function isChildrenProperty(node, key) {
+	if (key === "children" && (node instanceof Element || node instanceof DocumentFragment)) return true;
+	if (hasSlots(node)) {
+		const slotName = key.replace(/^slot:/, "");
+		if (Slots.has(node[$slots], slotName)) return true;
+	}
+	return key in node && node[key] instanceof Slot;
+}
+function applyChildren(node, key, value) {
+	if (hasSlots(node)) {
+		const slotName = key.replace(/^slot:/, "");
+		if (Slots.has(node[$slots], slotName)) return applySlot(node[$slots][slotName], value);
+	}
+	if (key === "children" && (node instanceof Element || node instanceof DocumentFragment)) return mountChildren(node, value);
+	if (key in node) {
+		const slot = node[key];
+		if (!(slot instanceof Slot)) return;
+		return applySlot(slot, value);
+	}
+}
+/**
+* Sets a Slot's content from a Child value.
+*/
+function applySlot(slot, value) {
+	if (typeof value === "function") return effect(() => slot.set(resolveChild(value())));
+	slot.set(resolveChild(value));
+}
+function mountChildren(el, value) {
+	const children = ensureFlatArray(value);
+	const disposers = [];
+	for (const child of children) {
+		if (typeof child === "function") {
+			const slot = Slot.new();
+			el.appendChild(slot());
+			disposers.push(effect(() => slot.set(resolveChild(child()))));
+			continue;
+		}
+		el.appendChild(resolveChild(child));
+	}
+	return disposers.length > 0 ? () => disposers.forEach((d) => d()) : void 0;
+}
+function resolveChild(value) {
+	if (Array.isArray(value)) {
+		const fragment = document.createDocumentFragment();
+		for (const item of value) fragment.appendChild(resolveChild(item));
+		return fragment;
+	}
+	if (typeof value === "function") return resolveChild(value());
+	return resolveNode(value);
+}
+/** Normalises the children prop into a flat array. */
+function ensureFlatArray(raw) {
+	return (Array.isArray(raw) ? raw : [raw]).flat(Infinity);
+}
+
+//#endregion
+//#region src/jsx-runtime/properties.ts
+function applyProps(node, props) {
+	const disposables = /* @__PURE__ */ new Set();
+	for (const [key, value] of Object.entries(props)) {
+		if (isChildrenProperty(node, key)) {
+			const disposable = applyChildren(node, key, value);
+			if (disposable) disposables.add(disposable);
+			continue;
+		}
+		if (isReactive(value)) {
+			if (isEventKey(key)) {
+				let cleanup;
+				const dispose = effect(() => {
+					if (cleanup) cleanup();
+					cleanup = setEvent(node, key, value());
+				});
+				disposables.add(() => {
+					dispose();
+					if (cleanup) cleanup();
+				});
+				continue;
+			}
+			disposables.add(effect(() => setProp(node, key, value())));
+			continue;
+		}
+		if (isEventKey(key)) {
+			disposables.add(setEvent(node, key, value));
+			continue;
+		}
+		setProp(node, key, value);
+	}
+	return disposables;
+}
+function setProp(node, key, value) {
+	const colonIdx = key.indexOf(":");
+	if (colonIdx > -1) {
+		const ns = key.slice(0, colonIdx);
+		const name = key.slice(colonIdx + 1);
+		if (ReservedNameSpaces.has(ns)) {
+			if (ns === "prop") {
+				node[name] = value;
+				return;
+			}
+			if (ns === "class") {
+				node.classList.toggle(name, Boolean(value));
+				return;
+			}
+			if (ns === "style") {
+				if (value == null || value === false) node.style.removeProperty(name);
+				else node.style.setProperty(name, String(value));
+				return;
+			}
+			return;
+		}
+		const svgNs = constants_exports.SVGNamespace[ns];
+		if (svgNs) {
+			node.setAttributeNS(svgNs, key, String(value ?? ""));
+			return;
+		}
+	}
+	if (key === "class") {
+		node.className = String(value ?? "");
+		return;
+	}
+	if (key === "style") {
+		applyStyle(node, value);
+		return;
+	}
+	if (constants_exports.ChildProperties.has(key)) {
+		node[key] = value ?? "";
+		return;
+	}
+	if (!(node instanceof SVGElement) && constants_exports.Properties.has(key)) {
+		node[key] = value;
+		return;
+	}
+	if (node instanceof Element && node.nodeName.includes("-") && key in node) {
+		try {
+			node[key] = value;
+		} catch {
+			setAttribute(node, key, value);
+		}
+		return;
+	}
+	if (!(node instanceof Element)) {
+		node[key] = value;
+		return;
+	}
+	setAttribute(node, key, value);
+}
+function applyStyle(el, value) {
+	const s = el.style;
+	if (!s) return;
+	if (typeof value === "string") s.cssText = value;
+	else if (value && typeof value === "object") Object.assign(s, value);
+}
+function setAttribute(el, key, value) {
+	if (value == null || value === false) el.removeAttribute(key);
+	else el.setAttribute(key, value === true ? "" : String(value));
+}
+function isEventKey(key) {
+	return key.startsWith("on:") || key.length > 2 && key.startsWith("on") && key[2] >= "A" && key[2] <= "Z";
+}
+function setEvent(el, key, handler) {
+	const event = key.startsWith("on:") ? key.slice(3) : key[2].toLowerCase() + key.slice(3);
+	el.addEventListener(event, handler);
+	return () => el.removeEventListener(event, handler);
+}
+
+//#endregion
+//#region src/jsx-runtime/ref.ts
+const $ref = Symbol("ref");
+
+//#endregion
+//#region src/jsx-runtime/element.ts
+function createElement(type, { [$ref]: ref, ...props } = {}) {
+	if (typeof type === "function" && !type.prototype?.render) {
+		const el = type(props);
+		if (typeof ref === "function" && el instanceof Element) ref(el);
+		return el;
+	}
+	const node = resolveElement(type);
+	if (!node) return null;
+	const disposables = applyProps(node, props);
+	if (disposables.size > 0) attachDisposables(node, disposables);
+	const el = _render(node);
+	if (typeof ref === "function" && el instanceof Element) ref(el);
+	return el;
+}
+function _render(node) {
+	if (node instanceof Element || node instanceof DocumentFragment) return node;
+	if (!node || typeof node.render !== "function") return null;
+	return _render(node.render());
+}
+/**
+* Resolves the `type` argument of createElement into a concrete DOM node:
+*   - string          → document.createElement(type)
+*   - Element         → the element itself  (apply props to an existing node)
+*   - class component → new type()
+*/
+function resolveElement(type) {
+	if (typeof type === "string") return document.createElement(type);
+	if (type instanceof Element || type instanceof DocumentFragment) return type;
+	return new type();
+}
+function hasOwnDisposable(el) {
+	return Object.hasOwn(el, Symbol.dispose);
+}
+function attachDisposables(el, disposables) {
+	const existingDispose = hasOwnDisposable(el) ? el[Symbol.dispose].bind(el) : null;
+	Object.defineProperty(el, Symbol.dispose, {
+		value() {
+			existingDispose?.();
+			disposables.forEach((fn) => fn());
+			disposables.clear();
+		},
+		configurable: true
+	});
+}
+/** Runs all cleanup functions registered by JSX props/effects on `el`. */
+function disposeElement(el) {
+	el[Symbol.dispose]?.();
+}
+
+//#endregion
+export { disposeElement as n, createElement as t };

package/dist/index.d.mts

@@ -0,0 +1,36 @@
+//#region src/components/for.d.ts
+type KeyFn<T> = (item: T, index: number) => string | number;
+type RenderFn<T> = (item: T, index: number) => Element | DocumentFragment | null;
+/**
+ * Keyed list renderer. Reconciles a reactive array into the DOM using a key
+ * function to match existing nodes — minimising create/destroy churn.
+ *
+ * Reconciliation strategy (inspired by udomdiff / dom-expressions):
+ *   1. Remove stale entries (keys absent from the new array).
+ *   2. Skip unchanged common prefix and suffix.
+ *   3. Pure-append fast path when the surviving old range is empty.
+ *   4. Backward scan of the middle region — move or create entries so that
+ *      each entry's range lands immediately before the already-correct cursor.
+ *
+ * @example
+ * ```tsx
+ * <For each={visibleTodos} by={(todo) => todo.id}>
+ *   {(todo) => <li>{todo.text}</li>}
+ * </For>
+ * ```
+ *
+ * Props:
+ *   each     — reactive getter returning the array (e.g. a `computed`)
+ *   by       — extracts a stable key per item (default: index)
+ *   children — render function called once per new key
+ */
+declare class For<T = unknown> {
+  #private;
+  get each(): T[];
+  set each(v: T[]);
+  by: KeyFn<T>;
+  children: RenderFn<T>;
+  render(): DocumentFragment;
+}
+//#endregion
+export { For };

package/dist/index.mjs

@@ -0,0 +1,130 @@
+import { n as disposeElement } from "./element-B3gwJmBr.mjs";
+import { effect, signal, untracked } from "./signals.mjs";
+import "./polyfill-DAalJpCO.mjs";
+
+//#region src/components/for.ts
+/**
+* Keyed list renderer. Reconciles a reactive array into the DOM using a key
+* function to match existing nodes — minimising create/destroy churn.
+*
+* Reconciliation strategy (inspired by udomdiff / dom-expressions):
+*   1. Remove stale entries (keys absent from the new array).
+*   2. Skip unchanged common prefix and suffix.
+*   3. Pure-append fast path when the surviving old range is empty.
+*   4. Backward scan of the middle region — move or create entries so that
+*      each entry's range lands immediately before the already-correct cursor.
+*
+* @example
+* ```tsx
+* <For each={visibleTodos} by={(todo) => todo.id}>
+*   {(todo) => <li>{todo.text}</li>}
+* </For>
+* ```
+*
+* Props:
+*   each     — reactive getter returning the array (e.g. a `computed`)
+*   by       — extracts a stable key per item (default: index)
+*   children — render function called once per new key
+*/
+var For = class {
+	#each = signal([]);
+	get each() {
+		return this.#each();
+	}
+	set each(v) {
+		this.#each(v);
+	}
+	by = (_, i) => i;
+	children = () => null;
+	#start = document.createComment("<For>");
+	#end = document.createComment("</For>");
+	#cache = /* @__PURE__ */ new Map();
+	/** Keys in current DOM order — needed for prefix/suffix optimisation. */
+	#order = [];
+	render() {
+		const fragment = document.createDocumentFragment();
+		fragment.appendChild(this.#start);
+		fragment.appendChild(this.#end);
+		effect(() => this.#reconcile());
+		return fragment;
+	}
+	#reconcile() {
+		const parent = this.#start.parentNode;
+		if (!parent) return;
+		const items = this.each;
+		const b = items.map((item, i) => this.by(item, i));
+		const bSet = new Set(b);
+		for (const [key, entry] of this.#cache) if (!bSet.has(key)) {
+			removeEntry(entry);
+			this.#cache.delete(key);
+		}
+		const a = this.#order.filter((k) => this.#cache.has(k));
+		let aStart = 0, aEnd = a.length;
+		let bStart = 0, bEnd = b.length;
+		while (aStart < aEnd && bStart < bEnd && a[aStart] === b[bStart]) {
+			aStart++;
+			bStart++;
+		}
+		while (aEnd > aStart && bEnd > bStart && a[aEnd - 1] === b[bEnd - 1]) {
+			aEnd--;
+			bEnd--;
+		}
+		const after = bEnd < b.length ? this.#cache.get(b[bEnd]).start : this.#end;
+		if (aStart === aEnd) {
+			let cursor = after;
+			for (let i = bEnd - 1; i >= bStart; i--) {
+				const key = b[i];
+				const entry = this.#makeEntry(key);
+				insertEntry(parent, entry, cursor, untracked(() => this.children(items[i], i)));
+				this.#cache.set(key, entry);
+				cursor = entry.start;
+			}
+			this.#order = [...b];
+			return;
+		}
+		let cursor = after;
+		for (let i = bEnd - 1; i >= bStart; i--) {
+			const key = b[i];
+			let entry = this.#cache.get(key);
+			if (!entry) {
+				entry = this.#makeEntry(key);
+				insertEntry(parent, entry, cursor, untracked(() => this.children(items[i], i)));
+				this.#cache.set(key, entry);
+			} else if (entry.end.nextSibling !== cursor) moveEntry(parent, entry, cursor);
+			cursor = entry.start;
+		}
+		this.#order = [...b];
+	}
+	#makeEntry(key) {
+		return {
+			start: document.createComment(`[${key}]`),
+			end: document.createComment(`[/${key}]`)
+		};
+	}
+};
+function insertEntry(parent, entry, before, rendered) {
+	parent.insertBefore(entry.start, before);
+	if (rendered) parent.insertBefore(rendered, before);
+	parent.insertBefore(entry.end, before);
+}
+function removeEntry(entry) {
+	let node = entry.start.nextSibling;
+	while (node && node !== entry.end) {
+		const next = node.nextSibling;
+		if (node instanceof Element) disposeElement(node);
+		node = next;
+	}
+	const range = document.createRange();
+	range.setStartBefore(entry.start);
+	range.setEndAfter(entry.end);
+	range.deleteContents();
+}
+function moveEntry(parent, entry, before) {
+	const range = document.createRange();
+	range.setStartBefore(entry.start);
+	range.setEndAfter(entry.end);
+	parent.insertBefore(range.extractContents(), before);
+}
+
+//#endregion
+export { For };

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

@@ -0,0 +1,70 @@
+import { t as PrimitiveNodeType } from "../polyfill-Bvo2e52W.mjs";
+import { JSX as JSX$1 } from "dom-expressions/src/jsx-h";
+
+//#region src/jsx-runtime/types.d.ts
+/** An instance created by a component class — must expose `render()`. */
+interface ComponentInstance {
+  render(): Element | DocumentFragment | null;
+}
+/** A class whose constructor returns a ComponentInstance. */
+type ComponentClass = new (...args: any[]) => ComponentInstance;
+/** Anything that can appear as a JSX child. */
+type Child = PrimitiveNodeType | AnyFn | Child[];
+/** A function that renders props into an element or fragment. */
+type AnyFn = (...args: any[]) => any;
+//#endregion
+//#region src/jsx-runtime/ref.d.ts
+declare const $ref: unique symbol;
+//#endregion
+//#region src/jsx-runtime/element.d.ts
+declare function createElement(type: string | Element | DocumentFragment | ComponentClass | ((props: Record<string | symbol, unknown>) => null | Element | DocumentFragment), {
+  [$ref]: ref,
+  ...props
+}?: Record<string | symbol, unknown>): Element | DocumentFragment | null;
+//#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 {
+  type Element = globalThis.Element | globalThis.DocumentFragment | null;
+  type ElementType = Child | ComponentClass;
+  interface ElementChildrenAttribute {
+    children: {};
+  }
+  type IntrinsicElements = { [K in keyof JSX$1.IntrinsicElements]: WithOurProps<JSX$1.IntrinsicElements[K]> } & {
+    /** Custom elements (`x-foo`, `my-component`, …) get a loose typed fallback. */[customElement: `${string}-${string}`]: WithOurProps<JSX$1.DOMAttributes<HTMLElement>> & Record<string, unknown>;
+  };
+}
+//#endregion
+export { Attrs, FunctionMaybe, JSX, SlotProps, createElement as h, createElement as jsx, createElement as jsxDEV, createElement as jsxs };

package/dist/jsx-runtime/index.mjs

@@ -0,0 +1,4 @@
+import { t as createElement } from "../element-B3gwJmBr.mjs";
+import "../polyfill-DAalJpCO.mjs";
+
+export { createElement as h, createElement as jsx, createElement as jsxDEV, createElement as jsxs };

package/dist/polyfill-Bvo2e52W.d.mts

@@ -0,0 +1,14 @@
+//#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
+export { PrimitiveNodeType as t };

package/dist/polyfill-DAalJpCO.mjs

@@ -0,0 +1,20 @@
+//#region src/lib.ts
+var UnsupportedChildError = class extends Error {
+	constructor(value) {
+		super(`Unsupported child type: ${typeof value}`);
+		this.name = "UnsupportedChildError";
+	}
+};
+function resolveNode(c) {
+	if (c instanceof Node) return c;
+	if (c === null || c === void 0 || typeof c === "boolean") return document.createComment("");
+	if (typeof c === "string" || typeof c === "number" || typeof c === "bigint" || typeof c === "symbol" || c instanceof Date || c instanceof RegExp) return document.createTextNode(String(c));
+	throw new UnsupportedChildError(c);
+}
+
+//#endregion
+//#region src/polyfill.ts
+if (!Symbol.dispose) Object.defineProperty(Symbol, "dispose", { value: Symbol("dispose") });
+
+//#endregion
+export { resolveNode as t };

package/dist/signals.d.mts

@@ -1,3 +1,40 @@
-import { t as isReactiveValue } from "./signals-BzhB4Ch2.mjs";
-export * from "alien-signals";
-export { isReactiveValue };
+import "./polyfill-Bvo2e52W.mjs";
+import { ValueOrReactive } from "./builder/index.mjs";
+import { computed, effect, effectScope, isComputed, isEffect, isEffectScope, isSignal, signal, signal as signal$1, trigger } from "alien-signals";
+
+//#region src/signals.d.ts
+declare function isReactive<T>(value: ValueOrReactive<T>): value is () => T;
+type Signal<T> = ReturnType<typeof signal$1<T>>;
+declare const batch: (fn: () => void) => void;
+declare const untracked: <T>(fn: () => T) => T;
+/**
+ * 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); }
+ * }
+ * ```
+ */
+declare function reactive<This extends object, Value>(source?: (self: This) => Signal<Value>): (_target: unknown, context: ClassFieldDecoratorContext<This, Value>) => (this: This, initialValue: Value) => Value;
+//#endregion
+export { Signal, batch, computed, effect, effectScope, isComputed, isEffect, isEffectScope, isReactive, isSignal, reactive, signal, trigger, untracked };

package/dist/signals.mjs

@@ -1,5 +1,76 @@
-import { t as isReactiveValue } from "./signals-BGUPt0zl.mjs";
+import { computed, effect, effectScope, endBatch, isComputed, isComputed as isComputed$1, isEffect, isEffectScope, isSignal, isSignal as isSignal$1, setActiveSub, signal, signal as signal$1, startBatch, trigger } from "alien-signals";
 
-export * from "alien-signals"
+//#region src/signals.ts
+function isReactive(value) {
+	return isSignal$1(value) || isComputed$1(value);
+}
+const batch = (fn) => {
+	startBatch();
+	try {
+		fn();
+	} finally {
+		endBatch();
+	}
+};
+const untracked = (fn) => {
+	const sub = setActiveSub(void 0);
+	try {
+		return fn();
+	} finally {
+		setActiveSub(sub);
+	}
+};
+/**
+* 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$1(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$1(initialValue));
+			return initialValue;
+		};
+	};
+}
 
-export { isReactiveValue };
+//#endregion
+export { batch, computed, effect, effectScope, isComputed, isEffect, isEffectScope, isReactive, isSignal, reactive, signal, trigger, untracked };