@planet-matrix/mobius-model 0.1.4 → 0.3.0

package/dist/index.js.map

@@ -1,13 +1,19 @@
 {
   "version": 3,
-  "sources": ["..\\src\\signal\\signal-core\\flags.ts", "..\\src\\signal\\signal-core\\reactive-system.ts", "..\\src\\signal\\signal-core\\primitive.ts", "..\\src\\signal\\signal-operators\\index.ts"],
+  "sources": ["..\\src\\reactor\\reactor-core\\flags.ts", "..\\src\\reactor\\reactor-core\\reactive-system.ts", "..\\src\\reactor\\reactor-core\\primitive.ts", "..\\src\\reactor\\reactor-operators\\utility.ts", "..\\src\\reactor\\reactor-operators\\convert.ts", "..\\src\\reactor\\reactor-operators\\create.ts", "..\\src\\reactor\\reactor-operators\\join.ts", "..\\src\\reactor\\reactor-operators\\branch.ts", "..\\src\\reactor\\reactor-operators\\map.ts", "..\\src\\reactor\\reactor-operators\\filter.ts"],
   "sourcesContent": [
     "export const FLAG_DICT = {\n  /**\n   * 当前节点没有任何特性。\n   */\n  None: 0,\n  /**\n   * 当前节点的值是可变的。值的变化可以通过此节点继续传递。\n   */\n  Mutable: 1,\n  /**\n   * 当前节点的值可能发生了变化，待确定。\n   */\n  Pending: 2,\n  /**\n   * 当前节点的值发生了变化。\n   */\n  Dirty: 4,\n  /**\n   * 当前节点正在进行观察。当上游节点的值发生变化时应该通知当前节点。\n   */\n  Watching: 8,\n\n  /**\n   * 当前节点正在进行依赖收集。\n   *\n   * 目前只考虑到以下用途：\n   *\n   * 1. 用于防止在某节点依赖收集过程中依赖发生变化导致该节点重复运行。\n   *    ```\n   *    const count = signal(0);\n   *    effect(() => {\n   *      count(count() + 1);\n   *    })\n   *    ```\n   */\n  Tracking: 16,\n  /**\n   * 当前节点正在进行依赖收集，且正在尝试复用现存连接。\n   */\n  TrackingReusing: 32,\n} as const;\n\nexport const hasMutable = (flags: number): boolean => {\n  return (flags & FLAG_DICT.Mutable) !== 0;\n}\nexport const setMutable = (flags?: number | undefined): number => {\n  return flags === undefined ? FLAG_DICT.Mutable : (flags | FLAG_DICT.Mutable);\n}\nexport const unsetMutable = (flags: number): number => {\n  return flags & ~FLAG_DICT.Mutable;\n}\nexport const toggleMutable = (flags: number): number => {\n  return flags ^ FLAG_DICT.Mutable;\n}\nexport const hasDirty = (flags: number): boolean => {\n  return (flags & FLAG_DICT.Dirty) !== 0;\n}\nexport const setDirty = (flags?: number | undefined): number => {\n  return flags === undefined ? FLAG_DICT.Dirty : (flags | FLAG_DICT.Dirty);\n}\nexport const unsetDirty = (flags: number): number => {\n  return flags & ~FLAG_DICT.Dirty;\n}\nexport const toggleDirty = (flags: number): number => {\n  return flags ^ FLAG_DICT.Dirty;\n}\nexport const hasPending = (flags: number): boolean => {\n  return (flags & FLAG_DICT.Pending) !== 0;\n}\nexport const setPending = (flags?: number | undefined): number => {\n  return flags === undefined ? FLAG_DICT.Pending : (flags | FLAG_DICT.Pending);\n}\nexport const unsetPending = (flags: number): number => {\n  return flags & ~FLAG_DICT.Pending;\n}\nexport const togglePending = (flags: number): number => {\n  return flags ^ FLAG_DICT.Pending;\n}\nexport const hasWatching = (flags: number): boolean => {\n  return (flags & FLAG_DICT.Watching) !== 0;\n}\nexport const setWatching = (flags?: number | undefined): number => {\n  return flags === undefined ? FLAG_DICT.Watching : (flags | FLAG_DICT.Watching);\n}\nexport const unsetWatching = (flags: number): number => {\n  return flags & ~FLAG_DICT.Watching;\n}\nexport const toggleWatching = (flags: number): number => {\n  return flags ^ FLAG_DICT.Watching;\n}\nexport const hasTracking = (flags: number): boolean => {\n  return (flags & FLAG_DICT.Tracking) !== 0;\n}\nexport const setTracking = (flags?: number | undefined): number => {\n  return flags === undefined ? FLAG_DICT.Tracking : (flags | FLAG_DICT.Tracking);\n}\nexport const unsetTracking = (flags: number): number => {\n  return flags & ~FLAG_DICT.Tracking;\n}\nexport const toggleTracking = (flags: number): number => {\n  return flags ^ FLAG_DICT.Tracking;\n}\nexport const hasTrackingReusing = (flags: number): boolean => {\n  return (flags & FLAG_DICT.TrackingReusing) !== 0;\n}\nexport const setTrackingReusing = (flags?: number): number => {\n  return flags === undefined ? FLAG_DICT.TrackingReusing : (flags | FLAG_DICT.TrackingReusing);\n}\nexport const unsetTrackingReusing = (flags: number): number => {\n  return flags & ~FLAG_DICT.TrackingReusing;\n}\nexport const toggleTrackingReusing = (flags: number): number => {\n  return flags ^ FLAG_DICT.TrackingReusing;\n}\n\nexport class Flags {\n  private flags: number;\n\n  constructor() {\n    this.flags = FLAG_DICT.None;\n  }\n\n  static clone(flags: Flags): Flags {\n    const newFlags = new Flags();\n    newFlags.set(flags.get());\n    return newFlags;\n  }\n\n  get(): number {\n    return this.flags;\n  }\n\n  set(flags: number): this {\n    this.flags = flags;\n    return this;\n  }\n\n  clear(): this {\n    this.flags = FLAG_DICT.None;\n    return this;\n  }\n\n  hasMutable(): boolean {\n    return hasMutable(this.flags);\n  }\n  setMutable(): this {\n    this.flags = setMutable(this.flags);\n    return this;\n  }\n  unsetMutable(): this {\n    this.flags = unsetMutable(this.flags);\n    return this;\n  }\n  toggleMutable(): this {\n    this.flags = toggleMutable(this.flags);\n    return this;\n  }\n\n  hasDirty(): boolean {\n    return hasDirty(this.flags);\n  }\n  setDirty(): this {\n    this.flags = setDirty(this.flags);\n    return this;\n  }\n  unsetDirty(): this {\n    this.flags = unsetDirty(this.flags);\n    return this;\n  }\n  toggleDirty(): this {\n    this.flags = toggleDirty(this.flags);\n    return this;\n  }\n\n  hasPending(): boolean {\n    return hasPending(this.flags);\n  }\n  setPending(): this {\n    this.flags = setPending(this.flags);\n    return this;\n  }\n  unsetPending(): this {\n    this.flags = unsetPending(this.flags);\n    return this;\n  }\n  togglePending(): this {\n    this.flags = togglePending(this.flags);\n    return this;\n  }\n\n  hasWatching(): boolean {\n    return hasWatching(this.flags);\n  }\n  setWatching(): this {\n    this.flags = setWatching(this.flags);\n    return this;\n  }\n  unsetWatching(): this {\n    this.flags = unsetWatching(this.flags);\n    return this;\n  }\n  toggleWatching(): this {\n    this.flags = toggleWatching(this.flags);\n    return this;\n  }\n\n  hasTracking(): boolean {\n    return hasTracking(this.flags);\n  }\n  setTracking(): this {\n    this.flags = setTracking(this.flags);\n    return this;\n  }\n  unsetTracking(): this {\n    this.flags = unsetTracking(this.flags);\n    return this;\n  }\n  toggleTracking(): this {\n    this.flags = toggleTracking(this.flags);\n    return this;\n  }\n\n  hasTrackingReusing(): boolean {\n    return hasTrackingReusing(this.flags);\n  }\n  setTrackingReusing(): this {\n    this.flags = setTrackingReusing(this.flags);\n    return this;\n  }\n  unsetTrackingReusing(): this {\n    this.flags = unsetTrackingReusing(this.flags);\n    return this;\n  }\n  toggleTrackingReusing(): this {\n    this.flags = toggleTrackingReusing(this.flags);\n    return this;\n  }\n\n  toString(): string {\n    if (this.flags === FLAG_DICT.None) {\n      return 'Flags(None)';\n    }\n\n    const activeFlags: string[] = [];\n\n    if (this.hasMutable()) {\n      activeFlags.push('Mutable')\n    };\n    if (this.hasPending()) {\n      activeFlags.push('Pending')\n    };\n    if (this.hasDirty()) {\n      activeFlags.push('Dirty')\n    };\n    if (this.hasWatching()) {\n      activeFlags.push('Watching')\n    };\n    if (this.hasTracking()) {\n      activeFlags.push('Tracking')\n    };\n    if (this.hasTrackingReusing()) {\n      activeFlags.push('TrackingReusing')\n    };\n\n    return `Flags(${activeFlags.join(' | ')})`;\n  }\n}\n\nexport const flags = (flags?: number | undefined): Flags => {\n  const f = new Flags();\n  if (flags !== undefined) {\n    f.set(flags);\n  }\n  return f;\n}\n",
-    "import type { Flags } from './flags.ts'\n\nexport interface Node {\n  /**\n   * 当前节点的上游连接链中的第一个连接。\n   */\n  headDepLink?: Link | undefined;\n  /**\n   * 当前节点的上游连接链中的最后一个连接。\n   */\n  tailDepLink?: Link | undefined;\n\n  /**\n   * 当前节点的下游连接链中的第一个连接。\n   */\n  headSubLink?: Link | undefined;\n  /**\n   * 当前节点的下游连接链中的最后一个连接。\n   */\n  tailSubLink?: Link | undefined;\n\n  /**\n   * 当前节点的标记。\n   */\n  flags: Flags;\n}\n/**\n * 连接用于表示某个节点（下游节点）依赖了某个节点（上游节点）。\n *\n * 多个连接连在一起形成连接链，连接链只有两种情况：\n *\n * 1. 下游连接链：链中所有连接的上游节点相同，通过该链可以找到该上游节点的所有下游节点。\n * 2. 上游连接链：链中所有连接的下游节点相同，通过该链可以找到该下游节点的所有上游节点。\n */\nexport interface Link {\n  /**\n   * 连接中的上游节点。\n   */\n  dep: Node;\n  /**\n   * 连接中的上游节点的下游连接链中的上一个连接。（下一个下游连接）\n   */\n  prevSubLink?: Link | undefined;\n  /**\n   * 连接中的上游节点的下游连接链中的下一个连接。（上一个下游连接）\n   */\n  nextSubLink?: Link | undefined;\n\n  /**\n   * 连接中的下游节点。\n   */\n  sub: Node;\n  /**\n   * 连接中的下游节点的上游连接链中的上一个连接。（上一个上游连接）\n   */\n  prevDepLink?: Link | undefined;\n  /**\n   * 连接中的下游节点的上游连接链中的下一个连接。（下一个上游连接）\n   */\n  nextDepLink?: Link | undefined;\n}\n\nexport interface CreateReactiveSystemOptions {\n  /**\n   * 当节点的值需要更新时此回调会执行，返回值表示更新前后值是否变化。\n   */\n  update(sub: Node): boolean;\n  /**\n   * 当节点的上游节点的值发生变化后此回调会执行。\n   *\n   * 注意：只有包含 Watching 标记的节点会触发此方法。\n   */\n  notify(node: Node): void;\n  /**\n   * 当节点不再拥有任何下游节点时此回调会执行。\n   */\n  unwatched(node: Node): void;\n}\nexport interface ReactiveSystem {\n  /**\n   * 判断连接是否是节点的上游连接。\n   */\n  isDepLinkOfNode(link: Link, node: Node): boolean;\n  /**\n   * 判断连接是否是节点的下游连接。\n   */\n  isSubLinkOfNode(link: Link, node: Node): boolean;\n  /**\n   * 获取两个节点之间的连接。\n   */\n  getLinkOfNodes(dep: Node, sub: Node): Link | undefined;\n  /**\n   * 判断两个节点之间是否存在连接。\n   */\n  isLinked(nodeA: Node, nodeB: Node): boolean;\n  /**\n   * 为两个节点建立连接。\n   */\n  linkNode(dep: Node, sub: Node): void;\n  /**\n   * 为两个节点解除连接。\n   */\n  unlinkNode(nodeA: Node, nodeB: Node): void;\n  /**\n   * 解除连接。\n   */\n  unlink(link: Link): void;\n  /**\n   * 为节点解除所有上游连接。\n   */\n  unlinkAllDepLinksOfNode(node: Node): void;\n  /**\n   * 为节点解除所有下游连接。\n   */\n  unlinkAllSubLinksOfNode(node: Node): void;\n\n\n  /**\n   * 获取当前正在进行依赖收集的节点。\n   */\n  getActiveNodeAsSub(): Node | undefined;\n  /**\n   * 设置当前正在进行依赖收集的节点。\n   */\n  setActiveNodeAsSub(nodeAsSub: Node): void;\n  /**\n   * 重置当前正在进行依赖收集的节点。\n   */\n  resetActiveNodeAsSub(): void;\n  /**\n   * 将指定节点作为当前正在进行依赖收集的节点执行指定函数。\n   */\n  withActiveNodeAsSub<T>(nodeAsSub: Node, fn: () => T): T;\n  /**\n   * 开始对节点（作为下游节点）进行依赖收集。\n   */\n  startTracking(node: Node): void;\n  /**\n   * 结束对节点（作为下游节点）进行依赖收集。\n   */\n  endTracking(node: Node): void;\n  /**\n   * 对节点（作为下游节点）进行依赖收集。\n   */\n  withTracking<T>(node: Node, fn: () => T): T;\n  /**\n   * 为两个节点建立连接（依赖收集优化版）。\n   */\n  linkNodeOptimizedForTracking(dep: Node, sub: Node): void;\n  /**\n   * 将节点作为当前正在进行依赖收集的节点的上游节点。\n   */\n  track(node: Node): void;\n\n  /**\n   * 当节点的值发生变化后，调用此方法更新直接下游节点的标记。\n   */\n  shallowPropagate(node: Node): void;\n  /**\n   * 当节点的值发生变化后，调用此方法更新所有下游节点的标记。\n   */\n  deeeeepPropagate(node: Node): void;\n  /**\n   * 解决节点的 Pending 标记。\n   */\n  resolvePending(node: Node): void;\n}\nexport const createReactiveSystem = (options: CreateReactiveSystemOptions): ReactiveSystem => {\n  const { update, notify, unwatched } = options;\n\n  const isDepLinkOfNode = (link: Link, node: Node): boolean => {\n    let tailDepLinkOfNode = node.tailDepLink;\n    while (tailDepLinkOfNode !== undefined) {\n      if (tailDepLinkOfNode === link) {\n        return true;\n      }\n      tailDepLinkOfNode = tailDepLinkOfNode.prevDepLink;\n    }\n    return false;\n  }\n\n  const isSubLinkOfNode = (link: Link, node: Node): boolean => {\n    let tailSubLinkOfNode = node.tailSubLink;\n    while (tailSubLinkOfNode !== undefined) {\n      if (tailSubLinkOfNode === link) {\n        return true;\n      }\n      tailSubLinkOfNode = tailSubLinkOfNode.prevSubLink;\n    }\n    return false;\n  }\n\n  const getLinkOfNodes = (dep: Node, sub: Node): Link | undefined => {\n    let subToCheck = dep.tailSubLink;\n    while (subToCheck !== undefined) {\n      if (subToCheck.sub === sub) {\n        return subToCheck;\n      }\n      subToCheck = subToCheck.prevSubLink;\n    }\n    return undefined;\n  }\n\n  const isLinked = (nodeA: Node, nodeB: Node): boolean => {\n    const aIsDepOfB = getLinkOfNodes(nodeA, nodeB) !== undefined;\n    if (aIsDepOfB === true) {\n      return true;\n    }\n    const bIsDepOfA = getLinkOfNodes(nodeB, nodeA) !== undefined;\n    if (bIsDepOfA === true) {\n      return true;\n    }\n    return false;\n  }\n\n  const linkNode = (dep: Node, sub: Node): void => {\n    /**\n     * 检查是否存在重复连接。\n     */\n    const isLinked = getLinkOfNodes(dep, sub) !== undefined;\n    if (isLinked === true) {\n      return;\n    }\n\n    /**\n     * 建立新连接。\n     */\n    const newLink: Link = {\n      dep,\n      prevSubLink: undefined,\n      nextSubLink: undefined,\n\n      sub,\n      prevDepLink: undefined,\n      nextDepLink: undefined,\n    };\n\n    const tailDepLinkOfSub = sub.tailDepLink;\n    if (tailDepLinkOfSub !== undefined) {\n      tailDepLinkOfSub.nextDepLink = newLink;\n      newLink.prevDepLink = tailDepLinkOfSub;\n    } else {\n      sub.headDepLink = newLink;\n    }\n    sub.tailDepLink = newLink;\n\n    const tailSubLinkOfDep = dep.tailSubLink;\n    if (tailSubLinkOfDep !== undefined) {\n      tailSubLinkOfDep.nextSubLink = newLink;\n      newLink.prevSubLink = tailSubLinkOfDep;\n    } else {\n      dep.headSubLink = newLink;\n    }\n    dep.tailSubLink = newLink;\n  }\n\n  const unlinkNode = (nodeA: Node, nodeB: Node): void => {\n    const linkAB = getLinkOfNodes(nodeA, nodeB);\n    if (linkAB !== undefined) {\n      unlink(linkAB);\n    }\n    const linkBA = getLinkOfNodes(nodeB, nodeA);\n    if (linkBA !== undefined) {\n      unlink(linkBA);\n    }\n  }\n\n  const unlink = (link: Link): void => {\n    const prevDepLink = link.prevDepLink;\n    const dep = link.dep;\n    const nextDepLink = link.nextDepLink;\n    const prevSubLink = link.prevSubLink;\n    const sub = link.sub;\n    const nextSubLink = link.nextSubLink;\n\n    /**\n     * 处理上游连接链。\n     */\n\n    if (nextDepLink !== undefined) {\n      // 如果当前连接的下一个连接存在，则将当前连接的下一个连接的上一个连接指向当前连接的上一个连接\n      nextDepLink.prevDepLink = prevDepLink;\n    } else {\n      // 如果当前连接的下一个连接不存在，则将当前连接的上一个连接作为最后一个连接\n      sub.tailDepLink = prevDepLink;\n    }\n    if (prevDepLink !== undefined) {\n      // 如果当前连接的上一个连接存在，则将当前连接的上一个连接的下一个连接指向当前连接的下一个连接\n      prevDepLink.nextDepLink = nextDepLink;\n    } else {\n      // 如果当前连接的上一个连接不存在，则将当前连接的下一个连接作为第一个连接\n      sub.headDepLink = nextDepLink;\n    }\n\n    /**\n     * 处理下游连接链。\n     */\n\n    if (nextSubLink !== undefined) {\n      // 如果当前连接的下一个连接存在，则将当前连接的下一个连接的上一个连接指向当前连接的上一个连接\n      nextSubLink.prevSubLink = prevSubLink;\n    } else {\n      // 如果当前连接的下一个连接不存在，则将当前连接的上一个连接作为最后一个连接\n      dep.tailSubLink = prevSubLink;\n    }\n    if (prevSubLink !== undefined) {\n      // 如果当前连接的上一个连接存在，则将当前连接的上一个连接的下一个连接指向当前连接的下一个连接\n      prevSubLink.nextSubLink = nextSubLink;\n    } else {\n      // 如果当前连接的上一个连接不存在，则将当前连接的下一个连接作为第一个连接\n      dep.headSubLink = nextSubLink;\n    }\n\n    /**\n     * 处理完连接链之后，检查当前连接中的上游节点是否还有下游节点。\n     *\n     * - 如果有：什么都不做。\n     * - 如果没有：触发回调。\n     */\n    if (dep.headSubLink === undefined && dep.tailSubLink === undefined) {\n      unwatched(dep);\n    }\n\n    /**\n     * 彻底断引用，防止内存泄漏。\n     */\n    link.prevDepLink = undefined;\n    // oxlint-disable-next-line no-unsafe-type-assertion\n    link.dep = undefined as unknown as Node; // type cast\n    link.nextDepLink = undefined;\n    link.prevSubLink = undefined;\n    // oxlint-disable-next-line no-unsafe-type-assertion\n    link.sub = undefined as unknown as Node; // type cast\n    link.nextSubLink = undefined;\n  }\n\n  const unlinkAllDepLinksOfNode = (node: Node): void => {\n    let currentDepLink = node.headDepLink;\n    while (currentDepLink !== undefined) {\n      const nextDepLink = currentDepLink.nextDepLink;\n      unlink(currentDepLink);\n      currentDepLink = nextDepLink;\n    }\n  }\n\n  const unlinkAllSubLinksOfNode = (node: Node): void => {\n    let currentSubLink = node.headSubLink;\n    while (currentSubLink !== undefined) {\n      const nextSubLink = currentSubLink.nextSubLink;\n      unlink(currentSubLink);\n      currentSubLink = nextSubLink;\n    }\n  }\n\n  let prevActiveNodeAsSubStack: Array<Node | undefined> = [];\n  let activeNodeAsSub: Node | undefined = undefined;\n  const getActiveNodeAsSub = (): Node | undefined => {\n    return activeNodeAsSub;\n  }\n  const setActiveNodeAsSub = (nodeAsSub: Node): void => {\n    prevActiveNodeAsSubStack.push(activeNodeAsSub);\n    activeNodeAsSub = nodeAsSub;\n  }\n  const resetActiveNodeAsSub = (): void => {\n    activeNodeAsSub = prevActiveNodeAsSubStack.pop();\n  }\n  const withActiveNodeAsSub = <T>(nodeAsSub: Node, fn: () => T): T => {\n    setActiveNodeAsSub(nodeAsSub);\n    try {\n      return fn();\n    } finally {\n      resetActiveNodeAsSub();\n    }\n  }\n\n  const startTracking = (nodeAsSub: Node): void => {\n    setActiveNodeAsSub(nodeAsSub);\n\n    const flags = nodeAsSub.flags;\n    flags.unsetPending().unsetDirty().setTracking();\n  }\n  const endTracking = (nodeAsSub: Node): void => {\n    const flags = nodeAsSub.flags;\n    if (flags.hasTrackingReusing() === true) {\n      const firstRedundantDepLink = nodeAsSub?.tailDepLink?.nextDepLink;\n      if (firstRedundantDepLink !== undefined) {\n        let toRemove: Link | undefined = firstRedundantDepLink;\n        while (toRemove !== undefined) {\n          const nextToRemove: Link | undefined = toRemove.nextDepLink;\n          unlink(toRemove);\n          toRemove = nextToRemove;\n        }\n      }\n    }\n    flags.unsetTrackingReusing().unsetTracking();\n\n    resetActiveNodeAsSub();\n  }\n  const withTracking = <T>(node: Node, fn: () => T): T => {\n    startTracking(node);\n    try {\n      return fn();\n    } finally {\n      endTracking(node);\n    }\n  }\n  /**\n   * 依赖收集的目标是：在完成一次依赖收集之后，对于所有在依赖收集执行过程中被访问过的节点（上游节点），\n   * 都与进行依赖收集的节点（下游节点）建立且仅建立一个连接。\n   */\n  const linkNodeOptimizedForTracking = (dep: Node, sub: Node): void => {\n    let existingDepLinkToCompare: Link | undefined;\n\n    const subFlags = sub.flags;\n    if (subFlags.hasTracking() === true && subFlags.hasTrackingReusing() === false) {\n      subFlags.setTrackingReusing();\n      sub.tailDepLink = sub.headDepLink;\n      existingDepLinkToCompare = sub.tailDepLink\n    } else {\n      existingDepLinkToCompare = sub.tailDepLink?.nextDepLink;\n    }\n\n    /**\n     * 检查是否可以复用现存连接。\n     */\n    if (existingDepLinkToCompare !== undefined && existingDepLinkToCompare.dep === dep) {\n      return;\n    }\n\n    linkNode(dep, sub);\n  }\n  const track = (node: Node): void => {\n    const activeNodeAsSub = getActiveNodeAsSub();\n    if (activeNodeAsSub !== undefined) {\n      linkNodeOptimizedForTracking(node, activeNodeAsSub);\n    }\n  }\n\n  const shallowPropagate = (node: Node): void => {\n    // 从头到尾遍历目标节点下游连接链中的所有下游节点，更新其标记。\n\n    let currentSubLink: Link | undefined = node.headSubLink;\n    while (currentSubLink !== undefined) {\n      const sub = currentSubLink.sub;\n      const flags = sub.flags;\n      let isChangeToDirty = false;\n\n      if (flags.hasPending() === true && flags.hasDirty() === false) {\n        // 如果包含 Pending 标记，且不包含 Dirty 标记，为其添加 Dirty 标记，移除 Pending 标记\n        flags.setDirty().unsetPending();\n        isChangeToDirty = true;\n      } else {\n        // 如果是其它情况，则处理下一个连接\n        currentSubLink = currentSubLink.nextSubLink;\n        continue;\n      }\n\n      if (isChangeToDirty === true) {\n        // 如果检查过程中被标记为 Dirty，则酌情触发 notify 回调\n        const shouldNotify = flags.hasWatching() === true && flags.hasTracking() === false;\n        if (shouldNotify === true) {\n          notify(sub);\n        }\n      }\n\n      // 当前连接处理完成，处理下一个连接\n      currentSubLink = currentSubLink.nextSubLink;\n    }\n  }\n\n  interface InternalStack<T> {\n    value: T;\n    prev: InternalStack<T> | undefined;\n  }\n\n  const deeeeepPropagate = (node: Node): void => {\n    let currentSubLink = node.headSubLink;\n    let nextSubLink = currentSubLink?.nextSubLink;\n    let unhandledSubLinkStack: InternalStack<Link | undefined> | undefined = undefined;\n\n    while (currentSubLink !== undefined) {\n      const sub = currentSubLink.sub;\n\n      let flags = sub.flags;\n      let shouldNotify = flags.hasWatching();\n      let shouldDownward = flags.hasMutable();\n\n      if (flags.hasTracking() === false && flags.hasDirty() === false && flags.hasPending() === false) {\n        /**\n         * 进入此分支的 flags：\n         *  1. 不包含 Tracking 标记。\n         *  2. 不包含 Dirty 标记或 Pending 标记。\n         *\n         * 说明：上游节点的变更首次传递到该节点。\n         *\n         * 此时，添加 Pending 标记，根据其它标记决定是否需要 Notify，根据其它标记决定是否需要 Downward。\n         */\n        flags.setPending();\n        // shouldNotify = shouldNotify;\n        // shouldDownward = shouldDownward;\n      } else if (flags.hasTracking() === false) {\n        /**\n         * 进入此分支的 flags：\n         *  1. 不包含 Tracking 标记。\n         *  2. 包含 Dirty 标记或 Pending 标记。\n         *\n         * 说明：上游节点的变更已经传递到该节点。\n         *\n         * 此时，什么都不做，不需要修改标记，不需要 Notify，不需要 Downward。\n         */\n        // flags = flags;\n        shouldNotify = false;\n        shouldDownward = false;\n      } else if (flags.hasDirty() === false && flags.hasPending() === false) {\n        /**\n         * 进入此分支的 flags：\n         *  1. 包含 Tracking 标记。\n         *  2. 不包含 Dirty 标记或 Pending 标记。\n         *\n         * 说明：上游节点的变更首次传递到该节点，且该节点正在进行依赖收集。\n         *\n         * 此时，添加 Pending 标记，不需要 Notify，根据其它标记决定是否需要 Downward。\n         */\n        flags.setPending();\n        shouldNotify = false;\n        // shouldDownward = shouldDownward;\n      } else {\n        /**\n         * 进入此分支的 flags：\n         *  1. 包含 Tracking 标记。\n         *  2. 包含 Dirty 标记或 Pending 标记。\n         *\n         * 说明：上游节点的变更已经传递到该节点，且该节点正在进行依赖收集。\n         *\n         * 此时，不需要修改标记，不需要 Notify，不需要 Downward。\n         */\n        // flags = flags;\n        shouldNotify = false;\n        shouldDownward = false;\n      }\n\n      if (shouldNotify === true) {\n        notify(sub);\n      }\n\n      if (shouldDownward === true) {\n        const headSubLinkOfSub = sub.headSubLink;\n        if (headSubLinkOfSub !== undefined) {\n          currentSubLink = headSubLinkOfSub;\n          const nextSubLinkOfSub = headSubLinkOfSub.nextSubLink;\n          if (nextSubLinkOfSub !== undefined) {\n            unhandledSubLinkStack = { value: nextSubLink, prev: unhandledSubLinkStack };\n            nextSubLink = nextSubLinkOfSub;\n          }\n          continue;\n        }\n      }\n\n      currentSubLink = nextSubLink\n      if (currentSubLink !== undefined) {\n        nextSubLink = currentSubLink.nextSubLink;\n        continue;\n      }\n\n      if (unhandledSubLinkStack !== undefined) {\n        currentSubLink = unhandledSubLinkStack.value;\n        unhandledSubLinkStack = unhandledSubLinkStack.prev;\n        if (currentSubLink !== undefined) {\n          nextSubLink = currentSubLink.nextSubLink;\n        }\n      }\n    }\n  }\n\n  const resolvePending = (node: Node): void => {\n    let currentDepLink = node.headDepLink;\n    let unhandledDepLinkStack: InternalStack<Link> | undefined = undefined;\n\n    while (currentDepLink !== undefined) {\n      const currentSub: Node = currentDepLink.sub;\n      const currentDep: Node = currentDepLink.dep;\n      const subFlags = currentSub.flags;\n      const depFlags = currentDep.flags;\n\n      if (depFlags.hasMutable() === true && depFlags.hasDirty() === true) {\n        /**\n         * 当前下游节点不包含 Dirty 标记，当前上游节点包含 Dirty 标记。\n         *\n         * 更新当前上游节点，若值有变化，则将状态向直接下游节点传播。\n         */\n        const valueChanged = update(currentDep);\n        if (valueChanged === true) {\n          shallowPropagate(currentDep);\n        }\n      } else if (depFlags.hasMutable() === true && depFlags.hasPending() === true) {\n        /**\n         * 当前下游节点不包含 Dirty 标记，当前上游节点包含 Pending 标记。\n         *\n         * 继续检查当前上游节点的上游节点。\n         */\n        unhandledDepLinkStack = { value: currentDepLink, prev: unhandledDepLinkStack };\n        currentDepLink = currentDep.headDepLink;\n        continue;\n      }\n\n      if (subFlags.hasPending() === true) {\n        const nextDepLink = currentDepLink.nextDepLink;\n        if (nextDepLink !== undefined) {\n          currentDepLink = nextDepLink;\n          continue;\n        }\n      }\n\n      if (unhandledDepLinkStack !== undefined) {\n        currentDepLink = unhandledDepLinkStack.value;\n        unhandledDepLinkStack = unhandledDepLinkStack.prev;\n\n        /**\n         * 当一个连接先被存起来，后续又被取出来处理时，说明其所有上游节点都已经处理完成，\n         * 因此可以将其 Pending 标记移除。\n         */\n        currentDepLink.dep.flags.unsetPending();\n      } else {\n        /**\n         * 所有连接都处理完成，可以安全移除当前连接的下游节点的 Pending 标记。\n         */\n        currentDepLink.sub.flags.unsetPending();\n        break;\n      }\n    }\n  }\n\n  return {\n    isDepLinkOfNode,\n    isSubLinkOfNode,\n    getLinkOfNodes,\n    isLinked,\n    linkNode,\n    unlinkNode,\n    unlink,\n    unlinkAllDepLinksOfNode,\n    unlinkAllSubLinksOfNode,\n\n    getActiveNodeAsSub,\n    setActiveNodeAsSub,\n    resetActiveNodeAsSub,\n    withActiveNodeAsSub,\n    startTracking,\n    endTracking,\n    withTracking,\n    linkNodeOptimizedForTracking,\n    track,\n\n    shallowPropagate,\n    deeeeepPropagate,\n    resolvePending,\n  };\n}\n",
-    "import type { Flags } from \"./flags.ts\"\nimport { createReactiveSystem } from \"./reactive-system.ts\"\nimport { flags } from \"./flags.ts\"\nimport type { Link, Node } from \"./reactive-system.ts\"\n\nconst VOID = Symbol(\"void\") as unknown;\n\nconst queue: Effect[] = [];\nconst flush = (): void => {\n  while (queue.length !== 0) {\n    queue.shift()!.run();\n  }\n}\n\nlet batchDepth = 0;\nexport const startBatch = (): void => {\n  batchDepth = batchDepth + 1;\n}\nexport const endBatch = (): void => {\n  batchDepth = batchDepth - 1;\n  if (batchDepth === 0) {\n    flush();\n  }\n}\n\nconst reactiveSystem = createReactiveSystem({\n  update(node: Signal | Computed) {\n    return node.update();\n  },\n  notify(node: Effect) {\n    const nodes = []\n    let currentNode: Effect | undefined = node\n    while (currentNode !== undefined) {\n      if (currentNode.flags.hasWatching() === false) {\n        break\n      }\n      node.notify();\n      nodes.push(currentNode);\n      const nextNode: Node | undefined = currentNode?.headSubLink?.sub\n      currentNode = nextNode instanceof Effect ? nextNode : undefined\n    }\n    queue.push(...nodes.toReversed());\n  },\n  unwatched(node: Signal | Computed | Effect) {\n    return node.stop();\n  }\n});\nconst {\n  unlinkAllDepLinksOfNode,\n\n  withTracking,\n  track,\n\n  shallowPropagate,\n  deeeeepPropagate,\n  resolvePending,\n} = reactiveSystem\n\n/**\n * Signal 的值只有在被获取的时候才会更新。\n */\nexport class Signal<T = unknown> implements Node {\n  headSubLink: Link | undefined;\n  tailSubLink: Link | undefined;\n  flags: Flags;\n\n  value: T;\n  pendingValue: T;\n\n  constructor(value: T) {\n    this.headSubLink = undefined;\n    this.tailSubLink = undefined;\n    this.flags = flags().setMutable();\n\n    this.pendingValue = value;\n    this.value = value;\n  }\n\n  get(): T {\n    let valueChanged = false\n\n    // 如果包含 Dirty 标记，则进行更新\n    const shouldUpdate = this.flags.hasDirty();\n    if (shouldUpdate === true) {\n      valueChanged = this.update()\n    }\n\n    // 如果值发生变化，则更新直接下游节点的标记\n    if (valueChanged === true) {\n      shallowPropagate(this);\n    }\n\n    // 自动进行依赖收集\n    track(this);\n\n    return this.value;\n  }\n\n  set(value: T): void {\n    // 将新值暂存起来，等用到的时候再执行更新\n    this.pendingValue = value;\n    // 为当前节点添加 Dirty 标记\n    this.flags.setDirty();\n\n    // 更新所有下游节点的标记\n    deeeeepPropagate(this);\n\n    // 执行更新队列\n    if (batchDepth === 0) {\n      flush();\n    }\n  }\n\n  /**\n   * 返回值表示更新前后值是否变化。\n   */\n  update(): boolean {\n    this.flags.unsetDirty();\n\n    const oldValue = this.value;\n    const newValue = this.pendingValue;\n    this.value = newValue;\n\n    return oldValue !== newValue;\n  }\n\n  stop(): void {\n    // do nothing\n  }\n}\n\n/**\n * Computed 的值只有在被获取的时候才会更新。\n * Computed 的值只有在上游节点的值发生变化时才会更新。\n * Computed 的下游节点全部解除连接时会自动与所有上游节点解除连接，并回到初始状态。\n */\nexport class Computed<T = unknown> implements Node {\n  headDepLink: Link | undefined;\n  tailDepLink: Link | undefined;\n  headSubLink: Link | undefined;\n  tailSubLink: Link | undefined;\n  flags: Flags;\n\n  value: T;\n  getValue: () => T;\n\n  constructor(getValue: () => T) {\n    this.headDepLink = undefined;\n    this.tailDepLink = undefined;\n    this.headSubLink = undefined;\n    this.tailSubLink = undefined;\n    // 值在创建时尚未计算，因此初始时添加 Dirty 标记\n    this.flags = flags().setMutable().setDirty();\n\n    // undefined 可能是使用者期待的合法值，因此这里使用 VOID 占位\n    // oxlint-disable-next-line no-unsafe-type-assertion\n    this.value = VOID as T;\n    this.getValue = getValue;\n  }\n\n  get(): T {\n    let valueChanged = false;\n\n    // 如果包含 Pending 标记，则进行解决\n    const shouldResolve = this.flags.hasPending();\n    if (shouldResolve === true) {\n      resolvePending(this);\n    }\n\n    // 如果包含 Dirty 标记，则进行更新\n    const shouldUpdate = this.flags.hasDirty();\n    if (shouldUpdate === true) {\n      valueChanged = this.update()\n    }\n\n    // 如果值变化，则通知下游（仅通知直接下游）\n    if (valueChanged === true) {\n      shallowPropagate(this);\n    }\n\n    // 自动进行依赖收集\n    track(this);\n\n    return this.value;\n  }\n\n  /**\n   * 返回值表示更新前后值是否变化。\n   */\n  update(): boolean {\n    const result = withTracking(this, () => {\n      const oldValue = this.value;\n      const newValue = this.getValue();\n      this.value = newValue;\n      return oldValue !== newValue;\n    })\n    return result;\n  }\n\n  stop(): void {\n    unlinkAllDepLinksOfNode(this);\n    this.flags = flags().setMutable().setDirty();\n  }\n}\n\n/**\n * Effect 会在创建时立即执行一次传入的函数。\n * Effect 会在每次上游节点的值发生变化时重新执行传入的函数。\n * Effect 在任意时刻最多只能一个待运行。\n * Effect 可以与 Effect 建立连接。\n * 作为上游节点的 Effect 在没有下游节点时会自动与所有上游节点解除连接，并将标记清空。\n */\nexport class Effect implements Node {\n  headDepLink: Link | undefined;\n  tailDepLink: Link | undefined;\n  headSubLink: Link | undefined;\n  tailSubLink: Link | undefined;\n  flags: Flags;\n\n  fn: () => void;\n\n  constructor(fn: () => void) {\n    this.headDepLink = undefined;\n    this.tailDepLink = undefined;\n    this.headSubLink = undefined;\n    this.tailSubLink = undefined;\n    // 在创建完成后即进入观察状态，因此初始时添加 Watching 标记\n    this.flags = flags().setWatching();\n\n    this.fn = fn;\n    this.internalRun();\n  }\n\n  notify(): void {\n    this.flags.unsetWatching();\n  }\n\n  run(): void {\n    this.flags.setWatching();\n\n    // 如果包含 Pending 标记，则进行解决\n    const shouldResolve = this.flags.hasPending();\n    if (shouldResolve === true) {\n      resolvePending(this);\n    }\n\n    // 如果包含 Dirty 标记，则进行更新\n    const shouldRun = this.flags.hasDirty();\n    if (shouldRun === true) {\n      this.internalRun();\n    }\n  }\n\n  private internalRun(): void {\n    track(this);\n    withTracking(this, () => {\n      return this.fn();\n    })\n  }\n\n  stop(): void {\n    unlinkAllDepLinksOfNode(this);\n    this.flags.clear();\n  }\n}\n\nexport const signal = <T>(initialValue: T): Signal<T> => {\n  return new Signal(initialValue);\n}\nexport const computed = <T>(getter: () => T): Computed<T> => {\n  return new Computed<T>(getter);\n}\nexport const effect = (fn: () => void): Effect => {\n  return new Effect(fn);\n}\n",
-    "import type { Signal } from \"#Source/index.ts\"\nimport { effect, signal } from \"#Source/index.ts\"\n\nexport const withHistory = <T>(orginal: Signal<T>): Signal<T[]> => {\n  const history: T[] = []\n  effect(() => {\n    history.push(orginal.get())\n  })\n  const result = signal<T[]>(history)\n  return result\n}\n\nexport const zip = <T, U>(signal1: Signal<T>, signal2: Signal<U>): Signal<[T, U]> => {\n  const result = signal<[T, U]>([signal1.get(), signal2.get()])\n  effect(() => {\n    result.set([signal1.get(), signal2.get()])\n  })\n  return result\n}\n"
+    "import type { Flags } from './flags.ts'\n\nexport interface Node {\n  /**\n   * 当前节点的上游连接链中的第一个连接。\n   */\n  headDepLink?: Link | undefined;\n  /**\n   * 当前节点的上游连接链中的最后一个连接。\n   */\n  tailDepLink?: Link | undefined;\n\n  /**\n   * 当前节点的下游连接链中的第一个连接。\n   */\n  headSubLink?: Link | undefined;\n  /**\n   * 当前节点的下游连接链中的最后一个连接。\n   */\n  tailSubLink?: Link | undefined;\n\n  /**\n   * 当前节点的标记。\n   */\n  flags: Flags;\n}\n/**\n * 连接用于表示某个节点（下游节点）依赖了某个节点（上游节点）。\n *\n * 多个连接连在一起形成连接链，连接链只有两种情况：\n *\n * 1. 下游连接链：链中所有连接的上游节点相同，通过该链可以找到该上游节点的所有下游节点。\n * 2. 上游连接链：链中所有连接的下游节点相同，通过该链可以找到该下游节点的所有上游节点。\n */\nexport interface Link {\n  /**\n   * 连接中的上游节点。\n   */\n  dep: Node;\n  /**\n   * 连接中的上游节点的下游连接链中的上一个连接。（上一个下游连接）\n   */\n  prevSubLink?: Link | undefined;\n  /**\n   * 连接中的上游节点的下游连接链中的下一个连接。（下一个下游连接）\n   */\n  nextSubLink?: Link | undefined;\n\n  /**\n   * 连接中的下游节点。\n   */\n  sub: Node;\n  /**\n   * 连接中的下游节点的上游连接链中的上一个连接。（上一个上游连接）\n   */\n  prevDepLink?: Link | undefined;\n  /**\n   * 连接中的下游节点的上游连接链中的下一个连接。（下一个上游连接）\n   */\n  nextDepLink?: Link | undefined;\n}\n\nexport interface CreateReactiveSystemOptions {\n  /**\n   * 当节点的上游节点发生变化时此回调会执行。\n   */\n  onDepChanged?: (sub: Node) => void;\n  /**\n   * 当节点的下游节点发生变化时此回调会执行。\n   */\n  onSubChanged?: (dep: Node) => void;\n  /**\n   * 当节点拥有第一个上游节点时此回调会执行。\n   */\n  onHasDep?: (sub: Node, dep: Node) => void;\n  /**\n   * 当节点不再拥有任何上游节点时此回调会执行。\n   */\n  onNoDep?: (sub: Node, dep: Node) => void;\n  /**\n   * 当节点拥有第一个下游节点时此回调会执行。\n   */\n  onHasSub?: (dep: Node, sub: Node) => void;\n  /**\n   * 当节点不再拥有任何下游节点时此回调会执行。\n   */\n  onNoSub?: (dep: Node, sub: Node) => void;\n\n  /**\n   * 当节点的值需要更新时此回调会执行，返回值表示更新前后值是否变化。\n   */\n  update(sub: Node): boolean;\n  /**\n   * 当节点的上游节点的值发生变化后此回调会执行。\n   *\n   * 注意：只有包含 Watching 标记的节点会触发此方法。\n   */\n  notify(node: Node): void;\n}\nexport interface ReactiveSystem {\n  /**\n   * 获取节点的上游连接。\n   */\n  getDepLinksOfNode(node: Node): Link[];\n  /**\n   * 获取节点的下游连接。\n   */\n  getSubLinksOfNode(node: Node): Link[];\n  /**\n   * 获取节点的上游节点。\n   */\n  getDepsOfNode(node: Node): Node[];\n  /**\n   * 获取节点的下游节点。\n   */\n  getSubsOfNode(node: Node): Node[];\n  /**\n   * 判断连接是否是节点的上游连接。\n   */\n  isDepLinkOfNode(link: Link, node: Node): boolean;\n  /**\n   * 判断连接是否是节点的下游连接。\n   */\n  isSubLinkOfNode(link: Link, node: Node): boolean;\n  /**\n   * 判断节点是否是目标节点的上游节点。\n   */\n  isDepOfNode(node: Node, targetNode: Node): boolean;\n  /**\n   * 判断节点是否是目标节点的下游节点。\n   */\n  isSubOfNode(node: Node, targetNode: Node): boolean;\n  /**\n   * 获取两个节点之间的连接（从上游节点的下游连接链中查找）。\n   */\n  getLinkBetweenFromDep(dep: Node, sub: Node): Link | undefined;\n  /**\n   * 获取两个节点之间的连接（从下游节点的上游连接链中查找）。\n   */\n  getLinkBetweenFromSub(dep: Node, sub: Node): Link | undefined;\n  /**\n   * 判断两个节点之间是否存在连接（从上游节点的下游连接链中查找）。\n   */\n  hasLinkBetweenFromDep(dep: Node, sub: Node): boolean;\n  /**\n   * 判断两个节点之间是否存在连接（从下游节点的上游连接链中查找）。\n   */\n  hasLinkBetweenFromSub(dep: Node, sub: Node): boolean;\n  /**\n   * 为两个节点建立连接。\n   */\n  addLinkBetween(dep: Node, sub: Node): Link;\n  /**\n   * 为两个节点移除连接（从上游节点的下游连接链中查找）。\n   */\n  removeLinkBetweenFromDep(dep: Node, sub: Node): void;\n  /**\n   * 为两个节点移除连接（从下游节点的上游连接链中查找）。\n   */\n  removeLinkBetweenFromSub(dep: Node, sub: Node): void;\n  /**\n   * 移除连接。\n   */\n  removeLink(link: Link): void;\n  /**\n   * 为节点移除所有上游连接。\n   */\n  removeAllDepLinksOfNode(node: Node): Node[];\n  /**\n   * 为节点移除所有下游连接。\n   */\n  removeAllSubLinksOfNode(node: Node): Node[];\n\n  /**\n   * 获取当前正在进行依赖收集的节点。\n   */\n  getActiveNodeAsSub(): Node | undefined;\n  /**\n   * 设置当前正在进行依赖收集的节点。\n   */\n  setActiveNodeAsSub(nodeAsSub: Node | undefined): void;\n  /**\n   * 设置当前正在进行依赖收集的节点为空。\n   */\n  setNoActiveNodeAsSub(): undefined;\n  /**\n   * 重置当前正在进行依赖收集的节点。\n   */\n  resetActiveNodeAsSub(): void;\n  /**\n   * 将指定节点作为当前正在进行依赖收集的节点执行指定函数。\n   */\n  withActiveNodeAsSub<T>(nodeAsSub: Node | undefined, fn: () => T): T;\n  /**\n   * 以无当前正在进行依赖收集的节点的状态执行指定函数。\n   */\n  withoutActiveNodeAsSub<T>(fn: () => T): T;\n  /**\n   * 断言当前没有正在进行依赖收集的节点。\n   */\n  assertWithoutActiveNodeAsSub(): void;\n  /**\n   * 开始对节点（作为下游节点）进行依赖收集。\n   */\n  startTracking(node: Node): void;\n  /**\n   * 结束对节点（作为下游节点）进行依赖收集。\n   */\n  endTracking(node: Node): void;\n  /**\n   * 对节点（作为下游节点）进行依赖收集。\n   */\n  withTracking<T>(node: Node, fn: () => T): T;\n  /**\n   * 以无当前正在进行依赖收集的节点的状态执行指定函数。\n   */\n  withoutTracking<T>(fn: () => T): T;\n  /**\n   * 断言当前没有正在进行依赖收集的节点。\n   */\n  assertWithoutTracking(): void;\n  /**\n   * 为两个节点建立连接（依赖收集优化版）。\n   */\n  addLinkBetweenOptimizedForTracking(dep: Node, sub: Node): Link;\n  /**\n   * 将节点作为当前正在进行依赖收集的节点的上游节点。\n   */\n  track(node: Node): void;\n  /**\n   * 将节点作为当前正在进行依赖收集的节点的上游节点。\n   */\n  trackNearestMutableOrWatching(node: Node): void;\n\n  /**\n   * 当节点的值发生变化后，调用此方法更新直接下游节点的标记。\n   */\n  shallowPropagate(node: Node): void;\n  /**\n   * 当节点的值发生变化后，调用此方法更新所有下游节点的标记。\n   */\n  deeeeepPropagate(node: Node): void;\n  /**\n   * 解决节点的 Pending 标记。\n   */\n  resolvePending(node: Node): void;\n}\nexport const createReactiveSystem = (options: CreateReactiveSystemOptions): ReactiveSystem => {\n  const {\n    onDepChanged,\n    onSubChanged,\n    onHasDep,\n    onNoDep,\n    onHasSub,\n    onNoSub,\n    update,\n    notify\n  } = options;\n\n  /**\n   * 获取目标节点的所有上游连接。\n   *\n   * 依赖收集过程中会尝试复用现存连接，该机制会导致在未完全完成依赖收集前，连接链中可能出现\n   * 未经验证的连接。此方法只会返回经过验证的连接。\n   */\n  const getDepLinksOfNode = (node: Node): Link[] => {\n    const depLinks: Link[] = [];\n    let currentDepLink = node.headDepLink;\n    const tailDepLink = node.tailDepLink;\n    while (currentDepLink !== undefined) {\n      depLinks.push(currentDepLink);\n      const isValidLastDepLink = currentDepLink === tailDepLink;\n      if (isValidLastDepLink === true) {\n        break;\n      } else {\n        currentDepLink = currentDepLink.nextDepLink;\n      }\n    }\n    return depLinks;\n  }\n\n  /**\n   * 获取目标节点的所有下游连接。\n   *\n   * 依赖收集过程中会尝试复用现存连接，该机制会导致在未完全完成依赖收集前，连接链中可能出现\n   * 未经验证的连接。此方法只会返回经过验证的连接。\n   */\n  const getSubLinksOfNode = (node: Node): Link[] => {\n    const subLinks: Link[] = [];\n    let currentSubLink = node.headSubLink;\n    const tailSubLink = node.tailSubLink;\n    while (currentSubLink !== undefined) {\n      subLinks.push(currentSubLink);\n      const isValidLastSubLink = currentSubLink === tailSubLink;\n      if (isValidLastSubLink === true) {\n        break;\n      } else {\n        currentSubLink = currentSubLink.nextSubLink;\n      }\n    }\n    return subLinks;\n  }\n\n  const getDepsOfNode = (node: Node): Node[] => {\n    const depLinks = getDepLinksOfNode(node);\n    const deps = depLinks.map(link => link.dep);\n    return deps;\n  }\n\n  const getSubsOfNode = (node: Node): Node[] => {\n    const subLinks = getSubLinksOfNode(node);\n    const subs = subLinks.map(link => link.sub);\n    return subs;\n  }\n\n  const isDepLinkOfNode = (link: Link, node: Node): boolean => {\n    let currentDepLink = node.headDepLink;\n    const tailDepLink = node.tailDepLink;\n    while (currentDepLink !== undefined) {\n      if (currentDepLink === link) {\n        return true;\n      }\n      const isValidLastDepLink = currentDepLink === tailDepLink;\n      if (isValidLastDepLink === true) {\n        break;\n      } else {\n        currentDepLink = currentDepLink.nextDepLink;\n      }\n    }\n    return false;\n  }\n\n  const isSubLinkOfNode = (link: Link, node: Node): boolean => {\n    let currentSubLink = node.headSubLink;\n    const tailSubLink = node.tailSubLink;\n    while (currentSubLink !== undefined) {\n      if (currentSubLink === link) {\n        return true;\n      }\n      const isValidLastSubLink = currentSubLink === tailSubLink;\n      if (isValidLastSubLink === true) {\n        break;\n      } else {\n        currentSubLink = currentSubLink.nextSubLink;\n      }\n    }\n    return false;\n  }\n\n  const isDepOfNode = (node: Node, targetNode: Node): boolean => {\n    let currentDepLink = targetNode.headDepLink;\n    const tailDepLink = targetNode.tailDepLink;\n    while (currentDepLink !== undefined) {\n      if (currentDepLink.dep === node) {\n        return true;\n      }\n      const isValidLastDepLink = currentDepLink === tailDepLink;\n      if (isValidLastDepLink === true) {\n        break;\n      } else {\n        currentDepLink = currentDepLink.nextDepLink;\n      }\n    }\n    return false;\n  }\n\n  const isSubOfNode = (node: Node, targetNode: Node): boolean => {\n    let currentSubLink = targetNode.headSubLink;\n    const tailSubLink = targetNode.tailSubLink;\n    while (currentSubLink !== undefined) {\n      if (currentSubLink.sub === node) {\n        return true;\n      }\n      const isValidLastSubLink = currentSubLink === tailSubLink;\n      if (isValidLastSubLink === true) {\n        break;\n      } else {\n        currentSubLink = currentSubLink.nextSubLink;\n      }\n    }\n    return false;\n  }\n\n  const getLinkBetweenFromDep = (dep: Node, sub: Node): Link | undefined => {\n    let currentSubLink = dep.headSubLink;\n    const tailSubLink = dep.tailSubLink;\n    while (currentSubLink !== undefined) {\n      if (currentSubLink.sub === sub) {\n        return currentSubLink;\n      }\n      const isValidLastSubLink = currentSubLink === tailSubLink;\n      if (isValidLastSubLink === true) {\n        break;\n      } else {\n        currentSubLink = currentSubLink.nextSubLink;\n      }\n    }\n    return undefined;\n  }\n\n  const getLinkBetweenFromSub = (dep: Node, sub: Node): Link | undefined => {\n    let currentDepLink = sub.headDepLink;\n    const tailDepLink = sub.tailDepLink;\n    while (currentDepLink !== undefined) {\n      if (currentDepLink.dep === dep) {\n        return currentDepLink;\n      }\n      const isValidLastDepLink = currentDepLink === tailDepLink;\n      if (isValidLastDepLink === true) {\n        break;\n      } else {\n        currentDepLink = currentDepLink.nextDepLink;\n      }\n    }\n    return undefined;\n  }\n\n  const hasLinkBetweenFromDep = (dep: Node, sub: Node): boolean => {\n    const link = getLinkBetweenFromDep(dep, sub);\n    return link !== undefined;\n  }\n\n  const hasLinkBetweenFromSub = (dep: Node, sub: Node): boolean => {\n    const link = getLinkBetweenFromSub(dep, sub);\n    return link !== undefined;\n  }\n\n  const addLinkBetween = (dep: Node, sub: Node): Link => {\n    /**\n     * 检查是否存在重复连接。\n     */\n    const existLink = getLinkBetweenFromSub(dep, sub);\n    if (existLink !== undefined) {\n      return existLink;\n    }\n\n    /**\n     * 建立新连接。\n     */\n    const newLink: Link = {\n      dep,\n      prevSubLink: undefined,\n      nextSubLink: undefined,\n\n      sub,\n      prevDepLink: undefined,\n      nextDepLink: undefined,\n    };\n\n    const tailDepLinkOfSub = sub.tailDepLink;\n    if (tailDepLinkOfSub !== undefined) {\n      tailDepLinkOfSub.nextDepLink = newLink;\n      newLink.prevDepLink = tailDepLinkOfSub;\n    } else {\n      sub.headDepLink = newLink;\n    }\n    sub.tailDepLink = newLink;\n\n    const tailSubLinkOfDep = dep.tailSubLink;\n    if (tailSubLinkOfDep !== undefined) {\n      tailSubLinkOfDep.nextSubLink = newLink;\n      newLink.prevSubLink = tailSubLinkOfDep;\n    } else {\n      dep.headSubLink = newLink;\n    }\n    dep.tailSubLink = newLink;\n\n    /**\n     * 连接全部更新完成之后，触发回调，优先通知上游节点。\n     */\n    onSubChanged?.(dep);\n    const isFirstSub = tailSubLinkOfDep === undefined;\n    if (isFirstSub === true) {\n      onHasSub?.(dep, sub);\n    }\n    onDepChanged?.(sub);\n    const isFirstDep = tailDepLinkOfSub === undefined;\n    if (isFirstDep === true) {\n      onHasDep?.(sub, dep);\n    }\n\n    return newLink;\n  }\n\n  const removeLinkBetweenFromDep = (dep: Node, sub: Node): void => {\n    const linkFromDep = getLinkBetweenFromDep(dep, sub);\n    if (linkFromDep !== undefined) {\n      removeLink(linkFromDep);\n    }\n  }\n\n  const removeLinkBetweenFromSub = (dep: Node, sub: Node): void => {\n    const linkFromSub = getLinkBetweenFromSub(dep, sub);\n    if (linkFromSub !== undefined) {\n      removeLink(linkFromSub);\n    }\n  }\n\n  const removeLink = (link: Link): void => {\n    const prevDepLink = link.prevDepLink;\n    const dep = link.dep;\n    const nextDepLink = link.nextDepLink;\n    const prevSubLink = link.prevSubLink;\n    const sub = link.sub;\n    const nextSubLink = link.nextSubLink;\n\n    /**\n     * 处理上游连接链。\n     */\n\n    if (nextDepLink !== undefined) {\n      // 如果当前连接的下一个连接存在，则将当前连接的下一个连接的上一个连接指向当前连接的上一个连接\n      nextDepLink.prevDepLink = prevDepLink;\n    } else {\n      // 如果当前连接的下一个连接不存在，则将当前连接的上一个连接作为最后一个连接\n      sub.tailDepLink = prevDepLink;\n    }\n    if (prevDepLink !== undefined) {\n      // 如果当前连接的上一个连接存在，则将当前连接的上一个连接的下一个连接指向当前连接的下一个连接\n      prevDepLink.nextDepLink = nextDepLink;\n    } else {\n      // 如果当前连接的上一个连接不存在，则将当前连接的下一个连接作为第一个连接\n      sub.headDepLink = nextDepLink;\n    }\n\n    /**\n     * 处理下游连接链。\n     */\n\n    if (nextSubLink !== undefined) {\n      // 如果当前连接的下一个连接存在，则将当前连接的下一个连接的上一个连接指向当前连接的上一个连接\n      nextSubLink.prevSubLink = prevSubLink;\n    } else {\n      // 如果当前连接的下一个连接不存在，则将当前连接的上一个连接作为最后一个连接\n      dep.tailSubLink = prevSubLink;\n    }\n    if (prevSubLink !== undefined) {\n      // 如果当前连接的上一个连接存在，则将当前连接的上一个连接的下一个连接指向当前连接的下一个连接\n      prevSubLink.nextSubLink = nextSubLink;\n    } else {\n      // 如果当前连接的上一个连接不存在，则将当前连接的下一个连接作为第一个连接\n      dep.headSubLink = nextSubLink;\n    }\n\n    /**\n     * 连接全部更新完成之后，触发回调，优先通知上游节点。\n     */\n    onSubChanged?.(dep);\n    if (dep.headSubLink === undefined && dep.tailSubLink === undefined) {\n      onNoSub?.(dep, sub);\n    }\n    onDepChanged?.(sub);\n    if (sub.headDepLink === undefined && sub.tailDepLink === undefined) {\n      onNoDep?.(sub, dep);\n    }\n\n    /**\n     * 彻底断引用，防止内存泄漏。\n     */\n    link.prevDepLink = undefined;\n    // oxlint-disable-next-line no-unsafe-type-assertion\n    link.dep = undefined as unknown as Node; // type cast\n    link.nextDepLink = undefined;\n    link.prevSubLink = undefined;\n    // oxlint-disable-next-line no-unsafe-type-assertion\n    link.sub = undefined as unknown as Node; // type cast\n    link.nextSubLink = undefined;\n  }\n\n  const removeAllDepLinksOfNode = (node: Node): Node[] => {\n    const depNodes = [];\n    let currentDepLink = node.headDepLink;\n    while (currentDepLink !== undefined) {\n      depNodes.push(currentDepLink.dep);\n      const nextDepLink = currentDepLink.nextDepLink;\n      removeLink(currentDepLink);\n      currentDepLink = nextDepLink;\n    }\n    return depNodes;\n  }\n\n  const removeAllSubLinksOfNode = (node: Node): Node[] => {\n    const subNodes = [];\n    let currentSubLink = node.headSubLink;\n    while (currentSubLink !== undefined) {\n      subNodes.push(currentSubLink.sub);\n      const nextSubLink = currentSubLink.nextSubLink;\n      removeLink(currentSubLink);\n      currentSubLink = nextSubLink;\n    }\n    return subNodes;\n  }\n\n  let prevActiveNodeAsSubStack: Array<Node | undefined> = [];\n  let activeNodeAsSub: Node | undefined = undefined;\n  const getActiveNodeAsSub = (): Node | undefined => {\n    return activeNodeAsSub;\n  }\n  const setActiveNodeAsSub = (nodeAsSub: Node | undefined): Node | undefined => {\n    prevActiveNodeAsSubStack.push(activeNodeAsSub);\n    activeNodeAsSub = nodeAsSub;\n    return activeNodeAsSub;\n  }\n  const setNoActiveNodeAsSub = (): undefined => {\n    // oxlint-disable-next-line no-unsafe-type-assertion\n    return setActiveNodeAsSub(undefined) as undefined;\n  }\n  const resetActiveNodeAsSub = (): Node | undefined => {\n    activeNodeAsSub = prevActiveNodeAsSubStack.pop();\n    return activeNodeAsSub;\n  }\n  const withActiveNodeAsSub = <T>(nodeAsSub: Node | undefined, fn: () => T): T => {\n    setActiveNodeAsSub(nodeAsSub);\n    try {\n      return fn();\n    } finally {\n      resetActiveNodeAsSub();\n    }\n  }\n  const withoutActiveNodeAsSub = <T>(fn: () => T): T => {\n    return withActiveNodeAsSub(undefined, fn);\n  }\n  const assertWithoutActiveNodeAsSub = (): void => {\n    const currentActiveNodeAsSub = getActiveNodeAsSub();\n    if (currentActiveNodeAsSub !== undefined) {\n      throw new Error(`Expected no active node as sub, but got one.`);\n    }\n  }\n\n  const startTracking = (nodeAsSub: Node): void => {\n    setActiveNodeAsSub(nodeAsSub);\n\n    const flags = nodeAsSub.flags;\n    flags.unsetPending().unsetDirty().setTracking();\n  }\n  const endTracking = (nodeAsSub: Node): void => {\n    const flags = nodeAsSub.flags;\n    if (flags.hasTrackingReusing() === true) {\n      const firstRedundantDepLink = nodeAsSub?.tailDepLink?.nextDepLink;\n      if (firstRedundantDepLink !== undefined) {\n        let toRemove: Link | undefined = firstRedundantDepLink;\n        while (toRemove !== undefined) {\n          const nextToRemove: Link | undefined = toRemove.nextDepLink;\n          removeLink(toRemove);\n          toRemove = nextToRemove;\n        }\n      }\n    }\n    flags.unsetTrackingReusing().unsetTracking();\n\n    resetActiveNodeAsSub();\n  }\n  const withTracking = <T>(node: Node, fn: () => T): T => {\n    startTracking(node);\n    try {\n      return fn();\n    } finally {\n      endTracking(node);\n    }\n  }\n  const withoutTracking = <T>(fn: () => T): T => {\n    return withoutActiveNodeAsSub(() => {\n      return fn();\n    });\n  }\n  const assertWithoutTracking = (): void => {\n    try {\n      assertWithoutActiveNodeAsSub();\n    } catch {\n      throw new Error(`Expected no active node as sub for tracking, but got one.`);\n    }\n  }\n  /**\n   * 依赖收集的目标是：在完成一次依赖收集之后，对于所有在依赖收集执行过程中被访问过的节点（上游节点），\n   * 都与进行依赖收集的节点（下游节点）建立且仅建立一个连接。\n   */\n  const addLinkBetweenOptimizedForTracking = (dep: Node, sub: Node): Link => {\n    let existingDepLinkToCompare: Link | undefined;\n\n    const subFlags = sub.flags;\n    if (subFlags.hasTracking() === true && subFlags.hasTrackingReusing() === false) {\n      subFlags.setTrackingReusing();\n      sub.tailDepLink = sub.headDepLink;\n      existingDepLinkToCompare = sub.tailDepLink;\n    } else {\n      existingDepLinkToCompare = sub.tailDepLink?.nextDepLink;\n    }\n\n    /**\n     * 检查是否可以复用现存连接。\n     */\n\n    if (existingDepLinkToCompare !== undefined && existingDepLinkToCompare.dep === dep) {\n      // 如果可以，则复用该连接\n      sub.tailDepLink = existingDepLinkToCompare;\n      // 触发回调\n      onDepChanged?.(sub);\n      return existingDepLinkToCompare;\n    } else {\n      // 否则，建立新连接\n      const newLink = addLinkBetween(dep, sub);\n      return newLink;\n    }\n  }\n  const track = (node: Node): void => {\n    let targetSub = getActiveNodeAsSub();\n    if (targetSub !== undefined) {\n      addLinkBetweenOptimizedForTracking(node, targetSub);\n    }\n  }\n  const trackNearestMutableOrWatching = (node: Node): void => {\n    let targetSub = getActiveNodeAsSub();\n    while (targetSub !== undefined) {\n      const flags = targetSub.flags;\n      if (flags.hasMutable() === true || flags.hasWatching() === true) {\n        addLinkBetweenOptimizedForTracking(node, targetSub);\n        break;\n      }\n      targetSub = targetSub.headSubLink?.sub;\n    }\n  }\n\n  const shallowPropagate = (node: Node): void => {\n    // 从头到尾遍历目标节点下游连接链中的所有下游节点，更新其标记。\n\n    let currentSubLink: Link | undefined = node.headSubLink;\n    while (currentSubLink !== undefined) {\n      const sub = currentSubLink.sub;\n      const flags = sub.flags;\n      let isChangeToDirty = false;\n\n      if (flags.hasPending() === true && flags.hasDirty() === false) {\n        // 如果包含 Pending 标记，且不包含 Dirty 标记，为其添加 Dirty 标记，移除 Pending 标记\n        flags.setDirty().unsetPending();\n        isChangeToDirty = true;\n      } else {\n        // 如果是其它情况，则处理下一个连接\n        currentSubLink = currentSubLink.nextSubLink;\n        continue;\n      }\n\n      if (isChangeToDirty === true) {\n        // 如果检查过程中被标记为 Dirty，则酌情触发 notify 回调\n        const shouldNotify = flags.hasWatching() === true && flags.hasTracking() === false;\n        if (shouldNotify === true) {\n          notify(sub);\n        }\n      }\n\n      // 当前连接处理完成，处理下一个连接\n      currentSubLink = currentSubLink.nextSubLink;\n    }\n  }\n\n  interface InternalStack<T> {\n    value: T;\n    prev: InternalStack<T> | undefined;\n  }\n\n  const deeeeepPropagate = (node: Node): void => {\n    let currentSubLink = node.headSubLink;\n    let nextSubLink = currentSubLink?.nextSubLink;\n    let unhandledSubLinkStack: InternalStack<Link | undefined> | undefined = undefined;\n\n    while (currentSubLink !== undefined) {\n      const sub = currentSubLink.sub;\n\n      let flags = sub.flags;\n      let shouldNotify = flags.hasWatching();\n      let shouldDownward = flags.hasMutable();\n\n      if (flags.hasTracking() === false && flags.hasDirty() === false && flags.hasPending() === false) {\n        /**\n         * 进入此分支的 flags：\n         *  1. 不包含 Tracking 标记。\n         *  2. 不包含 Dirty 标记或 Pending 标记。\n         *\n         * 说明：上游节点的变更首次传递到该节点。\n         *\n         * 此时，添加 Pending 标记，根据其它标记决定是否需要 Notify，根据其它标记决定是否需要 Downward。\n         */\n        flags.setPending();\n        shouldNotify = shouldNotify;\n        shouldDownward = shouldDownward;\n      } else if (flags.hasTracking() === false) {\n        /**\n         * 进入此分支的 flags：\n         *  1. 不包含 Tracking 标记。\n         *  2. 包含 Dirty 标记或 Pending 标记。\n         *\n         * 说明：上游节点的变更已经传递到该节点。\n         *\n         * 此时，什么都不做，不需要修改标记，不需要 Notify，不需要 Downward。\n         */\n        flags = flags;\n        shouldNotify = false;\n        shouldDownward = false;\n      } else if (flags.hasDirty() === false && flags.hasPending() === false) {\n        /**\n         * 进入此分支的 flags：\n         *  1. 包含 Tracking 标记。\n         *  2. 不包含 Dirty 标记或 Pending 标记。\n         *\n         * 说明：上游节点的变更首次传递到该节点，且该节点正在进行依赖收集。\n         *\n         * 此时，添加 Pending 标记，不需要 Notify，根据其它标记决定是否需要 Downward。\n         */\n        flags.setPending();\n        shouldNotify = false;\n        shouldDownward = shouldDownward;\n      } else {\n        /**\n         * 进入此分支的 flags：\n         *  1. 包含 Tracking 标记。\n         *  2. 包含 Dirty 标记或 Pending 标记。\n         *\n         * 说明：上游节点的变更已经传递到该节点，且该节点正在进行依赖收集。\n         *\n         * 此时，不需要修改标记，不需要 Notify，不需要 Downward。\n         */\n        flags = flags;\n        shouldNotify = false;\n        shouldDownward = false;\n      }\n\n      if (shouldNotify === true) {\n        notify(sub);\n      }\n\n      if (shouldDownward === true) {\n        const headSubLinkOfSub = sub.headSubLink;\n        if (headSubLinkOfSub !== undefined) {\n          currentSubLink = headSubLinkOfSub;\n          const nextSubLinkOfSub = headSubLinkOfSub.nextSubLink;\n          if (nextSubLinkOfSub !== undefined) {\n            unhandledSubLinkStack = { value: nextSubLink, prev: unhandledSubLinkStack };\n            nextSubLink = nextSubLinkOfSub;\n          }\n          continue;\n        }\n      }\n\n      currentSubLink = nextSubLink\n      if (currentSubLink !== undefined) {\n        nextSubLink = currentSubLink.nextSubLink;\n        continue;\n      }\n\n      if (unhandledSubLinkStack !== undefined) {\n        currentSubLink = unhandledSubLinkStack.value;\n        unhandledSubLinkStack = unhandledSubLinkStack.prev;\n        if (currentSubLink !== undefined) {\n          nextSubLink = currentSubLink.nextSubLink;\n        }\n      }\n    }\n  }\n\n  const resolvePending = (node: Node): void => {\n    let currentDepLink = node.headDepLink;\n    let unhandledDepLinkStack: InternalStack<Link> | undefined = undefined;\n\n    while (currentDepLink !== undefined) {\n      const currentSub: Node = currentDepLink.sub;\n      const currentDep: Node = currentDepLink.dep;\n      const subFlags = currentSub.flags;\n      const depFlags = currentDep.flags;\n\n      if (depFlags.hasMutable() === true && depFlags.hasDirty() === true) {\n        /**\n         * 当前下游节点不包含 Dirty 标记，当前上游节点包含 Dirty 标记。\n         *\n         * 更新当前上游节点，若值有变化，则将状态向直接下游节点传播。\n         */\n        const valueChanged = update(currentDep);\n        if (valueChanged === true) {\n          shallowPropagate(currentDep);\n        }\n      } else if (depFlags.hasMutable() === true && depFlags.hasPending() === true) {\n        /**\n         * 当前下游节点不包含 Dirty 标记，当前上游节点包含 Pending 标记。\n         *\n         * 继续检查当前上游节点的上游节点。\n         */\n        unhandledDepLinkStack = { value: currentDepLink, prev: unhandledDepLinkStack };\n        currentDepLink = currentDep.headDepLink;\n        continue;\n      }\n\n      if (subFlags.hasPending() === true) {\n        const nextDepLink = currentDepLink.nextDepLink;\n        if (nextDepLink !== undefined) {\n          currentDepLink = nextDepLink;\n          continue;\n        }\n      }\n\n      if (unhandledDepLinkStack !== undefined) {\n        currentDepLink = unhandledDepLinkStack.value;\n        unhandledDepLinkStack = unhandledDepLinkStack.prev;\n\n        /**\n         * 当一个连接先被存起来，后续又被取出来处理时，说明其所有上游节点都已经处理完成，\n         * 因此可以将其 Pending 标记移除。\n         */\n        currentDepLink.dep.flags.unsetPending();\n      } else {\n        /**\n         * 所有连接都处理完成，可以安全移除当前连接的下游节点的 Pending 标记。\n         */\n        currentDepLink.sub.flags.unsetPending();\n        break;\n      }\n    }\n  }\n\n  return {\n    getDepLinksOfNode,\n    getSubLinksOfNode,\n    getDepsOfNode,\n    getSubsOfNode,\n    isDepLinkOfNode,\n    isSubLinkOfNode,\n    isDepOfNode,\n    isSubOfNode,\n    getLinkBetweenFromDep,\n    getLinkBetweenFromSub,\n    hasLinkBetweenFromDep,\n    hasLinkBetweenFromSub,\n    addLinkBetween,\n    removeLinkBetweenFromDep,\n    removeLinkBetweenFromSub,\n    removeLink,\n    removeAllDepLinksOfNode,\n    removeAllSubLinksOfNode,\n\n    getActiveNodeAsSub,\n    setActiveNodeAsSub,\n    setNoActiveNodeAsSub,\n    resetActiveNodeAsSub,\n    withActiveNodeAsSub,\n    withoutActiveNodeAsSub,\n    assertWithoutActiveNodeAsSub,\n    startTracking,\n    endTracking,\n    withTracking,\n    withoutTracking,\n    assertWithoutTracking,\n    addLinkBetweenOptimizedForTracking,\n    track,\n    trackNearestMutableOrWatching,\n\n    shallowPropagate,\n    deeeeepPropagate,\n    resolvePending,\n  };\n}\n",
+    "import type { Flags } from \"./flags.ts\"\nimport { createReactiveSystem } from \"./reactive-system.ts\"\nimport { flags } from \"./flags.ts\"\nimport type { Link, Node, ReactiveSystem } from \"./reactive-system.ts\"\n\nexport interface BaseReactorOptions {\n  name?: string | undefined;\n\n  onDepChanged?: (() => void) | undefined;\n  onSubChanged?: (() => void) | undefined;\n  onHasDep?: ((dep: BaseReactor) => void) | undefined;\n  onNoDep?: ((dep: BaseReactor) => void) | undefined;\n  onHasSub?: ((sub: BaseReactor) => void) | undefined;\n  onNoSub?: ((sub: BaseReactor) => void) | undefined;\n\n  onDispose?: (() => void) | undefined;\n}\nexport abstract class BaseReactor<V = unknown> implements Node {\n  headDepLink?: Link | undefined;\n  tailDepLink?: Link | undefined;\n  headSubLink?: Link | undefined\n  tailSubLink?: Link | undefined\n  flags: Flags;\n\n  protected value: V;\n\n  protected _name: string | undefined;\n\n  protected _onDepChanged?: (() => void) | undefined;\n  protected _onSubChanged?: (() => void) | undefined;\n  protected _onHasDep?: ((dep: BaseReactor) => void) | undefined;\n  protected _onNoDep?: ((dep: BaseReactor) => void) | undefined;\n  protected _onHasSub?: ((sub: BaseReactor) => void) | undefined;\n  protected _onNoSub?: ((sub: BaseReactor) => void) | undefined;\n\n  protected _onDispose?: (() => void) | undefined;\n\n  constructor(options: BaseReactorOptions) {\n    this.flags = flags();\n\n    // undefined 可能是使用者期待的合法值，因此这里使用 VOID 占位\n    // oxlint-disable-next-line no-unsafe-type-assertion\n    this.value = VOID as V;\n\n    this._name = options.name;\n\n    this._onDepChanged = options.onDepChanged;\n    this._onSubChanged = options.onSubChanged;\n    this._onHasDep = options.onHasDep;\n    this._onNoDep = options.onNoDep;\n    this._onHasSub = options.onHasSub;\n    this._onNoSub = options.onNoSub;\n\n    this._onDispose = options.onDispose;\n  }\n\n  getName(): string | undefined {\n    return this._name;\n  }\n\n  setName(name: string | undefined): void {\n    this._name = name;\n  }\n\n  abstract trackThis(): void;\n\n  /**\n   * Reactor 在运行过程中状态可能会发生变化，此方法用于将状态重置。比如：\n   * 在错误发生时调用。\n   */\n  abstract reset(): void;\n\n  /**\n   * 删除当前 Reactor 与其它 Reactor 之间的所有连接，将状态重置，删除有必要删除的资源，\n   * 目标是使当前 Reactor 可以被安全地丢弃而不会引起内存泄漏。\n   */\n  abstract dispose(): void;\n\n  triggerOnDepChanged(): void {\n    this._onDepChanged?.();\n  };\n\n  triggerOnSubChanged(): void {\n    this._onSubChanged?.();\n  };\n\n  triggerOnHasDep(dep: BaseReactor): void {\n    this._onHasDep?.(dep);\n  };\n\n  triggerOnNoDep(dep: BaseReactor): void {\n    this._onNoDep?.(dep);\n  };\n\n  triggerOnHasSub(sub: BaseReactor): void {\n    this._onHasSub?.(sub);\n  };\n\n  triggerOnNoSub(sub: BaseReactor): void {\n    this._onNoSub?.(sub);\n    this.dispose();\n  };\n\n  triggerOnDispose(): void {\n    this._onDispose?.();\n  }\n}\n\nconst VOID = Symbol(\"void\") as unknown;\nconst isVoid = <T>(value: T): boolean => {\n  return value === VOID;\n}\n\nlet queue: Effect[] = [];\nconst flush = (): void => {\n  const tempFlushQueue = queue;\n  queue = [];\n  try {\n    while (tempFlushQueue.length !== 0) {\n      const effect = tempFlushQueue.shift()!;\n      effect.run();\n    }\n  } catch {\n    while (tempFlushQueue.length !== 0) {\n      const effect = tempFlushQueue.shift()!;\n      effect.reset();\n    }\n  }\n}\n\nlet batchDepth = 0;\nexport const flushBatch = (): void => {\n  if (batchDepth === 0) {\n    flush();\n  }\n}\nexport const startBatch = (): void => {\n  batchDepth = batchDepth + 1;\n}\nexport const endBatch = (): void => {\n  batchDepth = batchDepth - 1;\n  if (batchDepth < 0) {\n    throw new Error(\"endBatch called without matching startBatch\");\n  }\n  flushBatch();\n}\nexport const batch = (fn: () => void): void => {\n  startBatch();\n  try {\n    fn();\n  } finally {\n    endBatch();\n  }\n}\n\nexport const reactiveSystem: ReactiveSystem = createReactiveSystem({\n  onDepChanged: (sub: Node) => {\n    if (sub instanceof BaseReactor) {\n      return sub.triggerOnDepChanged();\n    }\n  },\n  onSubChanged: (dep: Node) => {\n    if (dep instanceof BaseReactor) {\n      return dep.triggerOnSubChanged();\n    }\n  },\n  onHasDep: (sub: Node, dep: Node) => {\n    if (sub instanceof BaseReactor && dep instanceof BaseReactor) {\n      return sub.triggerOnHasDep(dep);\n    }\n  },\n  onNoDep: (sub: Node, dep: Node) => {\n    if (sub instanceof BaseReactor && dep instanceof BaseReactor) {\n      return sub.triggerOnNoDep(dep);\n    }\n  },\n  onHasSub: (dep: Node, sub: Node) => {\n    if (dep instanceof BaseReactor && sub instanceof BaseReactor) {\n      return dep.triggerOnHasSub(sub);\n    }\n  },\n  onNoSub: (dep: Node, sub: Node) => {\n    if (dep instanceof BaseReactor && sub instanceof BaseReactor) {\n      return dep.triggerOnNoSub(sub);\n    }\n  },\n\n  update(node: Signal | Derived | Computed) {\n    return node.update();\n  },\n  notify(node: Effect) {\n    const nodes = []\n    let currentNode: Effect | undefined = node\n    while (currentNode !== undefined) {\n      if (currentNode.flags.hasWatching() === false) {\n        break\n      }\n      currentNode.notify();\n      nodes.push(currentNode);\n      const nextNode: Node | undefined = currentNode?.headSubLink?.sub\n      currentNode = nextNode instanceof Effect ? nextNode : undefined\n    }\n    queue.push(...nodes.toReversed());\n  },\n});\nconst {\n  removeAllDepLinksOfNode,\n  removeAllSubLinksOfNode,\n\n  withTracking,\n  track,\n  trackNearestMutableOrWatching,\n\n  shallowPropagate,\n  deeeeepPropagate,\n  resolvePending,\n} = reactiveSystem\n\nconst defaultIsEqual = <V>(oldValue: V, newValue: V): boolean => {\n  return Object.is(oldValue, newValue);\n}\n\nexport interface BaseSignalValueGetterContext { }\nexport interface InitializingSignalValueGetterContext extends BaseSignalValueGetterContext {\n  isInitializingRun: true;\n}\nexport interface UpdatingSignalValueGetterContext<V> extends BaseSignalValueGetterContext {\n  isInitializingRun: false;\n  previousValue: V;\n}\nexport type SignalValueGetterContext<V> =\n  | InitializingSignalValueGetterContext\n  | UpdatingSignalValueGetterContext<V>;\nexport type SignalValueInitializer<V> = (context: InitializingSignalValueGetterContext) => V;\nexport type SignalValueUpdater<V> = (context: UpdatingSignalValueGetterContext<V>) => V;\nexport type SignalValueGetter<V> = (context: SignalValueGetterContext<V>) => V;\nexport interface SignalOptions<V> extends BaseReactorOptions {\n  isEqual?: ((oldValue: V, newValue: V) => boolean) | undefined;\n}\n/**\n * Signal 的值只有在被获取的时候才会更新。\n */\nexport class Signal<V = unknown> extends BaseReactor<V> {\n  private isEqual: (oldValue: V, newValue: V) => boolean;\n\n  private valueGetter: SignalValueGetter<V>;\n\n  constructor(valueInitializer: SignalValueInitializer<V>, options: SignalOptions<V>) {\n    super(options);\n    this.headSubLink = undefined;\n    this.tailSubLink = undefined;\n    this.flags = this.getInitialFlags();\n\n    this.isEqual = options.isEqual ?? defaultIsEqual;\n\n    // oxlint-disable-next-line no-unsafe-type-assertion\n    this.valueGetter = valueInitializer as SignalValueGetter<V>;\n  }\n\n  private getInitialFlags(): Flags {\n    // 值在创建时尚未计算，因此初始时添加 Dirty 标记\n    return flags().setMutable().setDirty();\n  }\n\n  trackThis(): void {\n    trackNearestMutableOrWatching(this);\n  }\n\n  reset(): void {\n    this.flags = this.getInitialFlags();\n  }\n\n  dispose(): void {\n    removeAllDepLinksOfNode(this);\n    removeAllSubLinksOfNode(this);\n    this.reset();\n    this.triggerOnDispose();\n  }\n\n  private internalGet(options: { shouldTrack: boolean }): V {\n    const { shouldTrack } = options;\n    if (shouldTrack === true) {\n      this.trackThis();\n    }\n\n    let valueChanged = false\n\n    // 如果包含 Dirty 标记，则进行更新\n    const shouldUpdate = this.flags.hasDirty();\n    if (shouldUpdate === true) {\n      valueChanged = this.update()\n    }\n\n    // 如果值变化，则通知下游（仅通知直接下游）\n    if (valueChanged === true) {\n      shallowPropagate(this);\n    }\n\n    return this.value;\n  }\n\n  get(): V {\n    return this.internalGet({ shouldTrack: true });\n  }\n\n  getWithoutTrack(): V {\n    return this.internalGet({ shouldTrack: false });\n  }\n\n  private internalSet(options: { valueUpdater: SignalValueUpdater<V> }): void {\n    const { valueUpdater } = options;\n\n    // 将新值暂存起来，等用到的时候再执行更新\n    // oxlint-disable-next-line no-unsafe-type-assertion\n    this.valueGetter = valueUpdater as SignalValueGetter<V>;\n    // 为当前节点添加 Dirty 标记\n    this.flags.setDirty();\n\n    // 更新所有下游节点的标记\n    deeeeepPropagate(this);\n\n    // 执行更新队列\n    flushBatch();\n  }\n\n  set(value: V): void {\n    return this.internalSet({ valueUpdater: () => value });\n  }\n\n  setWithoutCalculate(valueUpdater: SignalValueUpdater<V>): void {\n    return this.internalSet({ valueUpdater });\n  }\n\n  /**\n   * 返回值表示更新前后值是否变化。\n   */\n  update(): boolean {\n    this.flags.unsetDirty();\n\n    const isInitializingRun = isVoid(this.value) === true;\n\n    if (isInitializingRun === true) {\n      const newValue = this.valueGetter({ isInitializingRun: true });\n      this.value = newValue;\n\n      return true;\n    } else {\n      const oldValue = this.value;\n      const newValue = this.valueGetter({ isInitializingRun: false, previousValue: oldValue });\n      this.value = newValue;\n\n      const valueChanged = this.isEqual(oldValue, newValue) === false\n      return valueChanged;\n    }\n  }\n}\n\nexport interface BaseDerivedValueGetterContext { }\nexport interface InitializingSignalValueGetterContext extends BaseDerivedValueGetterContext {\n  isInitializingRun: true;\n}\nexport interface UpdatingDerivedValueGetterContext<V> extends BaseDerivedValueGetterContext {\n  isInitializingRun: false;\n  previousValue: V;\n}\nexport type DerivedValueGetterContext<V> =\n  | InitializingSignalValueGetterContext\n  | UpdatingDerivedValueGetterContext<V>;\nexport type DerivedValueUpdater<V> = (context: UpdatingDerivedValueGetterContext<V>) => V;\nexport type DerivedValueGetter<V> = (context: DerivedValueGetterContext<V>) => V;\nexport interface DerivedOptions<V> extends BaseReactorOptions {\n  isEqual?: ((oldValue: V, newValue: V) => boolean) | undefined;\n}\n/**\n * Derived 的值只有在被获取的时候才会更新。\n * Derived 的值只有在上游节点的值发生变化时才会更新。\n * Derived 的下游节点全部解除连接时会自动与所有上游节点解除连接，并回到初始状态。\n */\nexport class Derived<V = unknown> extends BaseReactor<V> {\n  private isEqual: (oldValue: V, newValue: V) => boolean;\n\n  private valueGetter: DerivedValueGetter<V>;\n  private manualValueGetter: DerivedValueGetter<V> | undefined;\n\n  constructor(valueGetter: DerivedValueGetter<V>, options: DerivedOptions<V>) {\n    super(options);\n    this.headDepLink = undefined;\n    this.tailDepLink = undefined;\n    this.headSubLink = undefined;\n    this.tailSubLink = undefined;\n    this.flags = this.getInitialFlags();\n\n    this.isEqual = options.isEqual ?? defaultIsEqual;\n\n    this.valueGetter = valueGetter;\n    this.manualValueGetter = undefined;\n  }\n\n  private getInitialFlags(): Flags {\n    // 值在创建时尚未计算，因此初始时添加 Dirty 标记\n    return flags().setMutable().setDirty();\n  }\n\n  trackThis(): void {\n    trackNearestMutableOrWatching(this);\n  }\n\n  reset(): void {\n    this.flags = this.getInitialFlags();\n  }\n\n  dispose(): void {\n    removeAllDepLinksOfNode(this);\n    removeAllSubLinksOfNode(this);\n    this.reset();\n    this.triggerOnDispose();\n  }\n\n  private internalGet(options: { shouldTrack: boolean }): V {\n    const { shouldTrack } = options;\n    if (shouldTrack === true) {\n      this.trackThis();\n    }\n\n    let valueChanged = false;\n\n    // 如果包含 Pending 标记，则进行解决\n    const shouldResolve = this.flags.hasPending();\n    if (shouldResolve === true) {\n      resolvePending(this);\n    }\n\n    // 如果包含 Dirty 标记，则进行更新\n    const shouldUpdate = this.flags.hasDirty();\n    if (shouldUpdate === true) {\n      valueChanged = this.update()\n    }\n\n    // 如果值变化，则通知下游（仅通知直接下游）\n    if (valueChanged === true) {\n      shallowPropagate(this);\n    }\n\n    return this.value;\n  }\n\n  get(): V {\n    return this.internalGet({ shouldTrack: true });\n  }\n\n  getWithoutTrack(): V {\n    return this.internalGet({ shouldTrack: false });\n  }\n\n  private internalSet(options: { valueUpdater: DerivedValueUpdater<V> }): void {\n    const { valueUpdater } = options;\n\n    // 将新值暂存起来，等用到的时候再执行更新\n    // oxlint-disable-next-line no-unsafe-type-assertion\n    this.manualValueGetter = valueUpdater as DerivedValueGetter<V>;\n    // 为当前节点添加 Dirty 标记\n    this.flags.setDirty();\n\n    // 更新所有下游节点的标记\n    deeeeepPropagate(this);\n\n    // 执行更新队列\n    flushBatch();\n  }\n\n  set(value: V): void {\n    return this.internalSet({ valueUpdater: () => value });\n  }\n\n  setWithoutCalculate(valueUpdater: DerivedValueUpdater<V>): void {\n    return this.internalSet({ valueUpdater });\n  }\n\n  /**\n   * 返回值表示更新前后值是否变化。\n   */\n  private manualUpdate(): boolean {\n    const manualValueGetter = this.manualValueGetter;\n    if (manualValueGetter === undefined) {\n      throw new Error(\"Derived: manualValueGetter is undefined.\");\n    }\n    this.manualValueGetter = undefined;\n\n    this.flags.unsetDirty();\n\n    const isInitializingRun = isVoid(this.value) === true;\n\n    if (isInitializingRun === true) {\n      const newValue = manualValueGetter({ isInitializingRun: true });\n      this.value = newValue;\n\n      return true;\n    } else {\n      const oldValue = this.value;\n      const newValue = manualValueGetter({ isInitializingRun: false, previousValue: oldValue });\n      this.value = newValue;\n\n      const valueChanged = this.isEqual(oldValue, newValue) === false\n      return valueChanged;\n    }\n  }\n\n  /**\n   * 返回值表示更新前后值是否变化。\n   */\n  update(): boolean {\n    if (this.manualValueGetter !== undefined) {\n      return this.manualUpdate();\n    }\n\n    const result = withTracking(this, () => {\n      this.flags.unsetDirty();\n\n      const isInitializingRun = isVoid(this.value) === true;\n\n      if (isInitializingRun === true) {\n        const newValue = this.valueGetter({ isInitializingRun: true });\n        this.value = newValue;\n\n        return true;\n      } else {\n        const oldValue = this.value;\n        const newValue = this.valueGetter({ isInitializingRun: false, previousValue: oldValue });\n        this.value = newValue;\n\n        const valueChanged = this.isEqual(oldValue, newValue) === false\n        return valueChanged;\n      }\n\n    })\n    return result;\n  }\n}\n\nexport interface BaseComputedValueGetterContext { }\nexport interface InitializingComputedValueGetterContext extends BaseComputedValueGetterContext {\n  isInitializingRun: true;\n}\nexport interface UpdatingComputedValueGetterContext<V> extends BaseComputedValueGetterContext {\n  isInitializingRun: false;\n  previousValue: V;\n}\nexport type ComputedValueGetterContext<V> =\n  | InitializingComputedValueGetterContext\n  | UpdatingComputedValueGetterContext<V>;\nexport type ComputedValueGetter<V> = (context: ComputedValueGetterContext<V>) => V;\nexport interface ComputedOptions<V> extends BaseReactorOptions {\n  isEqual?: ((oldValue: V, newValue: V) => boolean) | undefined;\n}\n/**\n * Computed 的值只有在被获取的时候才会更新。\n * Computed 的值只有在上游节点的值发生变化时才会更新。\n * Computed 的下游节点全部解除连接时会自动与所有上游节点解除连接，并回到初始状态。\n */\nexport class Computed<V = unknown> extends BaseReactor<V> {\n  private isEqual: (oldValue: V, newValue: V) => boolean;\n\n  private valueGetter: ComputedValueGetter<V>;\n\n  constructor(valueGetter: ComputedValueGetter<V>, options: ComputedOptions<V>) {\n    super(options);\n    this.headDepLink = undefined;\n    this.tailDepLink = undefined;\n    this.headSubLink = undefined;\n    this.tailSubLink = undefined;\n    this.flags = this.getInitialFlags();\n\n    this.isEqual = options.isEqual ?? defaultIsEqual;\n\n    this.valueGetter = valueGetter;\n  }\n\n  private getInitialFlags(): Flags {\n    // 值在创建时尚未计算，因此初始时添加 Dirty 标记\n    return flags().setMutable().setDirty();\n  }\n\n  trackThis(): void {\n    trackNearestMutableOrWatching(this);\n  }\n\n  reset(): void {\n    this.flags = this.getInitialFlags();\n  }\n\n  dispose(): void {\n    removeAllDepLinksOfNode(this);\n    removeAllSubLinksOfNode(this);\n    this.reset();\n    this.triggerOnDispose();\n  }\n\n  private internalGet(options: { shouldTrack: boolean }): V {\n    const { shouldTrack } = options;\n    if (shouldTrack === true) {\n      this.trackThis();\n    }\n\n    let valueChanged = false;\n\n    // 如果包含 Pending 标记，则进行解决\n    const shouldResolve = this.flags.hasPending();\n    if (shouldResolve === true) {\n      resolvePending(this);\n    }\n\n    // 如果包含 Dirty 标记，则进行更新\n    const shouldUpdate = this.flags.hasDirty();\n    if (shouldUpdate === true) {\n      valueChanged = this.update()\n    }\n\n    // 如果值变化，则通知下游（仅通知直接下游）\n    if (valueChanged === true) {\n      shallowPropagate(this);\n    }\n\n    return this.value;\n  }\n\n  get(): V {\n    return this.internalGet({ shouldTrack: true });\n  }\n\n  getWithoutTrack(): V {\n    return this.internalGet({ shouldTrack: false });\n  }\n\n  /**\n   * 返回值表示更新前后值是否变化。\n   */\n  update(): boolean {\n    const result = withTracking(this, () => {\n      this.flags.unsetDirty();\n\n      const isInitializingRun = isVoid(this.value) === true;\n\n      if (isInitializingRun === true) {\n        const newValue = this.valueGetter({ isInitializingRun: true });\n        this.value = newValue;\n        return true;\n      } else {\n        const oldValue = this.value;\n        const newValue = this.valueGetter({ isInitializingRun: false, previousValue: oldValue });\n        this.value = newValue;\n\n        const valueChanged = this.isEqual(oldValue, newValue) === false\n        return valueChanged;\n      }\n\n    })\n    return result;\n  }\n}\n\n\nexport type CleanupFn = () => void;\nexport interface BaseEffectValueGetterContext {\n  setCleanup: (cleanup: CleanupFn) => void;\n}\nexport interface InitializingEffectValueGetterContext extends BaseEffectValueGetterContext {\n  isInitializingRun: true;\n}\nexport interface UpdatingEffectValueGetterContext<V> extends BaseEffectValueGetterContext {\n  isInitializingRun: false;\n  previousValue: V;\n}\nexport type EffectValueGetterContext<V> =\n  | InitializingEffectValueGetterContext\n  | UpdatingEffectValueGetterContext<V>;\nexport type EffectValueGetter<V> = (context: EffectValueGetterContext<V>) => V;\nexport interface EffectOptions extends BaseReactorOptions {\n}\n/**\n * Effect 会在创建时立即执行一次传入的函数。\n * Effect 会在每次上游节点的值发生变化时重新执行传入的函数。\n * Effect 在任意时刻最多只能一个待运行。\n * Effect 可以与 Effect 建立连接。\n * 作为上游节点的 Effect 在没有下游节点时会自动与所有上游节点解除连接，并将标记清空。\n */\nexport class Effect<V = void> extends BaseReactor<V> {\n  private valueGetter: EffectValueGetter<V>;\n  private cleanupFn: CleanupFn | undefined;\n\n  constructor(valueGetter: EffectValueGetter<V>, options: EffectOptions) {\n    super(options);\n    this.headDepLink = undefined;\n    this.tailDepLink = undefined;\n    this.headSubLink = undefined;\n    this.tailSubLink = undefined;\n    this.flags = this.getInitialFlags();\n\n    this.valueGetter = valueGetter;\n    this.cleanupFn = undefined;\n\n    this.trackThis();\n    this.runWithTracking();\n  }\n\n  private getInitialFlags(): Flags {\n    // 在创建完成后即进入观察状态，因此初始时添加 Watching 标记\n    return flags().setWatching();\n  }\n\n  trackThis(): void {\n    track(this);\n  }\n\n  private cleanup(): void {\n    this.cleanupFn?.();\n    this.cleanupFn = undefined;\n  }\n\n  private runWithTracking(): V {\n    const result = withTracking(this, () => {\n      this.cleanup();\n\n      const isInitializingRun = isVoid(this.value) === true;\n\n      if (isInitializingRun === true) {\n        const context: EffectValueGetterContext<V> = {\n          setCleanup: (cleanup) => {\n            this.cleanupFn = cleanup;\n          },\n          isInitializingRun,\n        }\n        const value = this.valueGetter(context);\n        this.value = value;\n        return value;\n      } else {\n        const context: EffectValueGetterContext<V> = {\n          setCleanup: (cleanup) => {\n            this.cleanupFn = cleanup;\n          },\n          isInitializingRun,\n          previousValue: this.value,\n        }\n        const value = this.valueGetter(context);\n        this.value = value;\n        return value;\n      }\n    })\n\n    return result;\n  }\n\n  reset(): void {\n    this.flags = this.getInitialFlags();\n  }\n\n  dispose(): void {\n    this.cleanup();\n    removeAllDepLinksOfNode(this);\n    removeAllSubLinksOfNode(this);\n    this.reset();\n    this.triggerOnDispose();\n  }\n\n  notify(): void {\n    this.flags.unsetWatching();\n  }\n\n  run(): void {\n    // 如果包含 Pending 标记，则进行解决\n    const shouldResolve = this.flags.hasPending();\n    if (shouldResolve === true) {\n      resolvePending(this);\n    }\n\n    // order matters:\n    //  - 需要在 resolvePending 之后，因为：resolvePending 时可能触发 shallowPropagate，\n    //    进而触发 notify，notify 只会作用于包含 Watching 标记的节点。\n    //  - 需要在 runWithTracking 之前，因为：Signal 只会 track 包含 Watching 标记的 Effect。\n    this.flags.setWatching();\n\n    // 如果包含 Dirty 标记，则进行更新\n    const shouldRun = this.flags.hasDirty();\n    if (shouldRun === true) {\n      this.runWithTracking();\n    }\n  }\n}\n\nexport interface BaseEffectScopeValueGetterContext extends BaseEffectValueGetterContext { }\nexport interface InitializingEffectScopeValueGetterContext\n  extends BaseEffectScopeValueGetterContext, InitializingEffectValueGetterContext { }\nexport interface UpdatingEffectScopeValueGetterContext<V>\n  extends BaseEffectScopeValueGetterContext, UpdatingEffectValueGetterContext<V> {\n}\nexport type EffectScopeValueGetterContext<V> =\n  | InitializingEffectScopeValueGetterContext\n  | UpdatingEffectScopeValueGetterContext<V>;\nexport type EffectScopeValueGetter<V> = (context: EffectScopeValueGetterContext<V>) => V;\nexport interface EffectScopeOptions extends BaseReactorOptions {\n}\nexport class EffectScope<V = void> extends BaseReactor<V> {\n  private valueGetter: EffectScopeValueGetter<V>;\n  private cleanupFn: CleanupFn | void;\n\n  constructor(valueGetter: EffectScopeValueGetter<V>, options: EffectScopeOptions) {\n    super(options);\n    this.headDepLink = undefined;\n    this.tailDepLink = undefined;\n    this.headSubLink = undefined;\n    this.tailSubLink = undefined;\n    this.flags = this.getInitialFlags();\n\n    this.valueGetter = valueGetter;\n    this.cleanupFn = undefined;\n\n    this.trackThis();\n    this.runWithTracking();\n  }\n\n  private getInitialFlags(): Flags {\n    // 只负责管理作用域，不需要添加任何标记\n    return flags();\n  }\n\n  private cleanup(): void {\n    this.cleanupFn?.();\n    this.cleanupFn = undefined;\n  }\n\n  private runWithTracking(): V {\n    const result = withTracking(this, () => {\n      this.cleanup();\n\n      const isInitializingRun = isVoid(this.value) === true;\n\n      if (isInitializingRun === true) {\n        const context: EffectScopeValueGetterContext<V> = {\n          setCleanup: (cleanup) => {\n            this.cleanupFn = cleanup;\n          },\n          isInitializingRun,\n        }\n        const value = this.valueGetter(context);\n        this.value = value;\n        return value;\n      } else {\n        const context: EffectScopeValueGetterContext<V> = {\n          setCleanup: (cleanup) => {\n            this.cleanupFn = cleanup;\n          },\n          isInitializingRun,\n          previousValue: this.value,\n        }\n        const value = this.valueGetter(context);\n        this.value = value;\n        return value;\n      }\n    })\n\n    return result;\n  }\n\n  trackThis(): void {\n    track(this);\n  }\n\n  reset(): void {\n    this.flags = this.getInitialFlags();\n  }\n\n  dispose(): void {\n    this.cleanup();\n    removeAllDepLinksOfNode(this);\n    removeAllSubLinksOfNode(this);\n    this.reset();\n    this.triggerOnDispose();\n  }\n}\n\nexport interface BaseTriggerValueGetterContext {\n  setCleanup: (cleanup: CleanupFn) => void;\n}\nexport interface InitializingTriggerValueGetterContext extends BaseTriggerValueGetterContext {\n  isInitializingRun: true;\n}\nexport interface UpdatingTriggerValueGetterContext<V> extends BaseTriggerValueGetterContext {\n  isInitializingRun: false;\n  previousValue: V;\n}\nexport type TriggerValueGetterContext<V> =\n  | InitializingTriggerValueGetterContext\n  | UpdatingTriggerValueGetterContext<V>\nexport type TriggerValueGetter<V> = (context: TriggerValueGetterContext<V>) => V;\nexport interface TriggerOptions extends BaseReactorOptions {\n}\nexport class Trigger<V = void> extends BaseReactor<V> {\n  private valueGetter: TriggerValueGetter<V>;\n  private cleanupFn: CleanupFn | void;\n\n  constructor(valueGetter: TriggerValueGetter<V>, options: TriggerOptions) {\n    super(options);\n    this.headDepLink = undefined;\n    this.tailDepLink = undefined;\n    this.headSubLink = undefined;\n    this.tailSubLink = undefined;\n    this.flags = this.getInitialFlags();\n\n    this.valueGetter = valueGetter;\n    this.cleanupFn = undefined;\n\n    this.runWithTracking();\n  }\n\n  private getInitialFlags(): Flags {\n    return flags().setWatching();\n  }\n\n  private cleanup(): void {\n    this.cleanupFn?.();\n    this.cleanupFn = undefined;\n  }\n\n  private runWithTracking(): V {\n    // 以依赖收集的方式获取目标 Signals\n    const result = withTracking(this, () => {\n      this.cleanup();\n\n      const isInitializingRun = isVoid(this.value) === true;\n\n      if (isInitializingRun === true) {\n        const context: TriggerValueGetterContext<V> = {\n          isInitializingRun,\n          setCleanup: (cleanup) => {\n            this.cleanupFn = cleanup;\n          },\n        }\n        const value = this.valueGetter(context);\n        this.value = value;\n        return value\n      } else {\n        const context: TriggerValueGetterContext<V> = {\n          isInitializingRun,\n          setCleanup: (cleanup) => {\n            this.cleanupFn = cleanup;\n          },\n          previousValue: this.value,\n        }\n        const value = this.valueGetter(context);\n        this.value = value;\n        return value\n      }\n\n    })\n\n    // 移除目标 Singals 与当前 Signal 之间的连接，并触发更新机制\n    const targetDeps = removeAllDepLinksOfNode(this);\n    targetDeps.forEach(dep => {\n      deeeeepPropagate(dep);\n      shallowPropagate(dep);\n    })\n\n    // 执行更新队列\n    flushBatch();\n\n    this.dispose();\n\n    return result;\n  }\n\n  trackThis(): void {\n    track(this);\n  }\n\n  reset(): void {\n    this.flags = this.getInitialFlags();\n  }\n\n  dispose(): void {\n    this.cleanup();\n    removeAllDepLinksOfNode(this);\n    removeAllSubLinksOfNode(this);\n    this.reset();\n    this.triggerOnDispose();\n  }\n}\n\nexport const isReactor = (target: unknown): target is BaseReactor => {\n  return target instanceof BaseReactor;\n}\n\nexport const isSignal = <V>(target: unknown): target is Signal<V> => {\n  return target instanceof Signal;\n}\nexport const signal = <V>(valueInitializer: SignalValueInitializer<V>, options?: SignalOptions<V>): Signal<V> => {\n  return new Signal(valueInitializer, options ?? {});\n}\nexport const isDerived = <V>(target: unknown): target is Derived<V> => {\n  return target instanceof Derived;\n}\nexport const derived = <V>(valueGetter: DerivedValueGetter<V>, options?: DerivedOptions<V>): Derived<V> => {\n  return new Derived(valueGetter, options ?? {});\n}\nexport const isComputed = <V>(target: unknown): target is Computed<V> => {\n  return target instanceof Computed;\n}\nexport const computed = <V>(valueGetter: ComputedValueGetter<V>, options?: ComputedOptions<V>): Computed<V> => {\n  return new Computed(valueGetter, options ?? {});\n}\nexport const isEffect = <V>(target: unknown): target is Effect<V> => {\n  return target instanceof Effect;\n}\nexport const effect = <V>(valueGetter: EffectValueGetter<V>, options?: EffectOptions): Effect<V> => {\n  return new Effect(valueGetter, options ?? {});\n}\nexport const isEffectScope = <V>(target: unknown): target is EffectScope<V> => {\n  return target instanceof EffectScope;\n}\nexport const effectScope = <V>(valueGetter: EffectScopeValueGetter<V>, options?: EffectScopeOptions): EffectScope<V> => {\n  return new EffectScope(valueGetter, options ?? {});\n}\nexport const isTrigger = <V>(target: unknown): target is Trigger<V> => {\n  return target instanceof Trigger;\n}\nexport const trigger = <V>(valueGetter: TriggerValueGetter<V>, options?: TriggerOptions): Trigger<V> => {\n  return new Trigger(valueGetter, options ?? {});\n}\n\nexport type ValueReactor<V = unknown> = Signal<V> | Derived<V> | Computed<V>;\nexport type ActionReactor<V = unknown> = Effect<V> | EffectScope<V> | Trigger<V>;\nexport const isValueReactor = <V>(target: unknown): target is ValueReactor<V> => {\n  return isSignal(target) || isDerived(target) || isComputed(target);\n}\nexport const isActionReactor = <V>(target: unknown): target is ActionReactor<V> => {\n  return isEffect(target) || isEffectScope(target) || isTrigger(target);\n}\n\n// oxlint-disable-next-line no-explicit-any\nexport type AnyReactor = BaseReactor<any>\n// oxlint-disable-next-line no-explicit-any\nexport type AnyValueReactor = ValueReactor<any>\n// oxlint-disable-next-line no-explicit-any\nexport type AnyActionReactor = ActionReactor<any>\n\nexport type ValueOfReactor<R extends AnyReactor> = R extends BaseReactor<infer V> ? V : never;\nexport type ValueOfValueReactor<R extends AnyValueReactor> = R extends ValueReactor<infer V> ? V : never;\nexport type ValueOfActionReactor<R extends AnyActionReactor> = R extends ActionReactor<infer V> ? V : never;\n",
+    "import type { ValueReactor } from \"../reactor-core/index.ts\"\n\nimport { effect } from \"../reactor-core/index.ts\"\n\nexport type ValueInitializer<V> = () => V;\n/**\n * This initializer can be used to create a Signal with an undefined initial value which\n * is casted to the desired type T. So the real value getter function will not be called\n * until the Signal is actually used.\n *\n * Every signal should always have a valid value (or value getter which returns a valid value).\n * When using the castValueInitializer, the real value should be set as soon as possible.\n */\nexport const castValueInitializer = <V>(): ValueInitializer<V> => {\n  return (): V => {\n    // oxlint-disable-next-line no-unsafe-return no-unsafe-type-assertion\n    return undefined as unknown as V\n  }\n}\n\nexport type Unsubscribe = () => void\nexport interface SubscribeOptions<V> {\n  target: ValueReactor<V>;\n  subscriber: (value: V) => void;\n}\n/**\n * Subscribes to a ValueReactor and invokes the subscriber when the reactor's value\n * changes.\n *\n * The initial value is skipped; the subscriber is called only on subsequent updates.\n */\nexport const subscribe = <V>(\n  options: SubscribeOptions<V>\n): Unsubscribe => {\n  const { target, subscriber } = options\n\n  const e = effect((context) => {\n    const { isInitializingRun } = context\n    const value = target.get()\n    if (isInitializingRun === false) {\n      subscriber(value)\n    }\n  })\n  const unsubscribe = (): void => {\n    e.dispose()\n  }\n  return unsubscribe\n}\n\n// oxlint-disable-next-line no-explicit-any\nexport type AnyValueReactorArray = Array<ValueReactor<any>>;\nexport type GetValuesInArray<T extends AnyValueReactorArray> = {\n  [K in keyof T]: T[K] extends ValueReactor<infer U> ? U : never\n}\nexport interface GetValuesInArrayOptions<T extends AnyValueReactorArray> {\n  target: T;\n  withoutTrack?: boolean;\n}\n/**\n * Gets the current values from an array of ValueReactors.\n */\nexport const getValuesInArray = <T extends AnyValueReactorArray>(\n  options: GetValuesInArrayOptions<T>\n): GetValuesInArray<T> => {\n  const valueReactors = options.target;\n  const withoutTrack = options?.withoutTrack ?? false;\n  // oxlint-disable-next-line no-unsafe-type-assertion\n  const values = valueReactors.map((vr) => {\n    // oxlint-disable-next-line no-unsafe-return\n    return withoutTrack ? vr.getWithoutTrack() : vr.get()\n  }) as unknown as GetValuesInArray<T>\n  return values\n}\n\n// oxlint-disable-next-line no-explicit-any\nexport type AnyValueReactorObject = Record<string, ValueReactor<any>>;\nexport type GetValuesInObject<T extends AnyValueReactorObject> = {\n  [K in keyof T]: T[K] extends ValueReactor<infer U> ? U : never\n}\nexport interface GetValueInObjectOptions<T extends AnyValueReactorObject> {\n  target: T;\n  withoutTrack?: boolean;\n}\n/**\n * Gets the current values from an object of ValueReactors.\n */\nexport const getValuesInObject = <T extends AnyValueReactorObject>(\n  options: GetValueInObjectOptions<T>\n): GetValuesInObject<T> => {\n  const valueReactors = options.target;\n  const withoutTrack = options?.withoutTrack ?? false;\n  // oxlint-disable-next-line no-unsafe-type-assertion\n  const values = {} as GetValuesInObject<T>\n  for (const key of Object.keys(valueReactors)) {\n    const valueReactor = valueReactors[key]!\n    // oxlint-disable-next-line no-unsafe-assignment\n    const value = withoutTrack ? valueReactor.getWithoutTrack() : valueReactor.get()\n    // oxlint-disable-next-line no-unsafe-assignment no-unsafe-member-access no-unsafe-type-assertion\n    values[key as unknown as keyof GetValuesInObject<T>] = value\n  }\n  return values\n}\n",
+    "import type { Signal, ValueReactor } from \"../reactor-core/index.ts\"\n\nimport { signal } from \"../reactor-core/index.ts\"\nimport { subscribe } from \"./utility.ts\"\n\nexport interface FromPromiseSyncOptions<V> {\n  target: Promise<V>;\n}\n/**\n * Converts a Promise into a Signal that updates its value\n * when the Promise resolves.\n *\n * @see {@link fromPromiseAsync} for an async version.\n */\nexport const fromPromiseSync = <V>(\n  options: FromPromiseSyncOptions<V>\n): Signal<V | undefined> => {\n  const { target } = options\n\n  const result = signal<V | undefined>(() => undefined)\n  void target.then((value) => {\n    return result.set(value)\n  })\n  return result\n}\n\nexport interface FromPromiseAsyncOptions<V> {\n  target: Promise<V>;\n}\n/**\n * Converts a Promise into a Signal that is initialized\n * with the resolved value of the Promise.\n *\n * @see {@link fromPromiseSync} for a sync version.\n */\nexport const fromPromiseAsync = async <V>(\n  options: FromPromiseAsyncOptions<V>\n): Promise<Signal<V>> => {\n  const { target } = options\n\n  const value = await target\n  const result = signal<V>(() => value)\n  return result\n}\n\nexport interface ToPromiseOptions<V> {\n  target: ValueReactor<V>;\n}\n/**\n * Converts a ValueReactor into a Promise that resolves\n * with the next value emitted by the ValueReactor.\n */\nexport const toPromise = async <V>(\n  options: ToPromiseOptions<V>\n): Promise<V> => {\n  const { target } = options\n\n  let _resolve: (value: V) => void\n  const promise = new Promise<V>((resolve) => {\n    _resolve = resolve\n  })\n  const unsubscribe = subscribe({\n    target,\n    subscriber: (value) => {\n      unsubscribe()\n      _resolve(value)\n    }\n  })\n  return await promise\n}\n",
+    "import type { Signal } from \"../reactor-core/index.ts\"\n\nimport { signal } from \"../reactor-core/index.ts\"\n\nexport interface TimerOptions {\n  delay: number\n  interval: number\n  initialValue?: number\n  step?: number\n}\n/**\n * Creates a signal that starts emitting values after a specified delay,\n * and continues to emit incremented values at specified intervals.\n *\n * The value starts at 0, becomes 1 after the delay, and increments by 1.\n */\nexport const timer = (\n  options: TimerOptions\n): Signal<number> => {\n  const { delay, interval, initialValue = 0, step = 1 } = options\n\n  const result = signal<number>(() => initialValue, {\n    onDispose: () => {\n      clearTimeout(timeoutId)\n      clearInterval(intervalId)\n    }\n  })\n\n  let intervalId: ReturnType<typeof setInterval> | undefined = undefined\n  const timeoutId = setTimeout(() => {\n    result.set(result.getWithoutTrack() + step)\n    intervalId = setInterval(() => {\n      result.set(result.getWithoutTrack() + step)\n    }, interval)\n  }, delay)\n\n  return result\n}\n\nexport interface IntervalOptions {\n  interval: number\n  initialValue?: number\n  step?: number\n}\n/**\n * Creates a signal that increments its value at specified intervals.\n *\n * The value starts at 0 and increments by 1 every interval.\n */\nexport const interval = (\n  options: IntervalOptions\n): Signal<number> => {\n  const { interval, initialValue = 0, step = 1 } = options\n\n  const result = signal<number>(() => initialValue, {\n    onDispose: () => {\n      clearInterval(intervalId)\n    }\n  })\n\n  const intervalId = setInterval(() => {\n    result.set(result.getWithoutTrack() + step)\n  }, interval)\n\n  return result\n}\n",
+    "import type { AnyValueReactorArray, AnyValueReactorObject, GetValuesInArray, GetValuesInObject } from \"./utility.ts\"\nimport type { Effect, Signal, ValueReactor } from \"../reactor-core/index.ts\"\n\nimport { castValueInitializer, getValuesInArray, getValuesInObject } from \"./utility.ts\"\nimport { effect, signal } from \"../reactor-core/index.ts\"\n\nexport type CombineLatestArray<T extends AnyValueReactorArray> = Signal<GetValuesInArray<T>>;\nexport interface CombineLatestArrayOptions<T extends AnyValueReactorArray> {\n  target: T;\n}\n/**\n * Combines multiple ValueReactors into a Signal that emits the latest values\n * from each ValueReactor whenever any of them updates.\n */\nexport const combineLatestArray = <T extends AnyValueReactorArray>(\n  options: CombineLatestArrayOptions<T>\n): CombineLatestArray<T> => {\n  const { target } = options;\n\n  const result = signal(castValueInitializer<GetValuesInArray<T>>(), {\n    onDispose: () => {\n      e.dispose()\n    }\n  })\n\n  const e = effect(() => {\n    result.set(getValuesInArray({ target }))\n  })\n\n  return result\n}\n\nexport type CombineLatestObject<T extends AnyValueReactorObject> = Signal<GetValuesInObject<T>>;\nexport interface CombineLatestObjectOptions<T extends AnyValueReactorObject> {\n  target: T;\n}\n/**\n * Combines multiple ValueReactors in an object into a Signal that emits the latest values\n * from each ValueReactor whenever any of them updates.\n */\nexport const combineLatestObject = <T extends AnyValueReactorObject>(\n  options: CombineLatestObjectOptions<T>\n): CombineLatestObject<T> => {\n  const { target } = options;\n\n  const result = signal(castValueInitializer<GetValuesInObject<T>>(), {\n    onDispose: () => {\n      e.dispose()\n    }\n  })\n\n  const e = effect(() => {\n    result.set(getValuesInObject({ target }))\n  })\n\n  return result\n}\n\nexport type MergeArray<T extends AnyValueReactorArray> = Signal<GetValuesInArray<T>[number]>;\nexport interface MergeArrayOptions<T extends AnyValueReactorArray> {\n  target: T;\n}\n/**\n * Merges multiple ValueReactors into a Signal that emits values\n * from any of the ValueReactors as they update.\n */\nexport const mergeArray = <T extends AnyValueReactorArray>(\n  options: MergeArrayOptions<T>\n): MergeArray<T> => {\n  const { target } = options;\n\n  const result = signal(castValueInitializer<GetValuesInArray<T>[number]>(), {\n    onDispose: () => {\n      for (const e of effects) {\n        e.dispose()\n      }\n    }\n  });\n\n  const effects: Effect[] = [];\n  for (const valueReactor of target) {\n    const e = effect(() => {\n      // oxlint-disable-next-line no-unsafe-type-assertion\n      const value = valueReactor.get() as GetValuesInArray<T>[number];\n      result.set(value)\n    })\n    effects.push(e)\n  }\n\n  return result\n}\n\nexport interface WithLatestFromOptions<T, U> {\n  target: ValueReactor<T>;\n  other: ValueReactor<U>;\n}\n/**\n * Combines two ValueReactors into a Signal that emits the latest values\n * from the source ValueReactor along with the latest value from the other ValueReactor.\n */\nexport const withLatestFrom = <T, U>(\n  options: WithLatestFromOptions<T, U>\n): Signal<[T, U]> => {\n  const { target, other } = options;\n\n  const result = signal(castValueInitializer<[T, U]>(), {\n    onDispose: () => {\n      eTarget.dispose()\n      eOther.dispose()\n    }\n  })\n\n  let lastOther = other.get()\n  const eOther = effect(() => {\n    const b = other.get()\n    lastOther = b\n  })\n  const eTarget = effect(() => {\n    const a = target.get()\n    result.set([a, lastOther])\n  })\n\n  return result\n}\n\nexport interface ZipOptions<VA, VB> {\n  a: ValueReactor<VA>;\n  b: ValueReactor<VB>;\n}\n/**\n * Zips two ValueReactors into a Signal that emits pairs of values.\n * Each time both ValueReactors have new values, a new pair is emitted.\n */\nexport const zip = <VA, VB>(\n  options: ZipOptions<VA, VB>\n): Signal<[VA, VB]> => {\n  const valueReactorA = options.a;\n  const valueReactorB = options.b;\n\n  let lastA = valueReactorA.getWithoutTrack()\n  let lastB = valueReactorB.getWithoutTrack()\n\n  const result = signal<[VA, VB]>(() => [lastA, lastB], {\n    onDispose: () => {\n      e.dispose()\n    }\n  })\n\n  const queueA: VA[] = []\n  const queueB: VB[] = []\n\n  const e = effect(() => {\n    const a = valueReactorA.get()\n    const b = valueReactorB.get()\n\n    if (a !== lastA) {\n      queueA.push(a)\n      lastA = a\n    }\n    if (b !== lastB) {\n      queueB.push(b)\n      lastB = b\n    }\n\n    if (queueA.length !== 0 && queueB.length !== 0) {\n      const va = queueA.shift()\n      const vb = queueB.shift()\n      // oxlint-disable-next-line no-unsafe-type-assertion\n      result.set([va, vb] as [VA, VB])\n    }\n  })\n\n  return result\n}\n",
+    "import type { Signal, ValueReactor } from \"../reactor-core/index.ts\"\n\nimport { castValueInitializer } from \"./utility.ts\"\nimport { effect, signal } from \"../reactor-core/index.ts\"\n\nexport interface CloneOptions<V> {\n  target: ValueReactor<V>;\n}\n/**\n * Creates a Signal that mirrors the value of the target ValueReactor.\n */\nexport const clone = <V>(\n  options: CloneOptions<V>\n): Signal<V> => {\n  const { target } = options;\n\n  const result = signal(castValueInitializer<V>(), {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  const eTarget = effect(() => {\n    const value = target.get()\n    result.set(value)\n  })\n\n  return result\n}\n\nexport interface PartitionOptions<V> {\n  target: ValueReactor<V>;\n  predicate: (value: V) => boolean;\n}\n/**\n * Partitions values from a ValueReactor into two Signals based on a predicate function.\n * The first Signal emits values that satisfy the predicate, while the second Signal\n * emits values that do not satisfy the predicate.\n */\nexport const partition = <V>(\n  options: PartitionOptions<V>\n): [Signal<V | undefined>, Signal<V | undefined>] => {\n  const { target, predicate } = options;\n\n  const trueSignal = signal(castValueInitializer<V | undefined>(), {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n  const falseSignal = signal(castValueInitializer<V | undefined>(), {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  const eTarget = effect(() => {\n    const value = target.get()\n    if (predicate(value) === true) {\n      trueSignal.set(value)\n    } else {\n      falseSignal.set(value)\n    }\n  })\n\n  return [trueSignal, falseSignal]\n}\n",
+    "import type { AnyValueReactor, Signal, ValueOfValueReactor, ValueReactor } from \"../reactor-core/index.ts\"\n\nimport { castValueInitializer } from \"./utility.ts\"\nimport { effect, signal } from \"../reactor-core/index.ts\"\n\nexport interface TapOptions<R extends AnyValueReactor> {\n  target: R;\n  tapper?: ((value: ValueOfValueReactor<R>) => void) | undefined;\n}\n/**\n * Taps into the value changes of a ValueReactor without modifying its value.\n */\nexport const tap = <R extends AnyValueReactor>(\n  options: TapOptions<R>\n): R => {\n  const { target, tapper = (value: ValueOfValueReactor<R>): void => console.log(value) } = options;\n\n  effect(() => {\n    // oxlint-disable-next-line no-unsafe-type-assertion\n    const value = target.get() as ValueOfValueReactor<R>\n    tapper(value)\n  })\n\n  return target\n}\n\nexport interface WithHistoryOptions<V> {\n  target: ValueReactor<V>;\n}\n/**\n * Creates a signal that maintains a history of values from a ValueReactor.\n * The history is stored in an array, with each new value appended to the end.\n *\n * Note: This implementation does not limit the size of the history array. Use\n * with caution to avoid excessive memory usage.\n */\nexport const withHistory = <V>(\n  options: WithHistoryOptions<V>\n): Signal<V[]> => {\n  const { target } = options;\n\n  const result = signal(castValueInitializer<V[]>(), {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  const history: V[] = []\n  const eTarget = effect(() => {\n    history.push(target.get())\n    result.set([...history])\n  })\n\n  return result\n}\n\nexport interface BufferByCountOptions<V> {\n  target: ValueReactor<V>;\n  count: number;\n}\n/**\n * Buffers values from a ValueReactor and emits them as an array\n * when the number of buffered values reaches the specified count.\n */\nexport const bufferByCount = <V>(\n  options: BufferByCountOptions<V>\n): Signal<V[]> => {\n  const { target, count } = options;\n\n  if (count <= 0) {\n    throw new Error(\"bufferByCount operator requires count to be greater than 0\")\n  }\n\n  const result = signal<V[]>(() => [], {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  const bufferedValues: V[] = []\n  const eTarget = effect(() => {\n    bufferedValues.push(target.get())\n    if (bufferedValues.length >= count) {\n      result.set([...bufferedValues])\n      bufferedValues.length = 0\n    }\n  })\n\n  return result\n}\n\nexport interface BufferByTimeOptions<V> {\n  target: ValueReactor<V>;\n  time: number;\n}\n/**\n * Buffers values from a ValueReactor and emits them as an array\n * at specified time intervals.\n */\nexport const bufferByTime = <V>(\n  options: BufferByTimeOptions<V>\n): Signal<V[]> => {\n  const { target, time } = options;\n\n  if (time <= 0) {\n    throw new Error(\"bufferByTime operator requires timeInMilliseconds to be greater than 0\")\n  }\n\n  const result = signal<V[]>(() => [], {\n    onDispose: () => {\n      eTarget.dispose()\n      clearInterval(intervalId)\n    }\n  })\n\n  const bufferedValues: V[] = []\n  const eTarget = effect(() => {\n    bufferedValues.push(target.get())\n  })\n\n  const intervalId = setInterval(() => {\n    result.set([...bufferedValues])\n    bufferedValues.length = 0\n  }, time)\n\n  return result\n}\n\nexport interface BufferByTriggerOptions<VTarget, VTrigger> {\n  target: ValueReactor<VTarget>;\n  trigger: ValueReactor<VTrigger>;\n}\n/**\n * Buffers values from a ValueReactor and emits them as an array when the trigger ValueReactor changes.\n */\nexport const bufferByTrigger = <VTarget, VTrigger>(\n  options: BufferByTriggerOptions<VTarget, VTrigger>\n): Signal<VTarget[]> => {\n  const { target, trigger } = options;\n\n  const result = signal(castValueInitializer<VTarget[]>(), {\n    onDispose: () => {\n      eTarget.dispose()\n      eTrigger.dispose()\n    }\n  })\n\n  const bufferedValues: VTarget[] = []\n  const eTarget = effect(() => {\n    bufferedValues.push(target.get())\n  })\n\n  const eTrigger = effect(() => {\n    trigger.get()\n    result.set([...bufferedValues])\n    bufferedValues.length = 0\n  })\n\n  return result\n}\n\nexport interface BufferByToggleOptions<VTarget, VOpen, VClose> {\n  target: ValueReactor<VTarget>;\n  open: ValueReactor<VOpen>;\n  close: ValueReactor<VClose>;\n}\n/**\n * Buffers values from a ValueReactor and emits them as an array\n * when the open ValueReactor emits a value, and stops buffering\n * when the close ValueReactor emits a value.\n */\nexport const bufferByToggle = <VTarget, VOpen, VClose>(\n  options: BufferByToggleOptions<VTarget, VOpen, VClose>\n): Signal<VTarget[]> => {\n  const { target, open, close } = options;\n\n  const result = signal(castValueInitializer<VTarget[]>(), {\n    onDispose: () => {\n      eTarget.dispose()\n      eOpen.dispose()\n      eClose.dispose()\n    }\n  })\n\n  const bufferedValues: VTarget[] = []\n  let buffering = false\n\n  const eOpen = effect(() => {\n    open.get()\n    buffering = true\n  })\n\n  const eTarget = effect(() => {\n    const value = target.get()\n    if (buffering === true) {\n      bufferedValues.push(value)\n    }\n  })\n\n  const eClose = effect(() => {\n    close.get()\n    if (buffering === true) {\n      result.set([...bufferedValues])\n      bufferedValues.length = 0\n      buffering = false\n    }\n  })\n\n  return result\n}\n\nexport interface BufferByDynamicOptions<VTarget, VDynamic> {\n  target: ValueReactor<VTarget>;\n  dynamic: (value: VTarget) => ValueReactor<VDynamic>;\n}\n/**\n * Buffers values from a ValueReactor and emits them as an array\n * when the ValueReactor returned by the `dynamic` function emits a value.\n * The `dynamic` function is called each time the buffer is emitted\n * to get a new ValueReactor for the next buffer.\n */\nexport const bufferByDynamic = <VTarget, VDynamic>(\n  options: BufferByDynamicOptions<VTarget, VDynamic>\n): Signal<VTarget[]> => {\n  const { target, dynamic } = options;\n\n  const result = signal(castValueInitializer<VTarget[]>(), {\n    onDispose: () => {\n      eTarget.dispose()\n      eDynamic.dispose()\n    }\n  })\n\n  const bufferedValues: VTarget[] = []\n  const eTarget = effect(() => {\n    const value = target.get()\n    bufferedValues.push(value)\n  })\n\n  let trigger: ValueReactor<VDynamic> | undefined = undefined\n  const eDynamic = effect(() => {\n    trigger?.dispose()\n    const targetValue = target.getWithoutTrack()\n    trigger = dynamic(targetValue)\n    trigger.get()\n    result.set([...bufferedValues])\n    bufferedValues.length = 0\n  })\n\n  return result\n}\n\nexport interface GroupToArrayByOptions<V, K> {\n  target: ValueReactor<V>;\n  keyGetter: (value: V) => K;\n}\n/**\n * Groups values from a ValueReactor into an array of arrays based on a key\n * extracted by the keyGetter function.\n */\nexport const groupToArrayBy = <V, K>(\n  options: GroupToArrayByOptions<V, K>\n): Signal<V[][]> => {\n  const { target, keyGetter } = options;\n\n  const result = signal<V[][]>(() => [], {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  const groups = new Map<K, V[]>()\n  const eTarget = effect(() => {\n    const value = target.get()\n    const key = keyGetter(value)\n    if (groups.has(key) === false) {\n      groups.set(key, [])\n      result.set([...groups.values()])\n    }\n    const groupedArray = groups.get(key)!\n    groupedArray.push(value)\n  })\n\n  return result\n}\n\nexport interface GroupToObjectByOptions<V, K extends string | number | symbol> {\n  target: ValueReactor<V>;\n  keyGetter: (value: V) => K;\n}\n/**\n * Groups values from a ValueReactor into an object where each key maps to an array\n * of values corresponding to that key.\n */\nexport const groupToObjectBy = <V, K extends string | number | symbol>(\n  options: GroupToObjectByOptions<V, K>\n): Signal<Record<K, V[]>> => {\n  const { target, keyGetter } = options;\n\n  const result = signal<Record<K, V[]>>(() => {\n    // oxlint-disable-next-line no-unsafe-type-assertion\n    return {} as Record<K, V[]>\n  }, {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  const groups = new Map<K, V[]>()\n  const eTarget = effect(() => {\n    const value = target.get()\n    const key = keyGetter(value)\n    if (groups.has(key) === false) {\n      groups.set(key, [])\n      // oxlint-disable-next-line no-unsafe-type-assertion\n      result.set(Object.fromEntries(groups.entries()) as Record<K, V[]>)\n    }\n    const groupedArray = groups.get(key)!\n    groupedArray.push(value)\n  })\n\n  return result\n}\n\n/**\n * Groups values from a ValueReactor into an array of Signals based on a key\n * extracted by the keyGetter function.\n */\nexport const groupToSignalArrayBy = <V, K>(\n  target: ValueReactor<V>, keyGetter: (value: V) => K\n): Signal<Array<Signal<V[]>>> => {\n  const result = signal<Array<Signal<V[]>>>(() => [], {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  const groups = new Map<K, Signal<V[]>>()\n  const eTarget = effect(() => {\n    const value = target.get()\n    const key = keyGetter(value)\n    if (groups.has(key) === false) {\n      const newGroup = signal<V[]>(() => [])\n      groups.set(key, newGroup)\n      result.set([...groups.values()])\n    }\n    const groupedSignal = groups.get(key)!\n    const currentArray = groupedSignal.get()\n    groupedSignal.set([...currentArray, value])\n  })\n\n  return result\n}\n\nexport interface GroupToSignalObjectByOptions<V, K extends string | number | symbol> {\n  target: ValueReactor<V>;\n  keyGetter: (value: V) => K;\n}\n/**\n * Groups values from a ValueReactor into a Signal of an object where each key maps to a Signal\n * of an array of values corresponding to that key.\n */\nexport const groupToSignalObjectBy = <V, K extends string | number | symbol>(\n  options: GroupToSignalObjectByOptions<V, K>\n): Signal<Record<K, Signal<V[]>>> => {\n  const { target, keyGetter } = options;\n\n  const result = signal<Record<K, Signal<V[]>>>(() => {\n    // oxlint-disable-next-line no-unsafe-type-assertion\n    return {} as Record<K, Signal<V[]>>\n  }, {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  const groups = new Map<K, Signal<V[]>>()\n  const eTarget = effect(() => {\n    const value = target.get()\n    const key = keyGetter(value)\n    if (groups.has(key) === false) {\n      const newGroup = signal<V[]>(() => [])\n      groups.set(key, newGroup)\n      // oxlint-disable-next-line no-unsafe-type-assertion\n      result.set(Object.fromEntries(groups.entries()) as Record<K, Signal<V[]>>)\n    }\n    const groupedSignal = groups.get(key)!\n    const currentArray = groupedSignal.get()\n    groupedSignal.set([...currentArray, value])\n  })\n\n  return result\n}\n\nexport interface MapOptions<VTarget, VMapped> {\n  target: ValueReactor<VTarget>;\n  mapper: (value: VTarget) => VMapped;\n}\n/**\n * Maps values from a ValueReactor using the provided mapper function and\n * emits the mapped values as a new Signal.\n */\nexport const map = <VTarget, VMapped>(\n  options: MapOptions<VTarget, VMapped>\n): Signal<VMapped> => {\n  const { target, mapper } = options;\n\n  const result = signal(castValueInitializer<VMapped>(), {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  const eTarget = effect(() => {\n    const value = target.get()\n    const newValue = mapper(value)\n    result.set(newValue)\n  })\n\n  return result\n}\n\nexport interface ContextualMapInitializingMapperContext<VTarget> {\n  isInitializingRun: true;\n  targetValue: VTarget\n}\nexport interface ContextualMapUpdatingMapperContext<VTarget, VMapped> {\n  isInitializingRun: false;\n  targetValue: VTarget\n  previousMappedValue: VMapped\n}\nexport type ContextualMapMapperContextOf<VTarget, VMapped> =\n  | ContextualMapInitializingMapperContext<VTarget>\n  | ContextualMapUpdatingMapperContext<VTarget, VMapped>;\n\nexport interface ContextualMapOptions<VTarget, VMapped> {\n  target: ValueReactor<VTarget>;\n  mapper: (context: ContextualMapMapperContextOf<VTarget, VMapped>) => VMapped;\n}\n/**\n * Maps values from a ValueReactor using the provided contextual mapper function and\n * emits the mapped values as a new Signal.\n */\nexport const contextualMap = <VTarget, VMapped>(\n  options: ContextualMapOptions<VTarget, VMapped>\n): Signal<VMapped> => {\n  const { target, mapper } = options;\n\n  const result = signal(castValueInitializer<VMapped>(), {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  const eTarget = effect((context) => {\n    const targetValue = target.get()\n    const { isInitializingRun } = context\n    if (isInitializingRun === true) {\n      const newValue = mapper({\n        isInitializingRun,\n        targetValue\n      })\n      result.set(newValue)\n    } else {\n      const previousMappedValue = result.getWithoutTrack()\n      const newValue = mapper({\n        isInitializingRun,\n        targetValue,\n        previousMappedValue\n      })\n      result.set(newValue)\n    }\n  })\n\n  return result\n}\n\nexport interface MergeMapOptions<VTarget, VMapped> {\n  target: ValueReactor<VTarget>;\n  mapper: (value: VTarget) => ValueReactor<VMapped>;\n}\n/**\n * Maps each value from a ValueReactor<T> to a ValueReactor<R> using the provided `mapper`,\n * subscribes to every mapped reactor, and merges their emitted values into a single `Signal<R>`.\n */\nexport const mergeMap = <VTarget, VMapped>(\n  options: MergeMapOptions<VTarget, VMapped>\n): Signal<VMapped> => {\n  const { target, mapper } = options;\n\n  const result = signal(castValueInitializer<VMapped>(), {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  const eTarget = effect(() => {\n    const value = target.get()\n    const currentMappedReactor = mapper(value);\n\n    effect(() => {\n      const mappedValue = currentMappedReactor.get()\n      result.set(mappedValue)\n    })\n  })\n\n  return result\n}\n\nexport interface SwitchMapOptions<VTarget, VMapped> {\n  target: ValueReactor<VTarget>;\n  mapper: (value: VTarget) => ValueReactor<VMapped>;\n}\n/**\n * Maps each value from a ValueReactor<T> to a ValueReactor<R> using the provided `mapper`,\n * subscribes only to the latest mapped reactor, and emits its values as a `Signal<R>`.\n */\nexport const switchMap = <VTarget, VMapped>(\n  options: SwitchMapOptions<VTarget, VMapped>\n): Signal<VMapped> => {\n  const { target, mapper } = options;\n\n  const result = signal(castValueInitializer<VMapped>(), {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  let lastMappedReactor: ValueReactor<VMapped> | undefined = undefined\n\n  const eTarget = effect(() => {\n    const value = target.get()\n    lastMappedReactor?.dispose()\n    lastMappedReactor = mapper(value);\n    effect(() => {\n      const mappedValue = lastMappedReactor!.get()\n      result.set(mappedValue)\n    })\n  })\n\n  return result\n}\n\nexport interface ScanOptions<VTarget, VAccumulated> {\n  target: ValueReactor<VTarget>;\n  accumulator: (acc: VAccumulated, value: VTarget) => VAccumulated;\n  seed: VAccumulated;\n}\n/**\n * Accumulates values from a ValueReactor using the provided accumulator function\n * and emits the accumulated value as a Signal.\n */\nexport const scan = <VTarget, VAccumulated>(\n  options: ScanOptions<VTarget, VAccumulated>\n): Signal<VAccumulated> => {\n  const { target, accumulator, seed } = options;\n\n  const result = signal(() => seed, {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  const eTarget = effect(() => {\n    const value = target.get()\n    const newValue = accumulator(result.getWithoutTrack(), value)\n    result.set(newValue)\n  })\n\n  return result\n}\n\nexport interface PairwiseOptions<V> {\n  target: ValueReactor<V>;\n}\n/**\n * Emits the previous and current values from a ValueReactor as a tuple.\n * The first emitted tuple will have `undefined` as the previous value.\n */\nexport const pairwise = <V>(\n  options: PairwiseOptions<V>\n): Signal<[V | undefined, V]> => {\n  const { target } = options;\n\n  const result = signal<[V | undefined, V]>(() => [undefined, target.get()], {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  let previousValue: V | undefined = undefined\n  const eTarget = effect(() => {\n    const currentValue = target.get()\n    result.set([previousValue, currentValue])\n    previousValue = currentValue\n  })\n\n  return result\n}\n",
+    "import type { Signal, SignalValueInitializer, ValueReactor } from \"../reactor-core/index.ts\"\n\nimport { castValueInitializer } from \"./utility.ts\"\nimport { effect, signal } from \"../reactor-core/index.ts\"\n\nexport interface CurrentOptions<V> {\n  target: ValueReactor<V>;\n}\n/**\n * Returns a Signal that holds the current value of the target ValueReactor.\n */\nexport const current = <V>(\n  options: CurrentOptions<V>\n): Signal<V> => {\n  const { target } = options;\n\n  const result = signal<V>(() => {\n    return target.get()\n  })\n\n  return result\n}\n\nexport interface NextOptions<V> {\n  target: ValueReactor<V>;\n  valueInitializer: SignalValueInitializer<V>\n}\n/**\n * Returns a Signal that holds the next value of the target ValueReactor\n * after the initial value.\n *\n * The Signal will update its value only once, upon the next change of\n * the target ValueReactor, and then it will not update anymore.\n */\nexport const next = <V>(\n  options: NextOptions<V>\n): Signal<V> => {\n  const { target, valueInitializer } = options;\n\n  const result = signal(valueInitializer, {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  const eTarget = effect((context) => {\n    const { isInitializingRun } = context\n\n    const value = target.get()\n    if (isInitializingRun === false) {\n      result.set(value)\n      eTarget.dispose()\n    }\n  })\n\n  return result\n}\n\nexport interface FilterInitializingFalsyValueGetterContext<V> {\n  isInitializingRun: true;\n  targetValue: V\n}\nexport interface FilterUpdatingFalsyValueGetterContext<V> {\n  isInitializingRun: false;\n  targetValue: V\n  previousValue: V\n}\nexport type FilterFalsyValueGetterContextOf<V> =\n  | FilterInitializingFalsyValueGetterContext<V>\n  | FilterUpdatingFalsyValueGetterContext<V>\nexport interface FilterOptions<V> {\n  target: ValueReactor<V>;\n  truthyPredicate: (value: V) => boolean;\n  falsyValueGetter: (context: FilterFalsyValueGetterContextOf<V>) => V;\n}\n/**\n * Returns a Signal that only updates its value from the target\n * ValueReactor when the predicate function returns true.\n */\nexport const filter = <V>(\n  options: FilterOptions<V>\n): Signal<V> => {\n  const { target, truthyPredicate, falsyValueGetter } = options;\n\n  const result = signal<V>(castValueInitializer<V>(), {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  const eTarget = effect((context) => {\n    const value = target.get()\n    if (truthyPredicate(value) === true) {\n      result.set(value)\n    } else {\n      const { isInitializingRun } = context\n      if (isInitializingRun === true) {\n        const fallbackValue = falsyValueGetter({\n          isInitializingRun,\n          targetValue: value\n        })\n        result.set(fallbackValue)\n      } else {\n        const fallbackValue = falsyValueGetter({\n          isInitializingRun,\n          targetValue: value,\n          previousValue: result.getWithoutTrack()\n        })\n        result.set(fallbackValue)\n      }\n    }\n  })\n\n  return result\n}\n\nexport interface AuditByCountOptions<V> {\n  target: ValueReactor<V>;\n  count: number;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor after every specified count of emissions.\n */\nexport const auditByCount = <V>(\n  options: AuditByCountOptions<V>\n): Signal<V> => {\n  const { target, count } = options;\n\n  if (count <= 0) {\n    throw new Error(\"auditByCount operator requires count to be greater than 0\")\n  }\n\n\n  const result = signal(castValueInitializer<V>(), {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  let emissionCount = 0\n  const eTarget = effect((context) => {\n    const latestValue = target.get()\n\n    if (context.isInitializingRun === true) {\n      result.set(latestValue)\n    } else {\n      emissionCount = emissionCount + 1\n      if (emissionCount >= count) {\n        result.set(latestValue)\n        emissionCount = 0\n      }\n    }\n  })\n\n  return result\n}\n\nexport interface AuditByTimeOptions<V> {\n  target: ValueReactor<V>;\n  time: number;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor at specified time intervals.\n */\nexport const auditByTime = <V>(\n  options: AuditByTimeOptions<V>\n): Signal<V> => {\n  const { target, time } = options;\n\n  if (time <= 0) {\n    throw new Error(\"auditByTime operator requires timeInMilliseconds to be greater than 0\")\n  }\n\n  const result = signal<V>(() => target.getWithoutTrack(), {\n    onDispose: () => {\n      clearInterval(intervalId)\n    }\n  })\n\n  const intervalId = setInterval(() => {\n    result.set(target.getWithoutTrack())\n  }, time)\n\n  return result\n}\n\nexport interface AuditByTriggerOptions<VTarget, VTrigger> {\n  target: ValueReactor<VTarget>;\n  trigger: ValueReactor<VTrigger>;\n}\n/**\n * Returns a Signal that only updates its value when the trigger\n * ValueReactor emits a value, using the latest value from the target\n * ValueReactor.\n */\nexport const auditByTrigger = <VTarget, VTrigger>(\n  options: AuditByTriggerOptions<VTarget, VTrigger>\n): Signal<VTarget> => {\n  const { target, trigger } = options;\n\n  const result = signal<VTarget>(castValueInitializer<VTarget>(), {\n    onDispose: () => {\n      eTrigger.dispose()\n    }\n  })\n\n  const eTrigger = effect(() => {\n    trigger.get()\n    result.set(target.getWithoutTrack())\n  })\n\n  return result\n}\n\nexport interface AuditByToggleOptions<VTarget, VOpen, VClose> {\n  target: ValueReactor<VTarget>;\n  open: ValueReactor<VOpen>;\n  close: ValueReactor<VClose>;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor when the close ValueReactor emits, but only\n * if auditing was started by the open ValueReactor.\n */\nexport const auditByToggle = <VTarget, VOpen, VClose>(\n  options: AuditByToggleOptions<VTarget, VOpen, VClose>\n): Signal<VTarget> => {\n  const { target, open, close } = options;\n\n  const result = signal(castValueInitializer<VTarget>(), {\n    onDispose: () => {\n      eTarget.dispose()\n      eOpen.dispose()\n      eClose.dispose()\n    }\n  })\n\n  let auditValue: VTarget | undefined = undefined\n  let auditing = false\n\n  const eOpen = effect(() => {\n    open.get()\n    auditing = true\n  })\n\n  const eTarget = effect(() => {\n    const value = target.get()\n    if (auditing === true) {\n      auditValue = value\n    }\n  })\n\n  const eClose = effect(() => {\n    close.get()\n    if (auditing === true) {\n      if (auditValue !== undefined) {\n        result.set(auditValue)\n      }\n      auditing = false\n      auditValue = undefined\n    }\n  })\n\n  return result\n}\n\nexport interface AuditByDynamicOptions<VTarget, VDynamic> {\n  target: ValueReactor<VTarget>;\n  dynamic: (value: VTarget) => ValueReactor<VDynamic>;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor when the ValueReactor returned by the `dynamic`\n * function emits. The `dynamic` function is called each time after emitting\n * to get a new ValueReactor for the next audit period.\n */\nexport const auditByDynamic = <VTarget, VDynamic>(\n  options: AuditByDynamicOptions<VTarget, VDynamic>\n): Signal<VTarget> => {\n  const { target, dynamic } = options;\n\n  const result = signal(castValueInitializer<VTarget>(), {\n    onDispose: () => {\n      eDynamic.dispose()\n    }\n  })\n\n  let trigger: ValueReactor<VDynamic> | undefined = undefined\n  const eDynamic = effect(() => {\n    trigger?.dispose()\n    const targetValue = target.getWithoutTrack()\n    trigger = dynamic(targetValue)\n    trigger.get()\n    result.set(targetValue)\n  })\n\n  return result\n}\n\nexport interface DebounceByCountOptions<V> {\n  target: ValueReactor<V>;\n  count: number;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor after the specified count of emissions\n * without being updated.\n */\nexport const debounceByCount = <V>(\n  options: DebounceByCountOptions<V>\n): Signal<V> => {\n  const { target, count } = options;\n\n  if (count <= 0) {\n    throw new Error(\"debounceByCount operator requires count to be greater than 0\")\n  }\n\n  const result = signal(castValueInitializer<V>(), {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  let emissionCount = 0\n  const eTarget = effect((context) => {\n    const latestValue = target.get()\n\n    if (context.isInitializingRun === true) {\n      result.set(latestValue)\n    } else {\n      emissionCount = emissionCount + 1\n      if (emissionCount >= count) {\n        result.set(latestValue)\n        emissionCount = 0\n      }\n    }\n  })\n\n  return result\n}\n\nexport interface DebounceByTimeOptions<V> {\n  target: ValueReactor<V>;\n  time: number;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor after the specified time in milliseconds\n * has passed since the last update.\n */\nexport const debounceByTime = <V>(\n  options: DebounceByTimeOptions<V>\n): Signal<V> => {\n  const { target, time } = options;\n\n  if (time <= 0) {\n    throw new Error(\"debounceTime operator requires timeInMilliseconds to be greater than 0\")\n  }\n\n  let timeoutId: ReturnType<typeof setTimeout> | undefined = undefined\n\n  const result = signal<V>(castValueInitializer<V>(), {\n    onDispose: () => {\n      eTarget.dispose()\n      clearTimeout(timeoutId)\n    }\n  })\n\n  const eTarget = effect((context) => {\n    const latestValue = target.get()\n\n    if (context.isInitializingRun === true) {\n      result.set(latestValue)\n    } else {\n      clearTimeout(timeoutId)\n      timeoutId = setTimeout(() => {\n        result.set(latestValue)\n        timeoutId = undefined\n      }, time)\n    }\n  })\n\n  return result\n}\n\nexport interface DebounceByTriggerOptions<VTarget, VTrigger> {\n  target: ValueReactor<VTarget>;\n  trigger: ValueReactor<VTrigger>;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor whenever the trigger ValueReactor\n * emits a value.\n */\nexport const debounceByTrigger = <VTarget, VTrigger>(\n  options: DebounceByTriggerOptions<VTarget, VTrigger>\n): Signal<VTarget> => {\n  const { target, trigger } = options;\n\n  const result = signal<VTarget>(castValueInitializer<VTarget>(), {\n    onDispose: () => {\n      eTrigger.dispose()\n    }\n  })\n\n  const eTrigger = effect(() => {\n    trigger.get()\n    result.set(target.getWithoutTrack())\n  })\n\n  return result\n}\n\nexport interface DebounceByToggleOptions<VTarget, VOpen, VClose> {\n  target: ValueReactor<VTarget>;\n  open: ValueReactor<VOpen>;\n  close: ValueReactor<VClose>;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor when the close ValueReactor emits, but only\n * if debouncing was started by the open ValueReactor.\n */\nexport const debounceByToggle = <VTarget, VOpen, VClose>(\n  options: DebounceByToggleOptions<VTarget, VOpen, VClose>\n): Signal<VTarget> => {\n  const { target, open, close } = options;\n\n  const result = signal(castValueInitializer<VTarget>(), {\n    onDispose: () => {\n      eTarget.dispose()\n      eOpen.dispose()\n      eClose.dispose()\n    }\n  })\n\n  let debounceValue: VTarget | undefined = undefined\n  let debouncing = false\n\n  const eOpen = effect(() => {\n    open.get()\n    debouncing = true\n  })\n\n  const eTarget = effect(() => {\n    const value = target.get()\n    if (debouncing === true) {\n      debounceValue = value\n    }\n  })\n\n  const eClose = effect(() => {\n    close.get()\n    if (debouncing === true) {\n      if (debounceValue !== undefined) {\n        result.set(debounceValue)\n      }\n      debouncing = false\n      debounceValue = undefined\n    }\n  })\n\n  return result\n}\n\nexport interface DebounceByDynamicOptions<VTarget, VDynamic> {\n  target: ValueReactor<VTarget>;\n  dynamic: (value: VTarget) => ValueReactor<VDynamic>;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor when the ValueReactor returned by the `dynamic`\n * function emits. The `dynamic` function is called each time after emitting\n * to get a new ValueReactor for the next debounce period.\n */\nexport const debounceByDynamic = <VTarget, VDynamic>(\n  options: DebounceByDynamicOptions<VTarget, VDynamic>\n): Signal<VTarget> => {\n  const { target, dynamic } = options;\n\n  const result = signal(castValueInitializer<VTarget>(), {\n    onDispose: () => {\n      eDynamic.dispose()\n    }\n  })\n\n  let trigger: ValueReactor<VDynamic> | undefined = undefined\n  const eDynamic = effect(() => {\n    trigger?.dispose()\n    const targetValue = target.getWithoutTrack()\n    trigger = dynamic(targetValue)\n    trigger.get()\n    result.set(targetValue)\n  })\n\n  return result\n}\n\nexport interface ThrottleByCountOptions<V> {\n  target: ValueReactor<V>;\n  count: number;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor at most once every specified count of emissions.\n */\nexport const throttleByCount = <V>(\n  options: ThrottleByCountOptions<V>\n): Signal<V> => {\n  const { target, count } = options;\n\n  if (count <= 0) {\n    throw new Error(\"throttleByCount operator requires count to be greater than 0\")\n  }\n\n  const result = signal(castValueInitializer<V>(), {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  let emissionCount = 0\n  const eTarget = effect(() => {\n    const latestValue = target.get()\n    if (emissionCount === 0) {\n      result.set(latestValue)\n    }\n    emissionCount = emissionCount + 1\n    if (emissionCount >= count) {\n      emissionCount = 0\n    }\n  })\n\n  return result\n}\n\nexport interface ThrottleByTimeOptions<V> {\n  target: ValueReactor<V>;\n  time: number;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor at most once every specified time in milliseconds.\n */\nexport const throttleByTime = <V>(\n  options: ThrottleByTimeOptions<V>\n): Signal<V> => {\n  const { target, time } = options;\n\n  if (time <= 0) {\n    throw new Error(\"throttleByTime operator requires timeInMilliseconds to be greater than 0\")\n  }\n\n  const result = signal<V>(castValueInitializer<V>(), {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  let canEmit = true\n  const eTarget = effect(() => {\n    const latestValue = target.get()\n\n    if (canEmit === true) {\n      result.set(latestValue)\n      canEmit = false\n      setTimeout(() => {\n        canEmit = true\n      }, time)\n    }\n  })\n\n  return result\n}\n\nexport interface ThrottleByTriggerOptions<VTarget, VTrigger> {\n  target: ValueReactor<VTarget>;\n  trigger: ValueReactor<VTrigger>;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor at most once whenever the trigger\n * ValueReactor emits.\n */\nexport const throttleByTrigger = <VTarget, VTrigger>(\n  options: ThrottleByTriggerOptions<VTarget, VTrigger>\n): Signal<VTarget> => {\n  const { target, trigger } = options;\n\n  const result = signal<VTarget>(castValueInitializer<VTarget>(), {\n    onDispose: () => {\n      eTrigger.dispose()\n      eTarget.dispose()\n    }\n  })\n\n  let canEmit = false\n  const eTrigger = effect(() => {\n    trigger.get()\n    canEmit = true\n  })\n  const eTarget = effect(() => {\n    const latestValue = target.get()\n    if (canEmit === true) {\n      result.set(latestValue)\n      canEmit = false\n    }\n  })\n\n  return result\n}\n\nexport interface ThrottleByToggleOptions<VTarget, VOpen, VClose> {\n  target: ValueReactor<VTarget>;\n  open: ValueReactor<VOpen>;\n  close: ValueReactor<VClose>;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor when the close ValueReactor emits, but only\n * if throttling was started by the open ValueReactor.\n */\nexport const throttleByToggle = <VTarget, VOpen, VClose>(\n  options: ThrottleByToggleOptions<VTarget, VOpen, VClose>\n): Signal<VTarget> => {\n  const { target, open, close } = options;\n\n  const result = signal(castValueInitializer<VTarget>(), {\n    onDispose: () => {\n      eTarget.dispose()\n      eOpen.dispose()\n      eClose.dispose()\n    }\n  })\n\n  let throttling = false\n\n  const eOpen = effect(() => {\n    open.get()\n    throttling = true\n  })\n\n  const eTarget = effect(() => {\n    const value = target.get()\n    if (throttling === true) {\n      result.set(value)\n      throttling = false\n    }\n  })\n\n  const eClose = effect(() => {\n    close.get()\n    throttling = false\n  })\n\n  return result\n}\n\nexport interface ThrottleByDynamicOptions<VTarget, VDynamic> {\n  target: ValueReactor<VTarget>;\n  dynamic: (value: VTarget) => ValueReactor<VDynamic>;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor when the ValueReactor returned by the `dynamic`\n * function emits. The `dynamic` function is called each time after emitting\n * to get a new ValueReactor for the next throttle period.\n */\nexport const throttleByDynamic = <VTarget, VDynamic>(\n  options: ThrottleByDynamicOptions<VTarget, VDynamic>\n): Signal<VTarget> => {\n  const { target, dynamic } = options;\n\n  const result = signal(castValueInitializer<VTarget>(), {\n    onDispose: () => {\n      eTrigger.dispose()\n      eTarget.dispose()\n    }\n  })\n\n  let trigger: ValueReactor<VDynamic> | undefined = undefined\n  let canEmit = true\n  const eTrigger = effect(() => {\n    trigger?.dispose()\n    const targetValue = target.getWithoutTrack()\n    trigger = dynamic(targetValue)\n    trigger.get()\n    canEmit = true\n  })\n\n  const eTarget = effect(() => {\n    const latestValue = target.get()\n    if (canEmit === true) {\n      result.set(latestValue)\n      canEmit = false\n    }\n  })\n\n  return result\n}\n\nexport interface DistinctOptions<V, K> {\n  target: ValueReactor<V>;\n  keyGetter?: (value: V) => K;\n}\n/**\n * Returns a Signal that only updates its value with unique values\n * from the target ValueReactor, determined by the key returned from\n * the keyGetter function.\n */\nexport const distinct = <V, K>(\n  options: DistinctOptions<V, K>\n): Signal<V> => {\n  const { target, keyGetter } = options;\n\n  const result = signal<V>(castValueInitializer<V>(), {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  // oxlint-disable-next-line no-unsafe-type-assertion\n  const preparedKeyGetter = keyGetter ?? ((value: V): K => (value as unknown) as K)\n\n  const keySet = new Set<K>()\n  const eTarget = effect(() => {\n    const newValue = target.get()\n    const key = preparedKeyGetter(newValue);\n    if (keySet.has(key) === false) {\n      result.set(newValue)\n      keySet.add(key)\n    }\n  })\n\n  return result\n}\n\nexport interface DistinctUntilChangedOptions<V, K> {\n  target: ValueReactor<V>;\n  keyGetter?: (value: V) => K;\n}\n/**\n * Returns a Signal that only updates its value when the key returned\n * from the keyGetter function changes between emissions.\n */\nexport const distinctUntilChanged = <V, K>(\n  options: DistinctUntilChangedOptions<V, K>\n): Signal<V> => {\n  const { target, keyGetter } = options;\n\n  const result = signal<V>(castValueInitializer<V>(), {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  // oxlint-disable-next-line no-unsafe-type-assertion\n  const preparedKeyGetter = keyGetter ?? ((value: V): K => (value as unknown) as K)\n\n  // oxlint-disable-next-line no-unsafe-type-assertion\n  let lastKey: K = Symbol(\"initial-key-for-distinct-until-changed\") as unknown as K\n  const eTarget = effect(() => {\n    const newValue = target.get()\n    const key = preparedKeyGetter(newValue);\n    if (key !== lastKey) {\n      result.set(newValue)\n      lastKey = key\n    }\n  })\n\n  return result\n}\n\nexport interface TakeByPredicateOptions<V> {\n  target: ValueReactor<V>;\n  predicate: (value: V) => boolean;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor, but only while the predicate function\n * returns true.\n */\nexport const takeByPredicate = <V>(\n  options: TakeByPredicateOptions<V>\n): Signal<V> => {\n  const { target, predicate } = options;\n\n  const result = signal<V>(castValueInitializer<V>(), {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  const eTarget = effect(() => {\n    const latestValue = target.get()\n    if (predicate(latestValue) === true) {\n      result.set(latestValue)\n    } else {\n      eTarget.dispose()\n    }\n  })\n\n  return result\n}\n\nexport interface TakeByCountOptions<V> {\n  target: ValueReactor<V>;\n  count: number;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor, but only for the first `count` emissions.\n */\nexport const takeByCount = <V>(\n  options: TakeByCountOptions<V>\n): Signal<V> => {\n  const { target, count } = options;\n\n  if (count <= 0) {\n    throw new Error(\"takeByCount operator requires count to be greater than 0\")\n  }\n\n  const result = signal<V>(castValueInitializer<V>(), {\n    onDispose: () => {\n      eTarget.dispose()\n    }\n  })\n\n  let takenCount = 0\n  const eTarget = effect(() => {\n    const latestValue = target.get()\n    if (takenCount < count) {\n      result.set(latestValue)\n      takenCount = takenCount + 1\n    }\n    if (takenCount >= count) {\n      eTarget.dispose()\n    }\n  })\n\n  return result\n}\n\nexport interface TakeByTimeOptions<T> {\n  target: ValueReactor<T>;\n  time: number;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor, but only for the specified time in milliseconds.\n */\nexport const takeByTime = <T>(\n  options: TakeByTimeOptions<T>\n): Signal<T> => {\n  const { target, time } = options;\n\n  if (time <= 0) {\n    throw new Error(\"takeByTime operator requires timeInMilliseconds to be greater than 0\")\n  }\n\n  const result = signal<T>(castValueInitializer<T>(), {\n    onDispose: () => {\n      eTarget.dispose()\n      clearTimeout(timeoutId)\n    }\n  })\n\n  const timeoutId = setTimeout(() => {\n    eTarget.dispose()\n  }, time)\n\n  const eTarget = effect(() => {\n    const latestValue = target.get()\n    result.set(latestValue)\n  })\n\n  return result\n}\n\nexport interface TakeByTriggerOptions<VTarget, VTrigger> {\n  target: ValueReactor<VTarget>;\n  trigger: ValueReactor<VTrigger>;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor whenever the trigger ValueReactor emits a value.\n */\nexport const takeByTrigger = <VTarget, VTrigger>(\n  options: TakeByTriggerOptions<VTarget, VTrigger>\n): Signal<VTarget> => {\n  const { target, trigger } = options;\n\n  const result = signal<VTarget>(castValueInitializer<VTarget>(), {\n    onDispose: () => {\n      eTrigger.dispose()\n    }\n  })\n\n  const eTrigger = effect(() => {\n    trigger.get()\n    result.set(target.getWithoutTrack())\n  })\n\n  return result\n}\n\nexport interface TakeByToggleOptions<VTarget, VOpen, VClose> {\n  target: ValueReactor<VTarget>;\n  open: ValueReactor<VOpen>;\n  close: ValueReactor<VClose>;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor when the close ValueReactor emits, but only\n * if taking was started by the open ValueReactor.\n */\nexport const takeByToggle = <VTarget, VOpen, VClose>(\n  options: TakeByToggleOptions<VTarget, VOpen, VClose>\n): Signal<VTarget> => {\n  const { target, open, close } = options;\n\n  const result = signal<VTarget>(castValueInitializer<VTarget>(), {\n    onDispose: () => {\n      eTarget.dispose()\n      eOpen.dispose()\n      eClose.dispose()\n    }\n  })\n\n  let taking = false\n\n  const eOpen = effect(() => {\n    open.get()\n    taking = true\n  })\n\n  const eTarget = effect(() => {\n    const value = target.get()\n    if (taking === true) {\n      result.set(value)\n    }\n  })\n\n  const eClose = effect(() => {\n    close.get()\n    taking = false\n  })\n\n  return result\n}\n\nexport interface TakeUntilTriggerOptions<VTarget, VTrigger> {\n  target: ValueReactor<VTarget>;\n  trigger: ValueReactor<VTrigger>;\n}\n/**\n * Returns a Signal that updates its value with the latest value from\n * the target ValueReactor until the trigger ValueReactor emits a value.\n */\nexport const takeUntilTrigger = <VTarget, VTrigger>(\n  options: TakeUntilTriggerOptions<VTarget, VTrigger>\n): Signal<VTarget> => {\n  const { target, trigger } = options;\n\n  const result = signal<VTarget>(castValueInitializer<VTarget>(), {\n    onDispose: () => {\n      eTarget.dispose()\n      eTrigger.dispose()\n    }\n  })\n\n  const eTarget = effect(() => {\n    const latestValue = target.get()\n    result.set(latestValue)\n  })\n\n  const eTrigger = effect((context) => {\n    trigger.get()\n    if (context.isInitializingRun === false) {\n      eTarget.dispose()\n      eTrigger.dispose()\n    }\n  })\n\n  return result\n}\n"
   ],
-  "mappings": "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",
-  "debugId": "DFFA09A32FC4BCF264756E2164756E21",
+  "mappings": "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",
+  "debugId": "2D5A015F006AB1BC64756E2164756E21",
   "names": []
 }

