@manyducks.co/dolla 3.1.0 → 3.3.0

package/dist/signals-CMJPGr_M.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"signals-CMJPGr_M.js","names":[],"sources":["../src/utils.ts","../src/core/signals.ts"],"sourcesContent":["/*=============================*\\\n||         ID Generator        ||\n\\*=============================*/\n\nlet lastId = 0;\nexport function uniqueId() {\n  return (lastId++).toString(36);\n}\n\n/*=============================*\\\n||         Object Utils        ||\n\\*=============================*/\n\n/**\n * Returns a new object without the specified keys.\n * If called without object, returns a function that takes an object\n * and returns a version with the original keys omitted.\n *\n * @param keys - An array of keys to omit.\n * @param object - An object to clone without the omitted keys.\n */\nexport function omit<O extends Record<any, any>>(keys: (keyof O)[], object: O): Record<any, any> {\n  const newObject: Record<any, any> = {};\n\n  for (const key in object) {\n    if (!keys.includes(key)) {\n      newObject[key] = object[key];\n    }\n  }\n\n  return newObject;\n}\n\n/*=============================*\\\n||        Type Checking        ||\n\\*=============================*/\n\n/**\n * Throws a TypeError unless `condition` is truthy.\n *\n * @param value - Value whose truthiness is in question.\n * @param errorMessage - Optional message for the thrown TypeError.\n */\nexport function assert<T = any>(value: T, errorMessage: string): asserts value is NonNullable<T> {\n  if (!value) throw new TypeError(errorMessage);\n}\n\n/**\n * Returns true if `value` is an array.\n */\nexport function isArray(value: unknown): value is Array<unknown> {\n  return Array.isArray(value);\n}\n\n/**\n * Returns true when `value` is an array and `check` returns true for every item.\n *\n * @param check - Function to check items against.\n * @param value - A possible array.\n */\nexport function isArrayOf<T>(check: (item: unknown) => boolean, value: unknown): value is T[];\nexport function isArrayOf<T>(check: (item: unknown) => boolean): (value: unknown) => value is T[];\n\nexport function isArrayOf<T>(check: (item: unknown) => boolean, value?: unknown) {\n  if (value) {\n    return isArray(value) && value.every((item) => check(item));\n  } else {\n    return (value: unknown) => isArrayOf<T>(check, value);\n  }\n}\n\n/**\n * Returns true if `value` is a string.\n */\nexport function isString(value: unknown): value is string {\n  return typeof value === \"string\";\n}\n\n/**\n * Returns true if `value` is a function (but not a class).\n */\nexport function isFunction<T = (...args: unknown[]) => unknown>(value: unknown): value is T {\n  return typeof value === \"function\" && !isClass(value);\n}\n\nexport function isClass(value: unknown) {\n  return /^\\s*class\\s+/.test(String(value));\n}\n\n/**\n * Returns true if `value` is a number.\n */\nexport function isNumber(value: unknown): value is number {\n  return typeof value === \"number\" && !isNaN(value);\n}\n\n/**\n * Returns `true` if `value` is an instance of `constructor`.\n *\n * @param constructor - The constructor `value` must be an instance of.\n * @param value - A value that may be an instance of `constructor`.\n */\nexport function isInstanceOf<T extends Function>(constructor: T, value: unknown): value is T;\nexport function isInstanceOf<T extends Function>(constructor: T): (value: unknown) => value is T;\n\nexport function isInstanceOf<T extends Function>(constructor: T, value?: unknown) {\n  if (value) {\n    return value instanceof constructor;\n  } else {\n    return (value: unknown) => isInstanceOf(constructor, value);\n  }\n}\n\n/**\n * Returns true if `value` is a JavaScript Promise.\n */\nexport function isPromise<T = unknown>(value: unknown): value is Promise<T> {\n  return value instanceof Promise;\n}\n\n/**\n * Returns true if `value` is a plain JavaScript object.\n */\nexport function isObject<T = Record<string | number | symbol, unknown>>(value: unknown): value is T {\n  return value != null && typeof value === \"object\" && !isArray(value);\n}\n","import { isFunction } from \"../utils.js\";\n\ninterface ReactiveNode {\n  _deps?: Link;\n  _depsTail?: Link;\n  _subs?: Link;\n  _subsTail?: Link;\n  _flags: ReactiveFlags;\n}\n\ninterface EffectNode extends ReactiveNode {\n  _fn(): void | (() => void);\n  _cleanup?: () => void;\n}\n\ninterface ComputedNode<T = any> extends ReactiveNode {\n  _value: T | undefined;\n  _getter: (previousValue?: T) => T;\n}\n\ninterface ValueNode<T = any> extends ReactiveNode {\n  _currentValue: T;\n  _pendingValue: T;\n}\n\ninterface Link {\n  _version: number;\n  _dep: ReactiveNode;\n  _sub: ReactiveNode;\n  _prevSub: Link | undefined;\n  _nextSub: Link | undefined;\n  _prevDep: Link | undefined;\n  _nextDep: Link | undefined;\n}\n\ninterface Stack<T> {\n  _value: T;\n  _prev: Stack<T> | undefined;\n}\n\n/*==================================*\\\n||         Signal Internals         ||\n\\*==================================*/\n\nconst enum ReactiveFlags {\n  None = 0,\n  Mutable = 1,\n  Watching = 2,\n  RecursedCheck = 4,\n  Recursed = 8,\n  Dirty = 16,\n  Pending = 32,\n}\n\nlet cycle = 0;\nlet batchDepth = 0;\nlet notifyIndex = 0;\nlet queuedLength = 0;\nlet activeSub: ReactiveNode | undefined;\n\nconst queued: (EffectNode | undefined)[] = [];\n\nfunction link(dep: ReactiveNode, sub: ReactiveNode, version: number): void {\n  const prevDep = sub._depsTail;\n  if (prevDep !== undefined && prevDep._dep === dep) {\n    return;\n  }\n  const nextDep = prevDep !== undefined ? prevDep._nextDep : sub._deps;\n  if (nextDep !== undefined && nextDep._dep === dep) {\n    nextDep._version = version;\n    sub._depsTail = nextDep;\n    return;\n  }\n  const prevSub = dep._subsTail;\n  if (prevSub !== undefined && prevSub._version === version && prevSub._sub === sub) {\n    return;\n  }\n  const newLink =\n    (sub._depsTail =\n    dep._subsTail =\n      {\n        _version: version,\n        _dep: dep,\n        _sub: sub,\n        _prevDep: prevDep,\n        _nextDep: nextDep,\n        _prevSub: prevSub,\n        _nextSub: undefined,\n      });\n  if (nextDep !== undefined) {\n    nextDep._prevDep = newLink;\n  }\n  if (prevDep !== undefined) {\n    prevDep._nextDep = newLink;\n  } else {\n    sub._deps = newLink;\n  }\n  if (prevSub !== undefined) {\n    prevSub._nextSub = newLink;\n  } else {\n    dep._subs = newLink;\n  }\n}\n\nfunction unwatched(node: ReactiveNode): void {\n  if (!(node._flags & ReactiveFlags.Mutable)) {\n    effectCleanup.call(node);\n  } else if (node._depsTail !== undefined) {\n    node._depsTail = undefined;\n    node._flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;\n    purgeDeps(node);\n  }\n}\n\nfunction unlink(link: Link, sub = link._sub): Link | undefined {\n  const dep = link._dep;\n  const prevDep = link._prevDep;\n  const nextDep = link._nextDep;\n  const nextSub = link._nextSub;\n  const prevSub = link._prevSub;\n  if (nextDep !== undefined) {\n    nextDep._prevDep = prevDep;\n  } else {\n    sub._depsTail = prevDep;\n  }\n  if (prevDep !== undefined) {\n    prevDep._nextDep = nextDep;\n  } else {\n    sub._deps = nextDep;\n  }\n  if (nextSub !== undefined) {\n    nextSub._prevSub = prevSub;\n  } else {\n    dep._subsTail = prevSub;\n  }\n  if (prevSub !== undefined) {\n    prevSub._nextSub = nextSub;\n  } else if ((dep._subs = nextSub) === undefined) {\n    unwatched(dep);\n  }\n  return nextDep;\n}\n\nfunction notify(effect: EffectNode): void {\n  let insertIndex = queuedLength;\n  let firstInsertedIndex = insertIndex;\n\n  do {\n    queued[insertIndex++] = effect;\n    effect._flags &= ~ReactiveFlags.Watching;\n    effect = effect._subs?._sub as EffectNode;\n    if (effect === undefined || !(effect._flags & ReactiveFlags.Watching)) {\n      break;\n    }\n  } while (true);\n\n  queuedLength = insertIndex;\n\n  while (firstInsertedIndex < --insertIndex) {\n    const left = queued[firstInsertedIndex];\n    queued[firstInsertedIndex++] = queued[insertIndex];\n    queued[insertIndex] = left;\n  }\n}\n\nfunction update(node: ReactiveNode): boolean {\n  if (node._depsTail !== undefined) {\n    return updateComputed(node as ComputedNode);\n  } else {\n    return updateValue(node as ValueNode);\n  }\n}\n\nfunction propagate(link: Link): void {\n  let next = link._nextSub;\n  let stack: Stack<Link | undefined> | undefined;\n\n  top: do {\n    const sub = link._sub;\n    let flags = sub._flags;\n\n    if (\n      !(flags & (ReactiveFlags.RecursedCheck | ReactiveFlags.Recursed | ReactiveFlags.Dirty | ReactiveFlags.Pending))\n    ) {\n      sub._flags = flags | ReactiveFlags.Pending;\n    } else if (!(flags & (ReactiveFlags.RecursedCheck | ReactiveFlags.Recursed))) {\n      flags = ReactiveFlags.None;\n    } else if (!(flags & ReactiveFlags.RecursedCheck)) {\n      sub._flags = (flags & ~ReactiveFlags.Recursed) | ReactiveFlags.Pending;\n    } else if (!(flags & (ReactiveFlags.Dirty | ReactiveFlags.Pending)) && isValidLink(link, sub)) {\n      sub._flags = flags | (ReactiveFlags.Recursed | ReactiveFlags.Pending);\n      flags &= ReactiveFlags.Mutable;\n    } else {\n      flags = ReactiveFlags.None;\n    }\n\n    if (flags & ReactiveFlags.Watching) {\n      notify(sub as EffectNode);\n    }\n\n    if (flags & ReactiveFlags.Mutable) {\n      const subSubs = sub._subs;\n      if (subSubs !== undefined) {\n        const nextSub = (link = subSubs)._nextSub;\n        if (nextSub !== undefined) {\n          stack = { _value: next, _prev: stack };\n          next = nextSub;\n        }\n        continue;\n      }\n    }\n\n    if ((link = next!) !== undefined) {\n      next = link._nextSub;\n      continue;\n    }\n\n    while (stack !== undefined) {\n      link = stack._value!;\n      stack = stack._prev;\n      if (link !== undefined) {\n        next = link._nextSub;\n        continue top;\n      }\n    }\n\n    break;\n  } while (true);\n}\n\nfunction checkDirty(link: Link, sub: ReactiveNode): boolean {\n  let stack: Stack<Link> | undefined;\n  let checkDepth = 0;\n  let dirty = false;\n\n  top: do {\n    const dep = link._dep;\n    const flags = dep._flags;\n\n    if (sub._flags & ReactiveFlags.Dirty) {\n      dirty = true;\n    } else if (\n      (flags & (ReactiveFlags.Mutable | ReactiveFlags.Dirty)) ===\n      (ReactiveFlags.Mutable | ReactiveFlags.Dirty)\n    ) {\n      if (update(dep)) {\n        const subs = dep._subs!;\n        if (subs._nextSub !== undefined) {\n          shallowPropagate(subs);\n        }\n        dirty = true;\n      }\n    } else if (\n      (flags & (ReactiveFlags.Mutable | ReactiveFlags.Pending)) ===\n      (ReactiveFlags.Mutable | ReactiveFlags.Pending)\n    ) {\n      if (link._nextSub !== undefined || link._prevSub !== undefined) {\n        stack = { _value: link, _prev: stack };\n      }\n      link = dep._deps!;\n      sub = dep;\n      ++checkDepth;\n      continue;\n    }\n\n    if (!dirty) {\n      const nextDep = link._nextDep;\n      if (nextDep !== undefined) {\n        link = nextDep;\n        continue;\n      }\n    }\n\n    while (checkDepth--) {\n      const firstSub = sub._subs!;\n      const hasMultipleSubs = firstSub._nextSub !== undefined;\n      if (hasMultipleSubs) {\n        link = stack!._value;\n        stack = stack!._prev;\n      } else {\n        link = firstSub;\n      }\n      if (dirty) {\n        if (update(sub)) {\n          if (hasMultipleSubs) {\n            shallowPropagate(firstSub);\n          }\n          sub = link._sub;\n          continue;\n        }\n        dirty = false;\n      } else {\n        sub._flags &= ~ReactiveFlags.Pending;\n      }\n      sub = link._sub;\n      const nextDep = link._nextDep;\n      if (nextDep !== undefined) {\n        link = nextDep;\n        continue top;\n      }\n    }\n\n    return dirty;\n  } while (true);\n}\n\nfunction shallowPropagate(link: Link): void {\n  do {\n    const sub = link._sub;\n    const flags = sub._flags;\n    if ((flags & (ReactiveFlags.Pending | ReactiveFlags.Dirty)) === ReactiveFlags.Pending) {\n      sub._flags = flags | ReactiveFlags.Dirty;\n      if ((flags & (ReactiveFlags.Watching | ReactiveFlags.RecursedCheck)) === ReactiveFlags.Watching) {\n        notify(sub as EffectNode);\n      }\n    }\n  } while ((link = link._nextSub!) !== undefined);\n}\n\nfunction isValidLink(checkLink: Link, sub: ReactiveNode): boolean {\n  let link = sub._depsTail;\n  while (link !== undefined) {\n    if (link === checkLink) {\n      return true;\n    }\n    link = link._prevDep;\n  }\n  return false;\n}\n\nfunction setActiveSub(sub?: ReactiveNode) {\n  const prevSub = activeSub;\n  activeSub = sub;\n  return prevSub;\n}\n\nfunction updateComputed(c: ComputedNode): boolean {\n  ++cycle;\n  c._depsTail = undefined;\n  c._flags = ReactiveFlags.Mutable | ReactiveFlags.RecursedCheck;\n  const prevSub = setActiveSub(c);\n  try {\n    const oldValue = c._value;\n    return oldValue !== (c._value = c._getter(oldValue));\n  } finally {\n    activeSub = prevSub;\n    c._flags &= ~ReactiveFlags.RecursedCheck;\n    purgeDeps(c);\n  }\n}\n\nfunction updateValue(v: ValueNode): boolean {\n  v._flags = ReactiveFlags.Mutable;\n  return v._currentValue !== (v._currentValue = v._pendingValue);\n}\n\nfunction run(e: EffectNode): void {\n  const flags = e._flags;\n  if (flags & ReactiveFlags.Dirty || (flags & ReactiveFlags.Pending && checkDirty(e._deps!, e))) {\n    ++cycle;\n    e._depsTail = undefined;\n    e._flags = ReactiveFlags.Watching | ReactiveFlags.RecursedCheck;\n    const prevSub = setActiveSub(e);\n    try {\n      e._cleanup?.();\n      e._cleanup = undefined;\n      const result = e._fn();\n      if (isFunction(result)) e._cleanup = result;\n    } finally {\n      activeSub = prevSub;\n      e._flags &= ~ReactiveFlags.RecursedCheck;\n      purgeDeps(e);\n    }\n  } else {\n    e._flags = ReactiveFlags.Watching;\n  }\n}\n\nfunction flush(): void {\n  try {\n    while (notifyIndex < queuedLength) {\n      const effect = queued[notifyIndex]!;\n      queued[notifyIndex++] = undefined;\n      run(effect);\n    }\n  } finally {\n    while (notifyIndex < queuedLength) {\n      const effect = queued[notifyIndex]!;\n      queued[notifyIndex++] = undefined;\n      effect._flags |= ReactiveFlags.Watching | ReactiveFlags.Recursed;\n    }\n    notifyIndex = 0;\n    queuedLength = 0;\n  }\n}\n\nfunction purgeDeps(sub: ReactiveNode) {\n  const depsTail = sub._depsTail;\n  let dep = depsTail !== undefined ? depsTail._nextDep : sub._deps;\n  while (dep !== undefined) {\n    dep = unlink(dep, sub);\n  }\n}\n\n/*==================================*\\\n||        API Implementation        ||\n\\*==================================*/\n\nfunction resolveValue<T>(next: SetterAction<T>, current: T): T {\n  if (isFunction(next)) return peek(() => next(current)) as T;\n  return next as T;\n}\n\nfunction computedGetter(this: ComputedNode) {\n  const flags = this._flags;\n  if (\n    flags & ReactiveFlags.Dirty ||\n    (flags & ReactiveFlags.Pending &&\n      (checkDirty(this._deps!, this) || ((this._flags = flags & ~ReactiveFlags.Pending), false)))\n  ) {\n    if (updateComputed(this)) {\n      const subs = this._subs;\n      if (subs !== undefined) {\n        shallowPropagate(subs);\n      }\n    }\n  } else if (!flags) {\n    this._flags = ReactiveFlags.Mutable | ReactiveFlags.RecursedCheck;\n    const prevSub = setActiveSub(this);\n    try {\n      this._value = unwrap(this._getter());\n    } finally {\n      activeSub = prevSub;\n      this._flags &= ~ReactiveFlags.RecursedCheck;\n    }\n  }\n  const sub = activeSub;\n  if (sub !== undefined) {\n    link(this, sub, cycle);\n  }\n  return this._value!;\n}\n\nfunction computedSetter(this: ComputedNode, next: SetterAction<any>) {\n  const value = resolveValue(next, this._value);\n  if (this._value !== value) {\n    this._value = value;\n\n    // Clear Dirty and Pending so _computedGetter skips updateComputed\n    this._flags &= ~(ReactiveFlags.Dirty | ReactiveFlags.Pending);\n\n    // Manually push the Dirty flag to all subscribers\n    let link = this._subs;\n    while (link !== undefined) {\n      const sub = link._sub;\n      const subFlags = sub._flags;\n\n      // Only modify and notify if it isn't already queued for an update\n      if ((subFlags & (ReactiveFlags.Dirty | ReactiveFlags.Pending)) === 0) {\n        // Force the node to be Dirty so it bypasses checkDirty() upon flush\n        sub._flags = subFlags | ReactiveFlags.Dirty;\n        notify(sub as EffectNode);\n      }\n\n      link = link._nextSub;\n    }\n\n    // Trigger queued effects\n    if (!batchDepth) {\n      flush();\n    }\n  }\n  return value;\n}\n\nfunction computedAccessor<T>(this: ComputedNode<T>, ...next: [SetterAction<T>]): T {\n  if (next.length) {\n    return computedSetter.call(this, next[0]) as T;\n  } else {\n    return computedGetter.call(this) as T;\n  }\n}\n\nfunction valueGetter<T>(this: ValueNode<T>): T {\n  if (this._flags & ReactiveFlags.Dirty) {\n    if (updateValue(this)) {\n      const subs = this._subs;\n      if (subs !== undefined) {\n        shallowPropagate(subs);\n      }\n    }\n  }\n  let sub = activeSub;\n  while (sub !== undefined) {\n    if (sub._flags & (ReactiveFlags.Mutable | ReactiveFlags.Watching)) {\n      link(this, sub, cycle);\n      break;\n    }\n    sub = sub._subs?._sub;\n  }\n  return this._currentValue;\n}\n\nfunction valueSetter<T>(this: ValueNode<T>, next: SetterAction<T>): void {\n  const value = resolveValue(next, this._pendingValue);\n  if (this._pendingValue !== (this._pendingValue = value)) {\n    this._flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;\n    const subs = this._subs;\n    if (subs !== undefined) {\n      propagate(subs);\n      if (!batchDepth) {\n        flush();\n      }\n    }\n  }\n}\n\nfunction valueAccessor<T>(this: ValueNode<T>, ...args: [SetterAction<T>]): T | void {\n  if (args.length) {\n    return valueSetter.call(this, args[0]);\n  } else {\n    return valueGetter.call(this) as T;\n  }\n}\n\nfunction effectCleanup(this: ReactiveNode): void {\n  this._depsTail = undefined;\n  this._flags = ReactiveFlags.None;\n  purgeDeps(this);\n  const sub = this._subs;\n  if (sub !== undefined) {\n    unlink(sub);\n  }\n  (this as EffectNode)._cleanup?.();\n  (this as EffectNode)._cleanup = undefined;\n}\n\n/*==================================*\\\n||            Public API            ||\n\\*==================================*/\n\n/**\n * Returns the currently held value. Registers the state as a dependency when called within a tracking context.\n */\nexport type Getter<T> = () => T;\n\n/**\n * A value that may be a static value or a getter function.\n * Can be converted to a plain value with `unwrap`.\n */\nexport type MaybeGetter<T> = T | Getter<T>;\n\n/**\n * Updates the value of an atom. Takes a new plain value, or an update function to compute one.\n */\nexport type Setter<T> = (next: SetterAction<T>) => T;\nexport type SetterAction<T> = T | ((prev: T) => T);\n\n/**\n * A getter and setter pair, as returned from `createAtom`.\n */\nexport type AtomAccessors<T> = [Getter<T>, Setter<T>];\n\n/**\n * Creates a new atom with a default `undefined` value.\n * Returns a `[getter, setter]` function tuple.\n *\n * @example\n * const [getValue, setValue] = createAtom();\n */\nexport function createAtom<T>(): AtomAccessors<T | undefined>;\n\n/**\n * Creates a new atom with a value computed from an existing getter.\n * This is usually used to create a 'settable' getter, in which you can store\n * a temporary value until it gets overwritten by a _real_ update.\n *\n * @example\n * const [getValue, setValue] = createAtom(\"\");\n * const [getInputValue, setInputValue] = createAtom(getValue);\n *\n * setInputValue(\"temporary\");\n * getValue(\"\");\n * getInputValue(); // \"temporary\"\n *\n * setValue(\"overwritten\");\n * getValue(\"overwritten\");\n * getInputValue(); // \"overwritten\"\n */\nexport function createAtom<T>(compute: Getter<T>): AtomAccessors<T>;\n\n/**\n * Creates a new atom with an initial value.\n * Returns a `[getter, setter]` function tuple.\n *\n * @example\n * const [getCount, setCount] = createAtom(5);\n */\nexport function createAtom<T>(initialValue: T): AtomAccessors<T>;\n\nexport function createAtom<T>(value?: T) {\n  if (isFunction<Getter<T>>(value)) {\n    const node: ComputedNode<T> = {\n      _value: undefined,\n      _subs: undefined,\n      _subsTail: undefined,\n      _deps: undefined,\n      _depsTail: undefined,\n      _flags: ReactiveFlags.None,\n      _getter: value as (previousValue?: T | undefined) => T,\n    };\n    return [computedGetter.bind(node), computedSetter.bind(node)];\n  } else {\n    const node: ValueNode<T> = {\n      _currentValue: value as T,\n      _pendingValue: value as T,\n      _subs: undefined,\n      _subsTail: undefined,\n      _flags: ReactiveFlags.Mutable,\n    };\n    return [valueGetter.bind(node), valueSetter.bind(node)];\n  }\n}\n\nexport function compose<T>(getter: (previousValue?: T) => Getter<T> | T): Getter<T> {\n  return computedGetter.bind({\n    _value: undefined,\n    _subs: undefined,\n    _subsTail: undefined,\n    _deps: undefined,\n    _depsTail: undefined,\n    _flags: ReactiveFlags.None,\n    _getter: getter as (previousValue?: unknown) => unknown,\n  }) as () => T;\n}\n\nexport function createEffect(fn: () => void): () => void {\n  const e: EffectNode = {\n    _fn: fn,\n    _cleanup: undefined,\n    _subs: undefined,\n    _subsTail: undefined,\n    _deps: undefined,\n    _depsTail: undefined,\n    _flags: ReactiveFlags.Watching | ReactiveFlags.RecursedCheck,\n  };\n  const prevSub = setActiveSub(e);\n  if (prevSub !== undefined) {\n    link(e, prevSub, 0);\n  }\n  try {\n    const result = e._fn();\n    if (isFunction(result)) e._cleanup = result;\n  } finally {\n    activeSub = prevSub;\n    e._flags &= ~ReactiveFlags.RecursedCheck;\n  }\n  return effectCleanup.bind(e);\n}\n\n/**\n * Unwraps a `MaybeGetter<T>` into a plain `T`.\n * Tracks the value if it is a getter.\n * Use the non-tracking `peek` if you're being stealthy.\n */\nexport function unwrap<T>(value: T | Getter<T>): T {\n  if (isFunction<Getter<T>>(value)) {\n    return value();\n  } else {\n    return value;\n  }\n}\n\n/**\n * Unwraps a `MaybeGetter<T>` into a plain `T`. Will _not_ track if the value is a getter.\n */\nexport function peek<T>(value: T | Getter<T>): T {\n  const prevSub = setActiveSub(undefined);\n  try {\n    return unwrap(value);\n  } finally {\n    setActiveSub(prevSub);\n  }\n}\n\n/**\n * Groups several signal changes into a single transaction.\n * Suspends effects until `callback` finishes, then runs all updates at once.\n */\nexport function batch(callback: () => void): void {\n  ++batchDepth;\n  try {\n    callback();\n  } finally {\n    if (!--batchDepth) {\n      flush();\n    }\n  }\n}\n\nexport function subscribe<T>(target: Getter<T>, fn: (value: T) => any): () => void {\n  return createEffect(() => {\n    const value = target();\n    peek(() => fn(value));\n  });\n}\n"],"mappings":"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"}