@zeix/cause-effect 0.18.3 → 0.18.5

package/types/index.d.ts

@@ -1,10 +1,10 @@
 /**
  * @name Cause & Effect
- * @version 0.18.3
+ * @version 0.18.5
  * @author Esther Brunner
  */
 export { CircularDependencyError, type Guard, InvalidCallbackError, InvalidSignalValueError, NullishSignalValueError, ReadonlySignalError, RequiredOwnerError, UnsetSignalValueError, } from './src/errors';
-export { batch, type Cleanup, type ComputedOptions, createScope, type EffectCallback, type MaybeCleanup, type MemoCallback, type Signal, type SignalOptions, SKIP_EQUALITY, type TaskCallback, untrack, } from './src/graph';
+export { batch, type Cleanup, type ComputedOptions, createScope, type EffectCallback, type MaybeCleanup, type MemoCallback, type Signal, type SignalOptions, SKIP_EQUALITY, type TaskCallback, unown, untrack, } from './src/graph';
 export { type Collection, type CollectionCallback, type CollectionChanges, type CollectionOptions, createCollection, type DeriveCollectionCallback, isCollection, } from './src/nodes/collection';
 export { createEffect, type MatchHandlers, type MaybePromise, match, } from './src/nodes/effect';
 export { createList, isEqual, isList, type KeyConfig, type List, type ListOptions, } from './src/nodes/list';

package/types/src/graph.d.ts

@@ -119,6 +119,7 @@ declare const TYPE_COLLECTION = "Collection";
 declare const TYPE_STORE = "Store";
 declare const TYPE_SLOT = "Slot";
 declare const FLAG_CLEAN = 0;
+declare const FLAG_CHECK: number;
 declare const FLAG_DIRTY: number;
 declare const FLAG_RELINK: number;
 declare let activeSink: SinkNode | null;