package/dist/reactor/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./reactor-core/index.ts";
+export * from "./reactor-operators/index.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/reactor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/reactor/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAA;AACvC,cAAc,8BAA8B,CAAA"}

package/dist/reactor/reactor-core/flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flags.d.ts","sourceRoot":"","sources":["../../../src/reactor/reactor-core/flags.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS;IACpB;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAGH;;;;;;;;;;;;OAYG;;IAEH;;OAEG;;CAEK,CAAC;AAEX,eAAO,MAAM,UAAU,4BAEtB,CAAA;AACD,eAAO,MAAM,UAAU,wCAEtB,CAAA;AACD,eAAO,MAAM,YAAY,2BAExB,CAAA;AACD,eAAO,MAAM,aAAa,2BAEzB,CAAA;AACD,eAAO,MAAM,QAAQ,4BAEpB,CAAA;AACD,eAAO,MAAM,QAAQ,wCAEpB,CAAA;AACD,eAAO,MAAM,UAAU,2BAEtB,CAAA;AACD,eAAO,MAAM,WAAW,2BAEvB,CAAA;AACD,eAAO,MAAM,UAAU,4BAEtB,CAAA;AACD,eAAO,MAAM,UAAU,wCAEtB,CAAA;AACD,eAAO,MAAM,YAAY,2BAExB,CAAA;AACD,eAAO,MAAM,aAAa,2BAEzB,CAAA;AACD,eAAO,MAAM,WAAW,4BAEvB,CAAA;AACD,eAAO,MAAM,WAAW,wCAEvB,CAAA;AACD,eAAO,MAAM,aAAa,2BAEzB,CAAA;AACD,eAAO,MAAM,cAAc,2BAE1B,CAAA;AACD,eAAO,MAAM,WAAW,4BAEvB,CAAA;AACD,eAAO,MAAM,WAAW,wCAEvB,CAAA;AACD,eAAO,MAAM,aAAa,2BAEzB,CAAA;AACD,eAAO,MAAM,cAAc,2BAE1B,CAAA;AACD,eAAO,MAAM,kBAAkB,4BAE9B,CAAA;AACD,eAAO,MAAM,kBAAkB,wCAE9B,CAAA;AACD,eAAO,MAAM,oBAAoB,2BAEhC,CAAA;AACD,eAAO,MAAM,qBAAqB,2BAEjC,CAAA;AAED,qBAAa,KAAK;IAChB,OAAO,CAAC,KAAK,CAAS;IAEtB,cAEC;IAED,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAIhC;IAED,GAAG,IAAI,MAAM,CAEZ;IAED,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAGvB;IAED,KAAK,IAAI,IAAI,CAGZ;IAED,UAAU,IAAI,OAAO,CAEpB;IACD,UAAU,IAAI,IAAI,CAGjB;IACD,YAAY,IAAI,IAAI,CAGnB;IACD,aAAa,IAAI,IAAI,CAGpB;IAED,QAAQ,IAAI,OAAO,CAElB;IACD,QAAQ,IAAI,IAAI,CAGf;IACD,UAAU,IAAI,IAAI,CAGjB;IACD,WAAW,IAAI,IAAI,CAGlB;IAED,UAAU,IAAI,OAAO,CAEpB;IACD,UAAU,IAAI,IAAI,CAGjB;IACD,YAAY,IAAI,IAAI,CAGnB;IACD,aAAa,IAAI,IAAI,CAGpB;IAED,WAAW,IAAI,OAAO,CAErB;IACD,WAAW,IAAI,IAAI,CAGlB;IACD,aAAa,IAAI,IAAI,CAGpB;IACD,cAAc,IAAI,IAAI,CAGrB;IAED,WAAW,IAAI,OAAO,CAErB;IACD,WAAW,IAAI,IAAI,CAGlB;IACD,aAAa,IAAI,IAAI,CAGpB;IACD,cAAc,IAAI,IAAI,CAGrB;IAED,kBAAkB,IAAI,OAAO,CAE5B;IACD,kBAAkB,IAAI,IAAI,CAGzB;IACD,oBAAoB,IAAI,IAAI,CAG3B;IACD,qBAAqB,IAAI,IAAI,CAG5B;IAED,QAAQ,IAAI,MAAM,CA2BjB;CACF;AAED,eAAO,MAAM,KAAK,uCAMjB,CAAA"}

package/dist/reactor/reactor-core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/reactor/reactor-core/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,sBAAsB,CAAA;AACpC,cAAc,gBAAgB,CAAA"}