{"mappings":"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","names":["BRAND_SYMBOL","Symbol","endBatch","batchDepth","error","hasError","snapshots","batchSnapshots","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","this","_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","_notify","target","prepareSources","rollbackNode","cleanupSources","head","Computed","_fn","_globalVersion","OUTDATED","computed","cleanupEffect","cleanup","_cleanup","disposeEffect","endEffect","Effect","push","finish","_start","bind","_dispose","dispose","action","_arguments","arguments","_this5","apply","slice","startCapturingEffects","modelEffects","concat","wrapInAction","visited","walkPrototypes","seen","create","obj","getPrototypeOf","descs","getOwnPropertyDescriptors","key","val","indexOf","createModel","modelFactory","model","stopCapturingEffects","effects","i","length","_unused","_unused2"],"sources":["../esm/npm/@preact/signals-core@1.14.5/node_modules/@preact/signals-core/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 \u003c\u003c 0;\nconst NOTIFIED = 1 \u003c\u003c 1;\nconst OUTDATED = 1 \u003c\u003c 2;\nconst DISPOSED = 1 \u003c\u003c 3;\nconst HAS_ERROR = 1 \u003c\u003c 4;\nconst TRACKING = 1 \u003c\u003c 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 \u0026 roll back the source's previous `._node` value when entering \u0026\n\t// exiting a new evaluation context.\n\t_rollbackNode?: Node;\n};\n\nfunction startBatch() {\n\tbatchDepth++;\n}\n\nfunction endBatch() {\n\tif (batchDepth \u003e 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 \u0026= ~NOTIFIED;\n\n\t\t\tif (!(effect._flags \u0026 DISPOSED) \u0026\u0026 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\u003cT\u003e(fn: () =\u003e T): T {\n\tif (batchDepth \u003e 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\u003cT\u003e(fn: () =\u003e 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 \u003c-\u003e B       }\n\t\t *         ↑     ↑\n\t\t *        tail  node (new)\n\t\t *               ↓\n\t\t * { A \u003c-\u003e B \u003c-\u003e 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 \u0026 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 \u003c-\u003e B \u003c-\u003e C \u003c-\u003e D }\n\t\t *         ↑           ↑\n\t\t *        node   ┌─── tail (evalContext._sources)\n\t\t *         └─────│─────┐\n\t\t *               ↓     ↓\n\t\t * { A \u003c-\u003e C \u003c-\u003e D \u003c-\u003e 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\u003cT = any\u003e {\n\t/** @internal */\n\t_value: unknown;\n\n\t/**\n\t * @internal\n\t * Version numbers should always be \u003e= 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\u003cT\u003e);\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\u003cT\u003e): void;\n\n\t/** @internal */\n\t_unwatched?(this: Signal\u003cT\u003e): void;\n\n\tsubscribe(fn: (value: T) =\u003e void): () =\u003e 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\u003cT = any\u003e {\n\twatched?: (this: Signal\u003cT\u003e) =\u003e void;\n\tunwatched?: (this: Signal\u003cT\u003e) =\u003e 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 \u0026\u0026 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(() =\u003e {\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(() =\u003e {\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() =\u003e {\n\t\t\tconst value = this.value;\n\t\t\tuntracked(() =\u003e 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(() =\u003e 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 \u003e 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\u003cT\u003e(value: T, options?: SignalOptions\u003cT\u003e): Signal\u003cT\u003e;\nexport function signal\u003cT = undefined\u003e(): Signal\u003cT | undefined\u003e;\nexport function signal\u003cT\u003e(value?: T, options?: SignalOptions\u003cT\u003e): Signal\u003cT\u003e {\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 \u003c- A \u003c-\u003e B \u003c-\u003e C -\u003e 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 \u003c-\u003e B \u003c-\u003e C }\n\t\t *         ↓\n\t\t *    { A \u003c-\u003e 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 \u003c-\u003e B \u003c-\u003e 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\u003cT = any\u003e extends Signal\u003cT\u003e {\n\t_fn: () =\u003e T;\n\t_sources?: Node;\n\t_globalVersion: number;\n\t_flags: number;\n\n\tconstructor(fn: () =\u003e T, options?: SignalOptions\u003cT\u003e);\n\n\t_notify(): void;\n\tget value(): T;\n}\n\n/** @internal */\nfunction Computed(this: Computed, fn: () =\u003e 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 \u0026= ~NOTIFIED;\n\n\tif (this._flags \u0026 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 \u0026 (OUTDATED | TRACKING)) === TRACKING) {\n\t\treturn true;\n\t}\n\tthis._flags \u0026= ~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 \u003e 0 \u0026\u0026 !needsToRecompute(this)) {\n\t\tthis._flags \u0026= ~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 \u0026 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 \u0026= ~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 \u0026= ~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 \u0026= ~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 \u0026 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 \u0026 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 \u0026 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\u003cT = any\u003e {\n\treadonly value: T;\n\tpeek(): T;\n\n\tsubscribe(fn: (value: T) =\u003e void): () =\u003e 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\u003cT\u003e(\n\tfn: () =\u003e T,\n\toptions?: SignalOptions\u003cT\u003e\n): ReadonlySignal\u003cT\u003e {\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 \u0026= ~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 \u0026= ~RUNNING;\n\ttry {\n\t\tif (this._flags \u0026 DISPOSED) {\n\t\t\tdisposeEffect(this);\n\t\t}\n\t} finally {\n\t\tendBatch();\n\t}\n}\n\ntype EffectFn =\n\t| ((this: { dispose: () =\u003e void }) =\u003e void | (() =\u003e void))\n\t| (() =\u003e void | (() =\u003e 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 \u0026 PropertyKey]: () =\u003e void;\n};\ntype DisposeFn = (() =\u003e void) \u0026 DisposableLike;\n\n/**\n * The base class for reactive effects.\n */\ndeclare class Effect {\n\t_fn?: EffectFn;\n\t_cleanup?: () =\u003e void;\n\t_sources?: Node;\n\t_nextBatchedEffect?: Effect;\n\t_flags: number;\n\t_debugCallback?: () =\u003e void;\n\tname?: string;\n\n\tconstructor(fn: EffectFn, options?: EffectOptions);\n\n\t_callback(): void;\n\t_start(): () =\u003e 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 \u0026 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 \u0026 RUNNING) {\n\t\tthrow new Error(\"Cycle detected\");\n\t}\n\tthis._flags |= RUNNING;\n\tthis._flags \u0026= ~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 \u0026 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 \u0026 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 `() =\u003e 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\u003cTArgs extends unknown[], TReturn\u003e(\n\tfn: (...args: TArgs) =\u003e TReturn\n): (...args: TArgs) =\u003e TReturn {\n\treturn function actionWrapper(this: unknown, ...args: TArgs) {\n\t\treturn batch(() =\u003e untracked(() =\u003e 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\u003cTModel\u003e = {\n\t[Key in keyof TModel]: TModel[Key] extends ReadonlySignal\u003cunknown\u003e\n\t\t? TModel[Key]\n\t\t: TModel[Key] extends (...args: any[]) =\u003e any\n\t\t\t? TModel[Key]\n\t\t\t: TModel[Key] extends object\n\t\t\t\t? ValidateModel\u003cTModel[Key]\u003e\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\u003cTModel\u003e = ValidateModel\u003cTModel\u003e \u0026 DisposableLike;\n\nexport type ModelFactory\u003cTModel, TFactoryArgs extends any[] = []\u003e = (\n\t...args: TFactoryArgs\n) =\u003e ValidateModel\u003cTModel\u003e;\nexport type ModelConstructor\u003cTModel, TFactoryArgs extends any[] = []\u003e = new (\n\t...args: TFactoryArgs\n) =\u003e Model\u003cTModel\u003e;\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) =\u003e ({ ... }));\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) =\u003e ({ ... }));\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 \u0026 React adapters to make instantiating\n * a model or a function that returns a model easier.\n *\n * @internal\n */\ninterface InternalModelConstructor\u003c\n\tTModel,\n\tTFactoryArgs extends any[],\n\u003e extends ModelConstructor\u003cTModel, TFactoryArgs\u003e {\n\t(...args: TFactoryArgs): Model\u003cTModel\u003e;\n}\n\nfunction startCapturingEffects(): () =\u003e 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 \u0026\u0026 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\u003cstring, unknown\u003e, visited: object[]) =\u003e {\n\tvisited.push(value);\n\t// Leaves built-ins like Map, Date and Array alone.\n\tconst walkPrototypes =\n\t\tObject.prototype.toString.call(value) === \"[object Object]\";\n\t// Avoids reading `value[key]`, which could run a shadowing getter.\n\tconst seen: Record\u003cstring, boolean\u003e = Object.create(null);\n\tfor (\n\t\tlet obj = value;\n\t\tobj \u0026\u0026 obj !== Object.prototype;\n\t\tobj = walkPrototypes \u0026\u0026 Object.getPrototypeOf(obj)\n\t) {\n\t\tconst descs = Object.getOwnPropertyDescriptors(obj);\n\t\tfor (const key in descs) {\n\t\t\tif (seen[key]) continue;\n\t\t\tseen[key] = true;\n\t\t\tconst val = descs[key].value;\n\t\t\tif (typeof val === \"function\") {\n\t\t\t\tif (key !== \"constructor\") {\n\t\t\t\t\tvalue[key] = action(val as (...args: unknown[]) =\u003e unknown);\n\t\t\t\t}\n\t\t\t} else if (\n\t\t\t\tobj === value \u0026\u0026\n\t\t\t\ttypeof val === \"object\" \u0026\u0026\n\t\t\t\tval !== null \u0026\u0026\n\t\t\t\t!(\"brand\" in val) \u0026\u0026\n\t\t\t\tvisited.indexOf(val) \u003c 0\n\t\t\t) {\n\t\t\t\twrapInAction(val as Record\u003cstring, unknown\u003e, visited);\n\t\t\t}\n\t\t}\n\t}\n};\n\nfunction createModel\u003cTModel, TFactoryArgs extends any[] = []\u003e(\n\tmodelFactory: ModelFactory\u003cTModel, TFactoryArgs\u003e\n): ModelConstructor\u003cTModel, TFactoryArgs\u003e {\n\treturn function SignalModel(...args: TFactoryArgs): Model\u003cTModel\u003e {\n\t\tlet modelEffects: Effect[] | undefined;\n\t\tlet model: Model\u003cTModel\u003e;\n\n\t\tconst stopCapturingEffects = startCapturingEffects();\n\t\ttry {\n\t\t\tmodel = modelFactory(...args) as Model\u003cTModel\u003e;\n\t\t} catch (err) {\n\t\t\tconst effects = capturedEffects;\n\t\t\t// Keeps stopCapturingEffects from merging these into a parent model.\n\t\t\tcapturedEffects = undefined;\n\t\t\t// Clean up every effect without replacing the factory error.\n\t\t\tif (effects) {\n\t\t\t\ttry {\n\t\t\t\t\tbatch(() =\u003e {\n\t\t\t\t\t\tfor (let i = 0; i \u003c effects.length; i++) {\n\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\teffects[i].dispose();\n\t\t\t\t\t\t\t} catch {}\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t} catch {}\n\t\t\t}\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 \u003c 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\u003cTModel, TFactoryArgs\u003e;\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"],"version":3}