@@ -217,4 +218,14 @@ declare function untrack<T>(fn: () => T): T;
  * ```
  */
 declare function createScope(fn: () => MaybeCleanup): Cleanup;
-export { type Cleanup, type ComputedOptions, type EffectCallback, type EffectNode, type MaybeCleanup, type MemoCallback, type MemoNode, type Scope, type Signal, type SignalOptions, type SinkNode, type StateNode, type TaskCallback, type TaskNode, activeOwner, activeSink, batch, batchDepth, createScope, DEFAULT_EQUALITY, SKIP_EQUALITY, FLAG_CLEAN, FLAG_DIRTY, FLAG_RELINK, flush, link, propagate, refresh, registerCleanup, runCleanup, runEffect, setState, trimSources, TYPE_COLLECTION, TYPE_LIST, TYPE_MEMO, TYPE_SENSOR, TYPE_STATE, TYPE_SLOT, TYPE_STORE, TYPE_TASK, unlink, untrack, };
+/**
+ * Runs a callback without any active owner.
+ * Any scopes or effects created inside the callback will not be registered as
+ * children of the current active owner (e.g. a re-runnable effect). Use this
+ * when a component or resource manages its own lifecycle independently of the
+ * reactive graph.
+ *
+ * @since 0.18.5
+ */
+declare function unown<T>(fn: () => T): T;
+export { type Cleanup, type ComputedOptions, type EffectCallback, type EffectNode, type MaybeCleanup, type MemoCallback, type MemoNode, type Scope, type Signal, type SignalOptions, type SinkNode, type StateNode, type TaskCallback, type TaskNode, activeOwner, activeSink, batch, batchDepth, createScope, DEFAULT_EQUALITY, SKIP_EQUALITY, FLAG_CHECK, FLAG_CLEAN, FLAG_DIRTY, FLAG_RELINK, flush, link, propagate, refresh, registerCleanup, runCleanup, runEffect, setState, trimSources, TYPE_COLLECTION, TYPE_LIST, TYPE_MEMO, TYPE_SENSOR, TYPE_STATE, TYPE_SLOT, TYPE_STORE, TYPE_TASK, unlink, unown, untrack, };

package/.ai-context.md

@@ -1,281 +0,0 @@
-# AI Context for Cause & Effect
-
-## What is Cause & Effect?
-
-Cause & Effect is a modern reactive state management library for JavaScript/TypeScript that implements the signals pattern. It provides fine-grained reactivity with automatic dependency tracking, making it easy to build responsive applications with predictable state updates.
-
-## Core Architecture
-
-### Graph-Based Reactivity (`src/graph.ts`)
-
-The reactive engine is a linked graph of source and sink nodes connected by `Edge` entries:
-- **Sources** (StateNode) maintain a linked list of sink edges
-- **Sinks** (MemoNode, TaskNode, EffectNode) maintain a linked list of source edges
-- `link()` creates edges between sources and sinks during `.get()` calls
-- `propagate()` flags sinks as dirty when sources change
-- `flush()` processes queued effects after propagation
-- `trimSources()` removes stale edges after recomputation
-
-### Node Types
-```
-StateNode<T>  — source-only with equality + guard (State, Sensor)
-MemoNode<T>   — source + sink (Memo, Slot, Store, List, Collection)
-TaskNode<T>   — source + sink + async (Task)
-EffectNode    — sink + owner (Effect)
-Scope         — owner-only (createScope)
-```
-
-### Signal Types
-- **State** (`createState`): Mutable signals for primitive values and objects
-- **Sensor** (`createSensor`): Read-only signals for external input streams with automatic state updates. Use `SKIP_EQUALITY` for mutable object observation.
-- **Memo** (`createMemo`): Synchronous derived computations with memoization, reducer capabilities, and optional `watched(invalidate)` for external invalidation
-- **Task** (`createTask`): Async derived computations with automatic abort/cancellation and optional `watched(invalidate)` for external invalidation
-- **Store** (`createStore`): Mutable object signals with individually reactive properties via Proxy
-- **List** (`createList`): Mutable array signals with stable keys and reactive items
-- **Collection** (`createCollection`): Reactive collections — either externally-driven with watched lifecycle, or derived from List/Collection with item-level memoization
-- **Slot** (`createSlot`): Stable delegation signal with swappable backing signal, designed for integration layers (property descriptors, custom elements)
-- **Effect** (`createEffect`): Side effect handlers that react to signal changes
-
-### Key Principles
-1. **Functional API**: All signals created via `create*()` factory functions (no classes)
-2. **Type Safety**: Full TypeScript support with strict type constraints (`T extends {}`)
-3. **Performance**: Flag-based dirty checking, linked-list edge traversal, batched flushing
-4. **Async Support**: Built-in cancellation with AbortSignal in Tasks
-5. **Tree-shaking**: Optimized for minimal bundle size with `/*#__PURE__*/` annotations
-
-## Project Structure
-
-```
-cause-effect/
-├── src/
-│   ├── graph.ts           # Core reactive engine (nodes, edges, link, propagate, flush, batch)
-│   ├── nodes/
-│   │   ├── state.ts       # createState — mutable state signals
-│   │   ├── sensor.ts      # createSensor — external input tracking (also covers mutable object observation)
-│   │   ├── memo.ts        # createMemo — synchronous derived computations
-│   │   ├── task.ts        # createTask — async derived computations
-│   │   ├── effect.ts      # createEffect, match — side effects
-│   │   ├── store.ts       # createStore — reactive object stores
-│   │   ├── list.ts        # createList — reactive arrays with stable keys
-│   │   ├── collection.ts  # createCollection — externally-driven and derived collections
-│   │   └── slot.ts        # createSlot — stable delegation with swappable backing signal
-│   ├── util.ts            # Utility functions and type checks
-│   └── ...
-├── index.ts           # Entry point / main export file
-├── test/
-│   ├── state.test.ts
-│   ├── memo.test.ts
-│   ├── task.test.ts
-│   ├── effect.test.ts
-│   ├── store.test.ts
-│   ├── list.test.ts
-│   └── collection.test.ts
-└── package.json
-```
-
-## API Patterns
-
-### Signal Creation
-```typescript
-// State for primitives and objects
-const count = createState(42)
-const name = createState('Alice')
-
-// Sensor for external input
-const mousePos = createSensor<{ x: number; y: number }>((set) => {
-  const handler = (e: MouseEvent) => set({ x: e.clientX, y: e.clientY })
-  window.addEventListener('mousemove', handler)
-  return () => window.removeEventListener('mousemove', handler)
-})
-
-// Sensor for mutable object observation (SKIP_EQUALITY)
-const element = createSensor<HTMLElement>((set) => {
-  const node = document.getElementById('box')!
-  set(node)
-  const obs = new MutationObserver(() => set(node))
-  obs.observe(node, { attributes: true })
-  return () => obs.disconnect()
-}, { value: node, equals: SKIP_EQUALITY })
-
-// Store for objects with reactive properties
-const user = createStore({ name: 'Alice', age: 30 })
-
-// List with stable keys for arrays
-const items = createList(['apple', 'banana', 'cherry'])
-const users = createList(
-  [{ id: 'alice', name: 'Alice' }],
-  { keyConfig: user => user.id }
-)
-
-// Memo for synchronous derived values
-const doubled = createMemo(() => count.get() * 2)
-
-// Memo with reducer capabilities (access to previous value)
-const counter = createMemo(prev => {
-  const action = actions.get()
-  return action === 'increment' ? prev + 1 : prev - 1
-}, { value: 0 })
-
-// Task for async derived values with cancellation
-const userData = createTask(async (prev, abort) => {
-  const id = userId.get()
-  if (!id) return prev
-  const response = await fetch(`/users/${id}`, { signal: abort })
-  return response.json()
-})
-
-// Collection for derived transformations
-const doubled = numbers.deriveCollection((value: number) => value * 2)
-const enriched = users.deriveCollection(async (user, abort) => {
-  const res = await fetch(`/api/${user.id}`, { signal: abort })
-  return { ...user, details: await res.json() }
-})
-
-// Collection for externally-driven data
-const feed = createCollection<{ id: string; text: string }>((applyChanges) => {
-  const ws = new WebSocket('/feed')
-  ws.onmessage = (e) => applyChanges(JSON.parse(e.data))
-  return () => ws.close()
-}, { keyConfig: item => item.id })
-
-// Slot for stable property delegation
-const local = createState('default')
-const slot = createSlot(local)
-Object.defineProperty(element, 'label', slot)
-slot.replace(createMemo(() => parentState.get())) // swap backing signal
-```
-
-### Reactivity
-```typescript
-// Effects run when dependencies change
-const dispose = createEffect(() => {
-  console.log(`Count: ${count.get()}`)
-})
-
-// Effects can return cleanup functions
-createEffect(() => {
-  const timer = setInterval(() => console.log(count.get()), 1000)
-  return () => clearInterval(timer)
-})
-
-// match() for ergonomic signal value extraction inside effects
-createEffect(() => {
-  match([userData], {
-    ok: ([data]) => updateUI(data),
-    nil: () => showLoading(),
-    err: errors => showError(errors[0].message)
-  })
-})
-```
-
-### Value Access Patterns
-```typescript
-// All signals use .get() for value access
-const value = signal.get()
-
-// State has .set() and .update()
-state.set(newValue)
-state.update(current => current + 1)
-
-// Store properties are individually reactive via Proxy
-user.name.set('Bob')             // Only name watchers trigger
-user.age.update(age => age + 1)  // Only age watchers trigger
-
-// List with stable keys
-const items = createList(['apple', 'banana'], { keyConfig: 'fruit' })
-const appleSignal = items.byKey('fruit0')
-const firstKey = items.keyAt(0)
-const appleIndex = items.indexOfKey('fruit0')
-items.splice(1, 0, 'cherry')
-items.sort()
-
-// Collections via deriveCollection
-const processed = items.deriveCollection(item => item.toUpperCase())
-```
-
-## Coding Conventions
-
-### TypeScript Style
-- Generic constraints: `T extends {}` to exclude null/undefined
-- Use `const` for immutable values
-- Function overloads for complex type scenarios (e.g., `createCollection`, `deriveCollection`)
-- JSDoc comments on all public APIs
-- Pure function annotations: `/*#__PURE__*/` for tree-shaking
-
-### Naming Conventions
-- Factory functions: `create*` prefix (createState, createMemo, createEffect, createStore, createList, createCollection, createSensor, createSlot)
-- Type predicates: `is*` prefix (isState, isMemo, isTask, isStore, isList, isCollection, isSensor, isSlot)
-- Type constants: `TYPE_*` format (TYPE_STATE, TYPE_STORE, TYPE_SENSOR, TYPE_COLLECTION)
-- Callback types: `*Callback` suffix (MemoCallback, TaskCallback, EffectCallback, SensorCallback, CollectionCallback, DeriveCollectionCallback)
-
-### Error Handling
-- Custom error classes in `src/errors.ts`: CircularDependencyError, NullishSignalValueError, InvalidSignalValueError, InvalidCallbackError, RequiredOwnerError, UnsetSignalValueError
-- Descriptive error messages with `[TypeName]` prefix
-- Input validation via `validateSignalValue()` and `validateCallback()`
-- Optional type guards via `guard` option in SignalOptions
-
-## Performance Considerations
-
-### Optimization Patterns
-- Linked-list edges for O(1) link/unlink operations
-- Flag-based dirty checking: FLAG_CLEAN, FLAG_CHECK, FLAG_DIRTY, FLAG_RUNNING
-- Batched updates via `batch()` to minimize effect re-runs
-- Lazy evaluation: Memos only recompute when accessed and dirty
-- Automatic abort of in-flight Tasks when sources change
-
-### Memory Management
-- `trimSources()` removes stale edges after each recomputation
-- `unlink()` calls `source.stop()` when last sink disconnects (auto-cleanup for Sensor/Collection/Store/List)
-- AbortSignal integration for canceling async operations
-- `createScope()` for hierarchical cleanup of nested effects
-
-## Resource Management
-
-**Sensor and Collection** use a watched callback that returns a Cleanup function:
-```typescript
-const sensor = createSensor<T>((set) => {
-  // setup input tracking, call set(value) to update
-  return () => { /* cleanup */ }
-})
-
-const feed = createCollection<T>((applyChanges) => {
-  // setup external data source, call applyChanges(diffResult) on changes
-  return () => { /* cleanup */ }
-}, { keyConfig: item => item.id })
-```
-
-**Memo and Task** use an optional `watched` callback in options that receives an `invalidate` function:
-```typescript
-const derived = createMemo(() => element.get().textContent ?? '', {
-  watched: (invalidate) => {
-    const obs = new MutationObserver(() => invalidate())
-    obs.observe(element.get(), { childList: true })
-    return () => obs.disconnect()
-  }
-})
-```
-
-**Store and List** use an optional `watched` callback in options:
-```typescript
-const store = createStore(initialValue, {
-  watched: () => {
-    // setup resources
-    return () => { /* cleanup */ }
-  }
-})
-```
-
-Resources activate on first sink link and cleanup when last sink unlinks.
-
-## Build and Development
-
-### Tools
-- **Runtime**: Bun (also works with Node.js)
-- **Build**: Bun build with TypeScript compilation
-- **Testing**: Bun test runner (`bun test`)
-- **Linting**: Biome for code formatting and linting
-
-### Package Configuration
-- ES modules only (`"type": "module"`)
-- TypeScript declarations generated automatically
-- Tree-shaking friendly with proper sideEffects configuration

package/examples/events-sensor.ts

@@ -1,187 +0,0 @@
-import { createSensor, isSensor, type Sensor } from '..'
-
-/* === Types === */
-
-type ReservedWords =
-	| 'constructor'
-	| 'prototype'
-	| '__proto__'
-	| 'toString'
-	| 'valueOf'
-	| 'hasOwnProperty'
-	| 'isPrototypeOf'
-	| 'propertyIsEnumerable'
-	| 'toLocaleString'
-
-type ComponentProp = Exclude<string, keyof HTMLElement | ReservedWords>
-type ComponentProps = Record<ComponentProp, NonNullable<unknown>>
-
-type Component<P extends ComponentProps> = HTMLElement & P
-
-type UI = Record<string, Element | Sensor<Element[]>>
-
-type EventType<K extends string> = K extends keyof HTMLElementEventMap
-	? HTMLElementEventMap[K]
-	: Event
-
-type EventHandler<
-	T extends {},
-	Evt extends Event,
-	U extends UI,
-	E extends Element,
-> = (context: {
-	event: Evt
-	ui: U
-	target: E
-	prev: T
-}) => T | void | Promise<void>
-
-type EventHandlers<T extends {}, U extends UI, E extends Element> = {
-	[K in keyof HTMLElementEventMap]?: EventHandler<T, EventType<K>, U, E>
-}
-
-type ElementFromKey<U extends UI, K extends keyof U> = NonNullable<
-	U[K] extends Sensor<infer E extends Element>
-		? E
-		: U[K] extends Element
-			? U[K]
-			: never
->
-
-type Parser<T extends {}, U extends UI> = (
-	ui: U,
-	value: string | null | undefined,
-	old?: string | null,
-) => T
-
-type Reader<T extends {}, U extends UI> = (ui: U) => T
-type Fallback<T extends {}, U extends UI> = T | Reader<T, U>
-
-type ParserOrFallback<T extends {}, U extends UI> =
-	| Parser<T, U>
-	| Fallback<T, U>
-
-/* === Internal === */
-
-const pendingElements = new Set<Element>()
-const tasks = new WeakMap<Element, () => void>()
-let requestId: number | undefined
-
-const runTasks = () => {
-	requestId = undefined
-	const elements = Array.from(pendingElements)
-	pendingElements.clear()
-	for (const element of elements) tasks.get(element)?.()
-}
-
-const requestTick = () => {
-	if (requestId) cancelAnimationFrame(requestId)
-	requestId = requestAnimationFrame(runTasks)
-}
-
-const schedule = (element: Element, task: () => void) => {
-	tasks.set(element, task)
-	pendingElements.add(element)
-	requestTick()
-}
-
-// High-frequency events that are passive by default and should be scheduled
-const PASSIVE_EVENTS = new Set([
-	'scroll',
-	'resize',
-	'mousewheel',
-	'touchstart',
-	'touchmove',
-	'wheel',
-])
-
-const isReader = <T extends {}, U extends UI>(
-	value: unknown,
-): value is Reader<T, U> => typeof value === 'function'
-
-const getFallback = <T extends {}, U extends UI>(
-	ui: U,
-	fallback: ParserOrFallback<T, U>,
-): T => (isReader<T, U>(fallback) ? fallback(ui) : (fallback as T))
-
-/* === Exported Functions === */
-
-/**
- * Produce an event-driven sensor from transformed event data
- *
- * @since 0.16.0
- * @param {S} key - name of UI key
- * @param {ParserOrFallback<T>} init - Initial value, reader or parser
- * @param {EventHandlers<T, ElementFromSelector<S>, C>} events - Transformation functions for events
- * @returns {Extractor<Sensor<T>, C>} Extractor function for value from event
- */
-const createEventsSensor =
-	<T extends {}, P extends ComponentProps, U extends UI, K extends keyof U>(
-		init: ParserOrFallback<T, U>,
-		key: K,
-		events: EventHandlers<T, U, ElementFromKey<U, K>>,
-	): ((ui: U & { host: Component<P> }) => Sensor<T>) =>
-	(ui: U & { host: Component<P> }) => {
-		const { host } = ui
-		let value: T = getFallback(ui, init)
-		const targets = isSensor<ElementFromKey<U, K>[]>(ui[key])
-			? ui[key].get()
-			: [ui[key] as ElementFromKey<U & { host: Component<P> }, K>]
-		const eventMap = new Map<string, EventListener>()
-
-		const getTarget = (
-			eventTarget: Node,
-		): ElementFromKey<U, K> | undefined => {
-			for (const t of targets)
-				if (t.contains(eventTarget)) return t as ElementFromKey<U, K>
-		}
-
-		return createSensor<T>(
-			set => {
-				for (const [type, handler] of Object.entries(events)) {
-					const options = { passive: PASSIVE_EVENTS.has(type) }
-					const listener = (e: Event) => {
-						const eventTarget = e.target as Node
-						if (!eventTarget) return
-						const target = getTarget(eventTarget)
-						if (!target) return
-						e.stopPropagation()
-
-						const task = () => {
-							try {
-								const next = handler({
-									event: e as any,
-									ui,
-									target,
-									prev: value,
-								})
-								if (next == null || next instanceof Promise)
-									return
-								if (!Object.is(next, value)) {
-									value = next
-									set(next)
-								}
-							} catch (error) {
-								e.stopImmediatePropagation()
-								throw error
-							}
-						}
-						if (options.passive) schedule(host, task)
-						else task()
-					}
-					eventMap.set(type, listener)
-					host.addEventListener(type, listener, options)
-				}
-				return () => {
-					if (eventMap.size) {
-						for (const [type, listener] of eventMap)
-							host.removeEventListener(type, listener)
-						eventMap.clear()
-					}
-				}
-			},
-			{ value },
-		)
-	}
-
-export { createEventsSensor, type EventHandler, type EventHandlers }

package/examples/selector-sensor.ts

@@ -1,173 +0,0 @@
-import { createMemo, type Memo } from '..'
-
-/* === Types === */
-
-// Split a comma-separated selector into individual selectors
-type SplitByComma<S extends string> = S extends `${infer First},${infer Rest}`
-	? [TrimWhitespace<First>, ...SplitByComma<Rest>]
-	: [TrimWhitespace<S>]
-
-// Trim leading/trailing whitespace from a string
-type TrimWhitespace<S extends string> = S extends ` ${infer Rest}`
-	? TrimWhitespace<Rest>
-	: S extends `${infer Rest} `
-		? TrimWhitespace<Rest>
-		: S
-
-// Extract the rightmost selector part from combinator selectors (space, >, +, ~)
-type ExtractRightmostSelector<S extends string> =
-	S extends `${string} ${infer Rest}`
-		? ExtractRightmostSelector<Rest>
-		: S extends `${string}>${infer Rest}`
-			? ExtractRightmostSelector<Rest>
-			: S extends `${string}+${infer Rest}`
-				? ExtractRightmostSelector<Rest>
-				: S extends `${string}~${infer Rest}`
-					? ExtractRightmostSelector<Rest>
-					: S
-
-// Extract tag name from a simple selector (without combinators)
-type ExtractTagFromSimpleSelector<S extends string> =
-	S extends `${infer T}.${string}`
-		? T
-		: S extends `${infer T}#${string}`
-			? T
-			: S extends `${infer T}:${string}`
-				? T
-				: S extends `${infer T}[${string}`
-					? T
-					: S
-
-// Main extraction logic for a single selector
-type ExtractTag<S extends string> = ExtractTagFromSimpleSelector<
-	ExtractRightmostSelector<S>
->
-
-// Normalize to lowercase and ensure it's a known HTML tag
-type KnownTag<S extends string> =
-	Lowercase<ExtractTag<S>> extends
-		| keyof HTMLElementTagNameMap
-		| keyof SVGElementTagNameMap
-		| keyof MathMLElementTagNameMap
-		? Lowercase<ExtractTag<S>>
-		: never
-
-// Get element type from a single selector
-type ElementFromSingleSelector<S extends string> =
-	KnownTag<S> extends never
-		? HTMLElement
-		: KnownTag<S> extends keyof HTMLElementTagNameMap
-			? HTMLElementTagNameMap[KnownTag<S>]
-			: KnownTag<S> extends keyof SVGElementTagNameMap
-				? SVGElementTagNameMap[KnownTag<S>]
-				: KnownTag<S> extends keyof MathMLElementTagNameMap
-					? MathMLElementTagNameMap[KnownTag<S>]
-					: HTMLElement
-
-// Map a tuple of selectors to a union of their element types
-type ElementsFromSelectorArray<Selectors extends readonly string[]> = {
-	[K in keyof Selectors]: Selectors[K] extends string
-		? ElementFromSingleSelector<Selectors[K]>
-		: never
-}[number]
-
-// Main type: handle both single selectors and comma-separated selectors
-type ElementFromSelector<S extends string> = S extends `${string},${string}`
-	? ElementsFromSelectorArray<SplitByComma<S>>
-	: ElementFromSingleSelector<S>
-
-type ElementChanges<E extends Element> = {
-	current: Set<E>
-	added: E[]
-	removed: E[]
-}
-
-/* === Internal Functions === */
-
-/**
- * Extract attribute names from a CSS selector
- * Handles various attribute selector formats: .class, #id, [attr], [attr=value], [attr^=value], etc.
- *
- * @param {string} selector - CSS selector to parse
- * @returns {string[]} - Array of attribute names found in the selector
- */
-const extractAttributes = (selector: string): string[] => {
-	const attributes = new Set<string>()
-	if (selector.includes('.')) attributes.add('class')
-	if (selector.includes('#')) attributes.add('id')
-	if (selector.includes('[')) {
-		const parts = selector.split('[')
-		for (let i = 1; i < parts.length; i++) {
-			const part = parts[i]
-			if (!part.includes(']')) continue
-			const attrName = part
-				.split('=')[0]
-				.trim()
-				.replace(/[^a-zA-Z0-9_-]/g, '')
-			if (attrName) attributes.add(attrName)
-		}
-	}
-	return [...attributes]
-}
-
-/* === Exported Functions === */
-
-/**
- * Observe changes to elements matching a CSS selector.
- * Returns a Memo that tracks which elements were added and removed.
- * The MutationObserver is lazily activated when an effect first reads
- * the memo, and disconnected when no effects are watching.
- *
- * @since 0.16.0
- * @param parent - The parent node to search within
- * @param selector - The CSS selector to match elements
- * @returns A Memo of element changes (current set, added, removed)
- */
-function observeSelectorChanges<S extends string>(
-	parent: ParentNode,
-	selector: S,
-): Memo<ElementChanges<ElementFromSelector<S>>>
-function observeSelectorChanges<E extends Element>(
-	parent: ParentNode,
-	selector: string,
-): Memo<ElementChanges<E>>
-function observeSelectorChanges<S extends string>(
-	parent: ParentNode,
-	selector: S,
-): Memo<ElementChanges<ElementFromSelector<S>>> {
-	type E = ElementFromSelector<S>
-
-	return createMemo(
-		(prev: ElementChanges<E>) => {
-			const next = new Set(
-				Array.from(parent.querySelectorAll<E>(selector)),
-			)
-			const added: E[] = []
-			const removed: E[] = []
-
-			for (const el of next) if (!prev.current.has(el)) added.push(el)
-			for (const el of prev.current) if (!next.has(el)) removed.push(el)
-
-			return { current: next, added, removed }
-		},
-		{
-			value: { current: new Set<E>(), added: [], removed: [] },
-			watched: invalidate => {
-				const observerConfig: MutationObserverInit = {
-					childList: true,
-					subtree: true,
-				}
-				const observedAttributes = extractAttributes(selector)
-				if (observedAttributes.length) {
-					observerConfig.attributes = true
-					observerConfig.attributeFilter = observedAttributes
-				}
-				const observer = new MutationObserver(() => invalidate())
-				observer.observe(parent, observerConfig)
-				return () => observer.disconnect()
-			},
-		},
-	)
-}
-
-export { observeSelectorChanges, type ElementChanges }