{"version":3,"file":"signals-core.min.js","sources":["../src/index.ts"],"sourcesContent":["// An named symbol/brand for detecting Signal instances even when they weren't\n// created using the same signals library version.\nconst BRAND_SYMBOL = Symbol.for(\"preact-signals\");\n\n// Flags for Computed and Effect.\nconst RUNNING = 1 << 0;\nconst NOTIFIED = 1 << 1;\nconst OUTDATED = 1 << 2;\nconst DISPOSED = 1 << 3;\nconst HAS_ERROR = 1 << 4;\nconst TRACKING = 1 << 5;\n\n// A linked list node used to track dependencies (sources) and dependents (targets).\n// Also used to remember the source's last version number that the target saw.\ntype Node = {\n\t// A source whose value the target depends on.\n\t_source: Signal;\n\t_prevSource?: Node;\n\t_nextSource?: Node;\n\n\t// A target that depends on the source and should be notified when the source changes.\n\t_target: Computed | Effect;\n\t_prevTarget?: Node;\n\t_nextTarget?: Node;\n\n\t// The version number of the source that target has last seen. We use version numbers\n\t// instead of storing the source value, because source values can take arbitrary amount\n\t// of memory, and computeds could hang on to them forever because they're lazily evaluated.\n\t// Use the special value -1 to mark potentially unused but recyclable nodes.\n\t_version: number;\n\n\t// Used to remember & roll back the source's previous `._node` value when entering &\n\t// exiting a new evaluation context.\n\t_rollbackNode?: Node;\n};\n\nfunction startBatch() {\n\tbatchDepth++;\n}\n\nfunction endBatch() {\n\tif (batchDepth > 1) {\n\t\tbatchDepth--;\n\t\treturn;\n\t}\n\n\tlet error: unknown;\n\tlet hasError = false;\n\treconcileBatchSnapshots();\n\n\twhile (batchedEffect !== undefined) {\n\t\tlet effect: Effect | undefined = batchedEffect;\n\t\tbatchedEffect = undefined;\n\n\t\tbatchIteration++;\n\n\t\twhile (effect !== undefined) {\n\t\t\tconst next: Effect | undefined = effect._nextBatchedEffect;\n\t\t\teffect._nextBatchedEffect = undefined;\n\t\t\teffect._flags &= ~NOTIFIED;\n\n\t\t\tif (!(effect._flags & DISPOSED) && needsToRecompute(effect)) {\n\t\t\t\ttry {\n\t\t\t\t\teffect._callback();\n\t\t\t\t} catch (err) {\n\t\t\t\t\tif (!hasError) {\n\t\t\t\t\t\terror = err;\n\t\t\t\t\t\thasError = true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\teffect = next;\n\t\t}\n\t}\n\tbatchIteration = 0;\n\tbatchDepth--;\n\n\tif (hasError) {\n\t\tthrow error;\n\t}\n}\n\n/**\n * Combine multiple value updates into one \"commit\" at the end of the provided callback.\n *\n * Batches can be nested and changes are only flushed once the outermost batch callback\n * completes.\n *\n * Accessing a signal that has been modified within a batch will reflect its updated\n * value.\n *\n * @param fn The callback function.\n * @returns The value returned by the callback.\n */\nfunction batch(fn: () => T): T {\n\tif (batchDepth > 0) {\n\t\treturn fn();\n\t}\n\tcurrentBatchSnapshotVersion = ++batchSnapshotVersion;\n\t/*@__INLINE__**/ startBatch();\n\ttry {\n\t\treturn fn();\n\t} finally {\n\t\tendBatch();\n\t}\n}\n\n// Currently evaluated computed or effect.\nlet evalContext: Computed | Effect | undefined = undefined;\n\n// Effects captured while constructing a model instance.\nlet capturedEffects: Effect[] | undefined;\n\n/**\n * Run a callback function that can access signal values without\n * subscribing to the signal updates.\n *\n * When called inside a `createModel` factory, this also suppresses\n * model-owned effect capture. Effects created inside the callback will not\n * be owned by the surrounding model and must be disposed manually. Nested\n * `createModel` calls inside the callback still capture their own effects.\n *\n * @param fn The callback function.\n * @returns The value returned by the callback.\n */\nfunction untracked(fn: () => T): T {\n\tconst prevContext = evalContext;\n\tconst prevCapturedEffects = capturedEffects;\n\n\tevalContext = undefined;\n\t// Model effect capture is another kind of ambient tracking. Suppress it in\n\t// untracked callbacks while still allowing nested createModel() calls to\n\t// establish their own capture scope.\n\tcapturedEffects = undefined;\n\ttry {\n\t\treturn fn();\n\t} finally {\n\t\tevalContext = prevContext;\n\t\tcapturedEffects = prevCapturedEffects;\n\t}\n}\n\n// Effects collected into a batch.\nlet batchedEffect: Effect | undefined = undefined;\nlet batchDepth = 0;\nlet batchIteration = 0;\n\ntype BatchSnapshot = {\n\t_source: Signal;\n\t_value: unknown;\n\t_version: number;\n\t_next?: BatchSnapshot;\n};\n\nlet batchSnapshotVersion = 0;\nlet currentBatchSnapshotVersion = 0;\nlet batchSnapshots: BatchSnapshot | undefined = undefined;\n\n// A global version number for signals, used for fast-pathing repeated\n// computed.peek()/computed.value calls when nothing has changed globally.\nlet globalVersion = 0;\n\nfunction recordBatchSnapshot(source: Signal) {\n\t// Only capture writes during the user-visible batch callback, not during effect flush.\n\tif (batchDepth === 0 || batchIteration !== 0) {\n\t\treturn;\n\t}\n\n\tif (source._batchSnapshotVersion !== currentBatchSnapshotVersion) {\n\t\tsource._batchSnapshotVersion = currentBatchSnapshotVersion;\n\t\tbatchSnapshots = {\n\t\t\t_source: source,\n\t\t\t_value: source._value,\n\t\t\t_version: source._version,\n\t\t\t_next: batchSnapshots,\n\t\t};\n\t}\n}\n\nfunction reconcileBatchSnapshots() {\n\tlet snapshots = batchSnapshots;\n\tbatchSnapshots = undefined;\n\n\twhile (snapshots !== undefined) {\n\t\tconst source = snapshots._source;\n\t\tif (source._value === snapshots._value) {\n\t\t\t// The value was reverted to its pre-batch state. Version numbers must\n\t\t\t// stay monotonic: a lazy computed may have observed an intermediate\n\t\t\t// version during the batch, and rolling the version back would let a\n\t\t\t// future write re-mint that observed number for a different value,\n\t\t\t// making the computed treat it as unchanged forever. Instead,\n\t\t\t// fast-forward subscribers that last saw the pre-batch version so\n\t\t\t// they skip recomputing for the no-op change.\n\t\t\tfor (\n\t\t\t\tlet node = source._targets;\n\t\t\t\tnode !== undefined;\n\t\t\t\tnode = node._nextTarget\n\t\t\t) {\n\t\t\t\tif (node._version === snapshots._version) {\n\t\t\t\t\tnode._version = source._version;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tsnapshots = snapshots._next;\n\t}\n}\n\nfunction addDependency(signal: Signal): Node | undefined {\n\tif (evalContext === undefined) {\n\t\treturn undefined;\n\t}\n\n\tlet node = signal._node;\n\tif (node === undefined || node._target !== evalContext) {\n\t\t/**\n\t\t * `signal` is a new dependency. Create a new dependency node, and set it\n\t\t * as the tail of the current context's dependency list. e.g:\n\t\t *\n\t\t * { A <-> B }\n\t\t * ↑ ↑\n\t\t * tail node (new)\n\t\t * ↓\n\t\t * { A <-> B <-> C }\n\t\t * ↑\n\t\t * tail (evalContext._sources)\n\t\t */\n\t\tnode = {\n\t\t\t_version: 0,\n\t\t\t_source: signal,\n\t\t\t_prevSource: evalContext._sources,\n\t\t\t_nextSource: undefined,\n\t\t\t_target: evalContext,\n\t\t\t_prevTarget: undefined,\n\t\t\t_nextTarget: undefined,\n\t\t\t_rollbackNode: node,\n\t\t};\n\n\t\tif (evalContext._sources !== undefined) {\n\t\t\tevalContext._sources._nextSource = node;\n\t\t}\n\t\tevalContext._sources = node;\n\t\tsignal._node = node;\n\n\t\t// Subscribe to change notifications from this dependency if we're in an effect\n\t\t// OR evaluating a computed signal that in turn has subscribers.\n\t\tif (evalContext._flags & TRACKING) {\n\t\t\tsignal._subscribe(node);\n\t\t}\n\t\treturn node;\n\t} else if (node._version === -1) {\n\t\t// `signal` is an existing dependency from a previous evaluation. Reuse it.\n\t\tnode._version = 0;\n\n\t\t/**\n\t\t * If `node` is not already the current tail of the dependency list (i.e.\n\t\t * there is a next node in the list), then make the `node` the new tail. e.g:\n\t\t *\n\t\t * { A <-> B <-> C <-> D }\n\t\t * ↑ ↑\n\t\t * node ┌─── tail (evalContext._sources)\n\t\t * └─────│─────┐\n\t\t * ↓ ↓\n\t\t * { A <-> C <-> D <-> B }\n\t\t * ↑\n\t\t * tail (evalContext._sources)\n\t\t */\n\t\tif (node._nextSource !== undefined) {\n\t\t\tnode._nextSource._prevSource = node._prevSource;\n\n\t\t\tif (node._prevSource !== undefined) {\n\t\t\t\tnode._prevSource._nextSource = node._nextSource;\n\t\t\t}\n\n\t\t\tnode._prevSource = evalContext._sources;\n\t\t\tnode._nextSource = undefined;\n\n\t\t\tevalContext._sources!._nextSource = node;\n\t\t\tevalContext._sources = node;\n\t\t}\n\n\t\t// We can assume that the currently evaluated effect / computed signal is already\n\t\t// subscribed to change notifications from `signal` if needed.\n\t\treturn node;\n\t}\n\treturn undefined;\n}\n\n//#region Signal\n\n/**\n * The base class for plain and computed signals.\n */\n//\n// A function with the same name is defined later, so we need to ignore TypeScript's\n// warning about a redeclared variable.\n//\n// The class is declared here, but later implemented with ES5-style prototypes.\n// This enables better control of the transpiled output size.\n// @ts-ignore: \"Cannot redeclare exported variable 'Signal'.\"\ndeclare class Signal {\n\t/** @internal */\n\t_value: unknown;\n\n\t/**\n\t * @internal\n\t * Version numbers should always be >= 0, because the special value -1 is used\n\t * by Nodes to signify potentially unused but recyclable nodes.\n\t */\n\t_version: number;\n\n\t/** @internal */\n\t_node?: Node;\n\n\t/** @internal */\n\t_targets?: Node;\n\n\t/** @internal */\n\t_batchSnapshotVersion: number;\n\n\tconstructor(value?: T, options?: SignalOptions);\n\n\t/** @internal */\n\t_refresh(): boolean;\n\n\t/** @internal */\n\t_subscribe(node: Node): void;\n\n\t/** @internal */\n\t_unsubscribe(node: Node): void;\n\n\t/** @internal */\n\t_watched?(this: Signal): void;\n\n\t/** @internal */\n\t_unwatched?(this: Signal): void;\n\n\tsubscribe(fn: (value: T) => void): () => void;\n\n\tname?: string;\n\n\tvalueOf(): T;\n\n\ttoString(): string;\n\n\ttoJSON(): T;\n\n\tpeek(): T;\n\n\tbrand: typeof BRAND_SYMBOL;\n\n\tget value(): T;\n\tset value(value: T);\n}\n\nexport interface SignalOptions {\n\twatched?: (this: Signal) => void;\n\tunwatched?: (this: Signal) => void;\n\tname?: string;\n}\n\n/** @internal */\n// A class with the same name has already been declared, so we need to ignore\n// TypeScript's warning about a redeclared variable.\n//\n// The previously declared class is implemented here with ES5-style prototypes.\n// This enables better control of the transpiled output size.\n// @ts-ignore: \"Cannot redeclare exported variable 'Signal'.\"\nfunction Signal(this: Signal, value?: unknown, options?: SignalOptions) {\n\tthis._value = value;\n\tthis._version = 0;\n\tthis._node = undefined;\n\tthis._targets = undefined;\n\tthis._batchSnapshotVersion = 0;\n\tthis._watched = options?.watched;\n\tthis._unwatched = options?.unwatched;\n\tthis.name = options?.name;\n}\n\nSignal.prototype.brand = BRAND_SYMBOL;\n\nSignal.prototype._refresh = function () {\n\treturn true;\n};\n\nSignal.prototype._subscribe = function (node) {\n\tconst targets = this._targets;\n\tif (targets !== node && node._prevTarget === undefined) {\n\t\tnode._nextTarget = targets;\n\t\tthis._targets = node;\n\n\t\tif (targets !== undefined) {\n\t\t\ttargets._prevTarget = node;\n\t\t} else {\n\t\t\tuntracked(() => {\n\t\t\t\tthis._watched?.call(this);\n\t\t\t});\n\t\t}\n\t}\n};\n\nSignal.prototype._unsubscribe = function (node) {\n\t// Only run the unsubscribe step if the signal has any subscribers to begin with.\n\tif (this._targets !== undefined) {\n\t\tconst prev = node._prevTarget;\n\t\tconst next = node._nextTarget;\n\t\tif (prev !== undefined) {\n\t\t\tprev._nextTarget = next;\n\t\t\tnode._prevTarget = undefined;\n\t\t}\n\n\t\tif (next !== undefined) {\n\t\t\tnext._prevTarget = prev;\n\t\t\tnode._nextTarget = undefined;\n\t\t}\n\n\t\tif (node === this._targets) {\n\t\t\tthis._targets = next;\n\t\t\tif (next === undefined) {\n\t\t\t\tuntracked(() => {\n\t\t\t\t\tthis._unwatched?.call(this);\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t}\n};\n\nSignal.prototype.subscribe = function (fn) {\n\treturn effect(\n\t\t() => {\n\t\t\tconst value = this.value;\n\t\t\tuntracked(() => fn(value));\n\t\t},\n\t\t{ name: \"sub\" }\n\t);\n};\n\nSignal.prototype.valueOf = function () {\n\treturn this.value;\n};\n\nSignal.prototype.toString = function () {\n\treturn this.value + \"\";\n};\n\nSignal.prototype.toJSON = function () {\n\treturn this.value;\n};\n\nSignal.prototype.peek = function () {\n\treturn untracked(() => this.value);\n};\n\nObject.defineProperty(Signal.prototype, \"value\", {\n\tget(this: Signal) {\n\t\tconst node = addDependency(this);\n\t\tif (node !== undefined) {\n\t\t\tnode._version = this._version;\n\t\t}\n\t\treturn this._value;\n\t},\n\tset(this: Signal, value) {\n\t\tif (value !== this._value) {\n\t\t\tif (batchIteration > 100) {\n\t\t\t\tthrow new Error(\"Cycle detected\");\n\t\t\t}\n\n\t\t\trecordBatchSnapshot(this);\n\t\t\tthis._value = value;\n\t\t\tthis._version++;\n\t\t\tglobalVersion++;\n\n\t\t\t/**@__INLINE__*/ startBatch();\n\t\t\ttry {\n\t\t\t\tfor (\n\t\t\t\t\tlet node = this._targets;\n\t\t\t\t\tnode !== undefined;\n\t\t\t\t\tnode = node._nextTarget\n\t\t\t\t) {\n\t\t\t\t\tnode._target._notify();\n\t\t\t\t}\n\t\t\t} finally {\n\t\t\t\tendBatch();\n\t\t\t}\n\t\t}\n\t},\n});\n\n/**\n * Create a new plain signal.\n *\n * @param value The initial value for the signal.\n * @returns A new signal.\n */\nexport function signal(value: T, options?: SignalOptions): Signal;\nexport function signal(): Signal;\nexport function signal(value?: T, options?: SignalOptions): Signal {\n\treturn new Signal(value, options);\n}\n\n//#endregion Signal\n\n//#region Computed\n\nfunction needsToRecompute(target: Computed | Effect): boolean {\n\t// Check the dependencies for changed values. The dependency list is already\n\t// in order of use. Therefore if multiple dependencies have changed values, only\n\t// the first used dependency is re-evaluated at this point.\n\tfor (\n\t\tlet node = target._sources;\n\t\tnode !== undefined;\n\t\tnode = node._nextSource\n\t) {\n\t\tif (\n\t\t\t// If the dependency has definitely been updated since its version number\n\t\t\t// was observed, then we need to recompute. This first check is not strictly\n\t\t\t// necessary for correctness, but allows us to skip the refresh call if the\n\t\t\t// dependency has already been updated.\n\t\t\tnode._source._version !== node._version ||\n\t\t\t// Refresh the dependency. If there's something blocking the refresh (e.g. a\n\t\t\t// dependency cycle), then we need to recompute.\n\t\t\t!node._source._refresh() ||\n\t\t\t// If the dependency got a new version after the refresh, then we need to recompute.\n\t\t\tnode._source._version !== node._version\n\t\t) {\n\t\t\treturn true;\n\t\t}\n\t}\n\t// If none of the dependencies have changed values since last recompute then\n\t// there's no need to recompute.\n\treturn false;\n}\n\nfunction prepareSources(target: Computed | Effect) {\n\t/**\n\t * 1. Mark all current sources as re-usable nodes (version: -1)\n\t * 2. Set a rollback node if the current node is being used in a different context\n\t * 3. Point 'target._sources' to the tail of the doubly-linked list, e.g:\n\t *\n\t * { undefined <- A <-> B <-> C -> undefined }\n\t * ↑ ↑\n\t * │ └──────┐\n\t * target._sources = A; (node is head) │\n\t * ↓ │\n\t * target._sources = C; (node is tail) ─┘\n\t */\n\tfor (\n\t\tlet node = target._sources;\n\t\tnode !== undefined;\n\t\tnode = node._nextSource\n\t) {\n\t\tconst rollbackNode = node._source._node;\n\t\tif (rollbackNode !== undefined) {\n\t\t\tnode._rollbackNode = rollbackNode;\n\t\t}\n\t\tnode._source._node = node;\n\t\tnode._version = -1;\n\n\t\tif (node._nextSource === undefined) {\n\t\t\ttarget._sources = node;\n\t\t\tbreak;\n\t\t}\n\t}\n}\n\nfunction cleanupSources(target: Computed | Effect) {\n\tlet node = target._sources;\n\tlet head: Node | undefined = undefined;\n\n\t/**\n\t * At this point 'target._sources' points to the tail of the doubly-linked list.\n\t * It contains all existing sources + new sources in order of use.\n\t * Iterate backwards until we find the head node while dropping old dependencies.\n\t */\n\twhile (node !== undefined) {\n\t\tconst prev = node._prevSource;\n\n\t\t/**\n\t\t * The node was not re-used, unsubscribe from its change notifications and remove itself\n\t\t * from the doubly-linked list. e.g:\n\t\t *\n\t\t * { A <-> B <-> C }\n\t\t * ↓\n\t\t * { A <-> C }\n\t\t */\n\t\tif (node._version === -1) {\n\t\t\tnode._source._unsubscribe(node);\n\n\t\t\tif (prev !== undefined) {\n\t\t\t\tprev._nextSource = node._nextSource;\n\t\t\t}\n\t\t\tif (node._nextSource !== undefined) {\n\t\t\t\tnode._nextSource._prevSource = prev;\n\t\t\t}\n\t\t} else {\n\t\t\t/**\n\t\t\t * The new head is the last node seen which wasn't removed/unsubscribed\n\t\t\t * from the doubly-linked list. e.g:\n\t\t\t *\n\t\t\t * { A <-> B <-> C }\n\t\t\t * ↑ ↑ ↑\n\t\t\t * │ │ └ head = node\n\t\t\t * │ └ head = node\n\t\t\t * └ head = node\n\t\t\t */\n\t\t\thead = node;\n\t\t}\n\n\t\tnode._source._node = node._rollbackNode;\n\t\tif (node._rollbackNode !== undefined) {\n\t\t\tnode._rollbackNode = undefined;\n\t\t}\n\n\t\tnode = prev;\n\t}\n\n\ttarget._sources = head;\n}\n\n/**\n * The base class for computed signals.\n */\ndeclare class Computed extends Signal {\n\t_fn: () => T;\n\t_sources?: Node;\n\t_globalVersion: number;\n\t_flags: number;\n\n\tconstructor(fn: () => T, options?: SignalOptions);\n\n\t_notify(): void;\n\tget value(): T;\n}\n\n/** @internal */\nfunction Computed(this: Computed, fn: () => unknown, options?: SignalOptions) {\n\tSignal.call(this, undefined, options);\n\n\tthis._fn = fn;\n\tthis._sources = undefined;\n\tthis._globalVersion = globalVersion - 1;\n\tthis._flags = OUTDATED;\n}\n\nComputed.prototype = new Signal() as Computed;\n\nComputed.prototype._refresh = function () {\n\tthis._flags &= ~NOTIFIED;\n\n\tif (this._flags & RUNNING) {\n\t\treturn false;\n\t}\n\n\t// If this computed signal has subscribed to updates from its dependencies\n\t// (TRACKING flag set) and none of them have notified about changes (OUTDATED\n\t// flag not set), then the computed value can't have changed.\n\tif ((this._flags & (OUTDATED | TRACKING)) === TRACKING) {\n\t\treturn true;\n\t}\n\tthis._flags &= ~OUTDATED;\n\n\tif (this._globalVersion === globalVersion) {\n\t\treturn true;\n\t}\n\tthis._globalVersion = globalVersion;\n\n\t// Mark this computed signal running before checking the dependencies for value\n\t// changes, so that the RUNNING flag can be used to notice cyclical dependencies.\n\tthis._flags |= RUNNING;\n\tif (this._version > 0 && !needsToRecompute(this)) {\n\t\tthis._flags &= ~RUNNING;\n\t\treturn true;\n\t}\n\n\tconst prevContext = evalContext;\n\ttry {\n\t\tprepareSources(this);\n\t\tevalContext = this;\n\t\tconst value = this._fn();\n\t\tif (\n\t\t\tthis._flags & HAS_ERROR ||\n\t\t\tthis._value !== value ||\n\t\t\tthis._version === 0\n\t\t) {\n\t\t\tthis._value = value;\n\t\t\tthis._flags &= ~HAS_ERROR;\n\t\t\tthis._version++;\n\t\t}\n\t} catch (err) {\n\t\tthis._value = err;\n\t\tthis._flags |= HAS_ERROR;\n\t\tthis._version++;\n\t}\n\tevalContext = prevContext;\n\tcleanupSources(this);\n\tthis._flags &= ~RUNNING;\n\treturn true;\n};\n\nComputed.prototype._subscribe = function (node) {\n\tif (this._targets === undefined) {\n\t\tthis._flags |= OUTDATED | TRACKING;\n\n\t\t// A computed signal subscribes lazily to its dependencies when it\n\t\t// gets its first subscriber.\n\t\tfor (\n\t\t\tlet node = this._sources;\n\t\t\tnode !== undefined;\n\t\t\tnode = node._nextSource\n\t\t) {\n\t\t\tnode._source._subscribe(node);\n\t\t}\n\t}\n\tSignal.prototype._subscribe.call(this, node);\n};\n\nComputed.prototype._unsubscribe = function (node) {\n\t// Only run the unsubscribe step if the computed signal has any subscribers.\n\tif (this._targets !== undefined) {\n\t\tSignal.prototype._unsubscribe.call(this, node);\n\n\t\t// Computed signal unsubscribes from its dependencies when it loses its last subscriber.\n\t\t// This makes it possible for unreferences subgraphs of computed signals to get garbage collected.\n\t\tif (this._targets === undefined) {\n\t\t\tthis._flags &= ~TRACKING;\n\n\t\t\tfor (\n\t\t\t\tlet node = this._sources;\n\t\t\t\tnode !== undefined;\n\t\t\t\tnode = node._nextSource\n\t\t\t) {\n\t\t\t\tnode._source._unsubscribe(node);\n\t\t\t}\n\t\t}\n\t}\n};\n\nComputed.prototype._notify = function () {\n\tif (!(this._flags & NOTIFIED)) {\n\t\tthis._flags |= OUTDATED | NOTIFIED;\n\n\t\tfor (\n\t\t\tlet node = this._targets;\n\t\t\tnode !== undefined;\n\t\t\tnode = node._nextTarget\n\t\t) {\n\t\t\tnode._target._notify();\n\t\t}\n\t}\n};\n\nObject.defineProperty(Computed.prototype, \"value\", {\n\tget(this: Computed) {\n\t\tif (this._flags & RUNNING) {\n\t\t\tthrow new Error(\"Cycle detected\");\n\t\t}\n\t\tconst node = addDependency(this);\n\t\tthis._refresh();\n\t\tif (node !== undefined) {\n\t\t\tnode._version = this._version;\n\t\t}\n\t\tif (this._flags & HAS_ERROR) {\n\t\t\tthrow this._value;\n\t\t}\n\t\treturn this._value;\n\t},\n});\n\n/**\n * An interface for read-only signals.\n */\ninterface ReadonlySignal {\n\treadonly value: T;\n\tpeek(): T;\n\n\tsubscribe(fn: (value: T) => void): () => void;\n\tvalueOf(): T;\n\ttoString(): string;\n\ttoJSON(): T;\n\tbrand: typeof BRAND_SYMBOL;\n}\n\n/**\n * Create a new signal that is computed based on the values of other signals.\n *\n * The returned computed signal is read-only, and its value is automatically\n * updated when any signals accessed from within the callback function change.\n *\n * @param fn The effect callback.\n * @returns A new read-only signal.\n */\nfunction computed(\n\tfn: () => T,\n\toptions?: SignalOptions\n): ReadonlySignal {\n\treturn new Computed(fn, options);\n}\n\n//#endregion Computed\n\n//#region Effect\n\nfunction cleanupEffect(effect: Effect) {\n\tconst cleanup = effect._cleanup;\n\teffect._cleanup = undefined;\n\n\tif (typeof cleanup === \"function\") {\n\t\t/*@__INLINE__**/ startBatch();\n\n\t\t// Run cleanup functions always outside of any context.\n\t\tconst prevContext = evalContext;\n\t\tevalContext = undefined;\n\t\ttry {\n\t\t\tcleanup();\n\t\t} catch (err) {\n\t\t\teffect._flags &= ~RUNNING;\n\t\t\teffect._flags |= DISPOSED;\n\t\t\tdisposeEffect(effect);\n\t\t\tthrow err;\n\t\t} finally {\n\t\t\tevalContext = prevContext;\n\t\t\tendBatch();\n\t\t}\n\t}\n}\n\nfunction disposeEffect(effect: Effect) {\n\tfor (\n\t\tlet node = effect._sources;\n\t\tnode !== undefined;\n\t\tnode = node._nextSource\n\t) {\n\t\tnode._source._unsubscribe(node);\n\t}\n\teffect._fn = undefined;\n\teffect._sources = undefined;\n\n\tcleanupEffect(effect);\n}\n\nfunction endEffect(this: Effect, prevContext?: Computed | Effect) {\n\tif (evalContext !== this) {\n\t\tthrow new Error(\"Out-of-order effect\");\n\t}\n\tcleanupSources(this);\n\tevalContext = prevContext;\n\n\tthis._flags &= ~RUNNING;\n\tif (this._flags & DISPOSED) {\n\t\tdisposeEffect(this);\n\t}\n\tendBatch();\n}\n\ntype EffectFn =\n\t| ((this: { dispose: () => void }) => void | (() => void))\n\t| (() => void | (() => void));\n\n// Avoid hard-requiring the ESNext.Disposable lib in consuming tsconfigs.\n// When `Symbol.dispose` is available, this becomes a symbol-keyed disposer type.\ntype DisposeSymbol = typeof Symbol extends { readonly dispose: infer TDispose }\n\t? TDispose\n\t: never;\ntype DisposableLike = {\n\t[K in DisposeSymbol & PropertyKey]: () => void;\n};\ntype DisposeFn = (() => void) & DisposableLike;\n\n/**\n * The base class for reactive effects.\n */\ndeclare class Effect {\n\t_fn?: EffectFn;\n\t_cleanup?: () => void;\n\t_sources?: Node;\n\t_nextBatchedEffect?: Effect;\n\t_flags: number;\n\t_debugCallback?: () => void;\n\tname?: string;\n\n\tconstructor(fn: EffectFn, options?: EffectOptions);\n\n\t_callback(): void;\n\t_start(): () => void;\n\t_notify(): void;\n\t_dispose(): void;\n\tdispose(): void;\n}\n\nexport interface EffectOptions {\n\tname?: string;\n}\n\n/** @internal */\nfunction Effect(this: Effect, fn: EffectFn, options?: EffectOptions) {\n\tthis._fn = fn;\n\tthis._cleanup = undefined;\n\tthis._sources = undefined;\n\tthis._nextBatchedEffect = undefined;\n\tthis._flags = TRACKING;\n\tthis.name = options?.name;\n\n\tif (capturedEffects) {\n\t\tcapturedEffects.push(this);\n\t}\n}\n\nEffect.prototype._callback = function () {\n\tconst finish = this._start();\n\ttry {\n\t\tif (this._flags & DISPOSED) return;\n\t\tif (this._fn === undefined) return;\n\n\t\tconst cleanup = this._fn();\n\t\tif (typeof cleanup === \"function\") {\n\t\t\tthis._cleanup = cleanup;\n\t\t}\n\t} finally {\n\t\tfinish();\n\t}\n};\n\nEffect.prototype._start = function () {\n\tif (this._flags & RUNNING) {\n\t\tthrow new Error(\"Cycle detected\");\n\t}\n\tthis._flags |= RUNNING;\n\tthis._flags &= ~DISPOSED;\n\tcleanupEffect(this);\n\tprepareSources(this);\n\n\t/*@__INLINE__**/ startBatch();\n\tconst prevContext = evalContext;\n\tevalContext = this;\n\treturn endEffect.bind(this, prevContext);\n};\n\nEffect.prototype._notify = function () {\n\tif (!(this._flags & NOTIFIED)) {\n\t\tthis._flags |= NOTIFIED;\n\t\tthis._nextBatchedEffect = batchedEffect;\n\t\tbatchedEffect = this;\n\t}\n};\n\nEffect.prototype._dispose = function () {\n\tthis._flags |= DISPOSED;\n\n\tif (!(this._flags & RUNNING)) {\n\t\tdisposeEffect(this);\n\t}\n};\n\nEffect.prototype.dispose = function () {\n\tthis._dispose();\n};\n/**\n * Create an effect to run arbitrary code in response to signal changes.\n *\n * An effect tracks which signals are accessed within the given callback\n * function `fn`, and re-runs the callback when those signals change.\n *\n * The callback may return a cleanup function. The cleanup function gets\n * run once, either when the callback is next called or when the effect\n * gets disposed, whichever happens first.\n *\n * @param fn The effect callback.\n * @returns A function for disposing the effect.\n */\nfunction effect(fn: EffectFn, options?: EffectOptions): DisposeFn {\n\tconst effect = new Effect(fn, options);\n\ttry {\n\t\teffect._callback();\n\t} catch (err) {\n\t\teffect._dispose();\n\t\tthrow err;\n\t}\n\t// Return a bound function instead of a wrapper like `() => effect._dispose()`,\n\t// because bound functions seem to be just as fast and take up a lot less memory.\n\tconst dispose = effect._dispose.bind(effect);\n\t(dispose as any)[Symbol.dispose] = dispose;\n\treturn dispose as DisposeFn;\n}\n\n//#endregion Effect\n\n//#region Action\n\nfunction action(\n\tfn: (...args: TArgs) => TReturn\n): (...args: TArgs) => TReturn {\n\treturn function actionWrapper(this: unknown, ...args: TArgs) {\n\t\treturn batch(() => untracked(() => fn.apply(this, args)));\n\t};\n}\n\n//#endregion Action\n\n//#region createModel\n\n/** Models should only contain signals, actions, and nested objects containing only signals and actions. */\ntype ValidateModel = {\n\t[Key in keyof TModel]: TModel[Key] extends ReadonlySignal\n\t\t? TModel[Key]\n\t\t: TModel[Key] extends (...args: any[]) => any\n\t\t\t? TModel[Key]\n\t\t\t: TModel[Key] extends object\n\t\t\t\t? ValidateModel\n\t\t\t\t: `Property ${Key extends string ? `'${Key}' ` : \"\"}is not a Signal, Action, or an object that contains only Signals and Actions.`;\n};\n\nexport type Model = ValidateModel & DisposableLike;\n\nexport type ModelFactory = (\n\t...args: TFactoryArgs\n) => ValidateModel;\nexport type ModelConstructor = new (\n\t...args: TFactoryArgs\n) => Model;\n\n/**\n * The public types for ModelConstructor require using `new` to help\n * disambiguate the function passed into `createModel` and the returned\n * constructor function. It is easier to say that `createModel` accepts\n * a factory and returns a class, then to say it accepts a factory and\n * returns a factory. In other words, this example:\n *\n * ```ts\n * const PersonModel = createModel((name: string) => ({ ... }));\n * const person = new PersonModel(\"John\");\n * ```\n *\n * is easier to understand than this example:\n *\n * ```ts\n * const createPerson = createModel((name: string) => ({ ... }));\n * const person = createPerson(\"John\");\n * ```\n *\n * However, internally we implement `createModel` to return a function\n * that can be called without `new` for simplicity. To bridge the gap\n * between the public types and the internal implementation, we define\n * this internal interface that extends the public interface but also\n * allows calling without `new`.\n *\n * This pattern is used by the Preact & React adapters to make instantiating\n * a model or a function that returns a model easier.\n *\n * @internal\n */\ninterface InternalModelConstructor<\n\tTModel,\n\tTFactoryArgs extends any[],\n> extends ModelConstructor {\n\t(...args: TFactoryArgs): Model;\n}\n\nfunction startCapturingEffects(): () => Effect[] | undefined {\n\tlet prevCapturedEffects = capturedEffects;\n\t// Always establish a fresh capture scope, even when `untracked()` has\n\t// temporarily cleared the parent scope. This lets nested models own their\n\t// effects without promoting them to a suppressed outer scope.\n\tcapturedEffects = [];\n\n\treturn function stopCapturingEffects() {\n\t\tlet modelEffects = capturedEffects;\n\t\tif (capturedEffects && prevCapturedEffects) {\n\t\t\tprevCapturedEffects = prevCapturedEffects.concat(capturedEffects);\n\t\t}\n\n\t\tcapturedEffects = prevCapturedEffects;\n\n\t\treturn modelEffects;\n\t};\n}\n\nconst wrapInAction = (value: Record) => {\n\tfor (const key in value) {\n\t\tconst val = value[key];\n\t\tif (typeof val === \"function\") {\n\t\t\tvalue[key] = action(val as (...args: unknown[]) => unknown);\n\t\t} else if (typeof val === \"object\" && val !== null && !(\"brand\" in val)) {\n\t\t\t// Recursively wrap nested object properties in actions. This allows users to write\n\t\t\t// nested models without worrying about wrapping their functions in `action`.\n\t\t\twrapInAction(val as Record);\n\t\t}\n\t}\n};\n\nfunction createModel(\n\tmodelFactory: ModelFactory\n): ModelConstructor {\n\treturn function SignalModel(...args: TFactoryArgs): Model {\n\t\tlet modelEffects: Effect[] | undefined;\n\t\tlet model: Model;\n\n\t\tconst stopCapturingEffects = startCapturingEffects();\n\t\ttry {\n\t\t\tmodel = modelFactory(...args) as Model;\n\t\t} catch (err) {\n\t\t\t// Drop any captured effects on error. Errors from nested models will bubble\n\t\t\t// up here and recursively reset `capturedEffects` to `undefined` preventing\n\t\t\t// any captured effects from leaking\n\t\t\tcapturedEffects = undefined;\n\t\t\tthrow err;\n\t\t} finally {\n\t\t\tmodelEffects = stopCapturingEffects();\n\t\t}\n\n\t\twrapInAction(model);\n\n\t\tmodel[Symbol.dispose] = action(function disposeModel() {\n\t\t\tif (modelEffects) {\n\t\t\t\tfor (let i = 0; i < modelEffects.length; i++) {\n\t\t\t\t\tmodelEffects[i].dispose();\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tmodelEffects = undefined;\n\t\t});\n\n\t\treturn model;\n\t} as InternalModelConstructor;\n}\n\n//#endregion createModel\n\nexport {\n\tcomputed,\n\teffect,\n\tbatch,\n\tuntracked,\n\taction,\n\tcreateModel,\n\tSignal,\n\tReadonlySignal,\n\tEffect,\n\tComputed,\n};\n"],"names":["g","f","exports","module","define","amd","globalThis","self","preactSignalsCore","this","BRAND_SYMBOL","Symbol","endBatch","batchDepth","error","hasError","snapshots","batchSnapshots","undefined","source","_source","_value","node","_targets","_nextTarget","_version","_next","reconcileBatchSnapshots","batchedEffect","effect","batchIteration","next","_nextBatchedEffect","_flags","needsToRecompute","_callback","err","batch","fn","currentBatchSnapshotVersion","batchSnapshotVersion","capturedEffects","evalContext","untracked","prevContext","prevCapturedEffects","globalVersion","addDependency","signal","_node","_target","_prevSource","_sources","_nextSource","_prevTarget","_rollbackNode","_subscribe","Signal","value","options","_batchSnapshotVersion","_watched","watched","_unwatched","unwatched","name","prototype","brand","_refresh","_this","targets","_this$_watched","call","_unsubscribe","_this2","prev","_this2$_unwatched","subscribe","_this3","valueOf","toString","toJSON","peek","_this4","Object","defineProperty","get","set","Error","recordBatchSnapshot","_notify","target","prepareSources","rollbackNode","cleanupSources","head","Computed","_fn","_globalVersion","OUTDATED","cleanupEffect","cleanup","_cleanup","disposeEffect","endEffect","Effect","push","finish","_start","bind","_dispose","dispose","action","_arguments","arguments","_this5","apply","slice","startCapturingEffects","modelEffects","concat","wrapInAction","key","val","computed","createModel","modelFactory","model","stopCapturingEffects","i","length"],"mappings":"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"}