aoye 0.0.1 → 0.0.4

package/dist/aoye.cjs.js

@@ -1,126 +1,209 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
+var bobeShared = require('bobe-shared');
 
-function Queue() {
-  return {
-    len: 0,
-    push: Queue_$$$_push,
-    shift: Queue_$$$_shift,
-    get first() {
-      var _a;
-      return (_a = this._first) === null || _a === void 0 ? void 0 : _a.v;
-    },
-    get last() {
-      var _a;
-      return (_a = this._last) === null || _a === void 0 ? void 0 : _a.v;
+const evt = new bobeShared.BaseEvent();
+const G = {
+  /** 原子 signal 更新次数 */
+  version: 0,
+  id: 0,
+  /** scope 销毁任务序号 */
+  scopeDisposeI: 0,
+  PullingSignal: null
+};
+const dirtyLeafs = new bobeShared.SortMap();
+var State = /* @__PURE__ */ ((State2) => {
+  State2[State2["Clean"] = 0] = "Clean";
+  State2[State2["LinkScopeOnly"] = 64] = "LinkScopeOnly";
+  State2[State2["ScopeAbort"] = 32] = "ScopeAbort";
+  State2[State2["ScopeReady"] = 16] = "ScopeReady";
+  State2[State2["IsScope"] = 8] = "IsScope";
+  State2[State2["Unknown"] = 4] = "Unknown";
+  State2[State2["Dirty"] = 2] = "Dirty";
+  State2[State2["Check"] = 1] = "Check";
+  return State2;
+})(State || {});
+const DirtyState = 4 /* Unknown */ | 2 /* Dirty */;
+const ScopeExecuted = 16 /* ScopeReady */ | 32 /* ScopeAbort */;
+const ScopeAbort = 32 /* ScopeAbort */;
+
+const leakI = (y, max) => y < 0 || y >= max ? null : y;
+const getLeft = (x, max) => leakI(x * 2 + 1, max);
+const getRight = (x, max) => leakI(x * 2 + 2, max);
+const getParent = (x, max) => leakI(x - 1 >>> 1, max);
+const exchange = (arr, i, j) => [arr[i], arr[j]] = [arr[j], arr[i]];
+class PriorityQueue {
+  // 构造函数接受一个compare函数
+  // compare返回的-1, 0, 1决定元素是否优先被去除
+  constructor(aIsUrgent) {
+    this.aIsUrgent = aIsUrgent;
+    this.arr = [];
+    this.goUp = (arr, current, len) => {
+      let i = len - 1;
+      while (i > 0) {
+        const item = arr[i];
+        const pI = getParent(i, len);
+        const parent = arr[pI];
+        if (this.aIsUrgent(item, parent)) {
+          exchange(arr, i, pI);
+          i = pI;
+        } else {
+          break;
+        }
+      }
+    };
+    this.goDown = (arr, i) => {
+      const len = this.size();
+      const half = len >>> 1;
+      while (i < half) {
+        const lI = getLeft(i, len);
+        const rI = getRight(i, len);
+        let point = i;
+        if (lI != null && this.aIsUrgent(arr[lI], arr[point])) {
+          point = lI;
+        }
+        if (rI != null && this.aIsUrgent(arr[rI], arr[point])) {
+          point = rI;
+        }
+        if (point === i) {
+          break;
+        }
+        exchange(arr, i, point);
+        i = point;
+      }
+    };
+  }
+  // 添加一个元素
+  _add(current) {
+    this.arr.push(current);
+    const len = this.size();
+    if (len === 1) {
+      return;
     }
-  };
-}
-function Queue_$$$_push(it) {
-  this.len++;
-  const {
-    _last: last
-  } = this;
-  const item = {
-    v: it
-  };
-  if (!last) {
-    this._first = this._last = item;
-    return;
+    this.goUp(this.arr, current, len);
   }
-  item.prev = this._last;
-  last.next = item;
-  this._last = item;
-}
-function Queue_$$$_shift() {
-  const {
-    _first: first
-  } = this;
-  if (!first) return undefined;
-  this.len--;
-  const {
-    next
-  } = first;
-  first.next = undefined;
-  if (next) {
-    next.prev = undefined;
-  } else {
-    this._last = undefined;
+  add(...items) {
+    items.forEach((it) => this._add(it));
+  }
+  // 去除头元素并返回
+  poll() {
+    const { arr } = this;
+    const len = this.size();
+    if (len <= 2) {
+      return arr.shift();
+    }
+    const last = arr.pop();
+    const first = arr[0];
+    arr[0] = last;
+    this.goDown(this.arr, 0);
+    return first;
+  }
+  // 取得头元素
+  peek() {
+    return this.arr[0];
+  }
+  // 取得元素数量
+  size() {
+    return this.arr.length;
+  }
+  logTree() {
+    const { arr } = this;
+    let i = 0;
+    let j = 1;
+    let level = 0;
+    const matrix = [];
+    do {
+      matrix.push(arr.slice(i, j));
+      i = i * 2 + 1;
+      j = i + Math.pow(2, level) + 1;
+      level++;
+    } while (i < arr.length);
+    const last = Math.pow(2, matrix.length - 1);
+    const arrStr = JSON.stringify(last);
+    const halfLen = arrStr.length >>> 1;
+    matrix.forEach((it) => {
+      const str = JSON.stringify(it);
+      const halfIt = str.length >>> 1;
+      console.log(str.padStart(halfLen + halfIt, " "));
+    });
+    console.log("\n");
   }
-  this._first = next;
-  return first.v;
-}
-function SortMap() {
-  return {
-    data: {},
-    clear: SortMap_$$$_clear,
-    add: SortMap_$$$_add
-  };
-}
-// const queue = new Queue([1,2,3,4]);
-// queue.shift()
-// queue.pop()
-// // @ts-ignore
-// queue.unshift('a')
-// // @ts-ignore
-// queue.push('b')
-// queue.shift()
-// queue.pop()
-// queue.shift()
-// queue.pop()
-// queue.shift()
-// queue.pop()
-// queue.push(10)
-// queue.array();
-function SortMap_$$$_clear() {
-  this.data = {};
 }
-function SortMap_$$$_add(key, value) {
-  const {
-    data
-  } = this;
-  let list = data[key];
-  if (!list) {
-    list = [];
-    data[key] = list;
+
+class TaskQueue {
+  constructor(callbackAble, aIsUrgent) {
+    this.callbackAble = callbackAble;
+    this.aIsUrgent = aIsUrgent;
+    this.isScheduling = false;
+  }
+  static create({ callbackAble, aIsUrgent }) {
+    const queue = new TaskQueue(callbackAble, aIsUrgent);
+    queue.taskQueue = new PriorityQueue(aIsUrgent);
+    return queue;
+  }
+  pushTask(task) {
+    const { taskQueue, isScheduling } = this;
+    taskQueue._add(task);
+    if (!isScheduling) {
+      this.callbackAble(this.scheduleTask.bind(this));
+      this.isScheduling = true;
+    }
+  }
+  scheduleTask() {
+    const { taskQueue } = this;
+    const fn = taskQueue.peek();
+    if (!fn) return this.isScheduling = false;
+    const hasRemain = fn();
+    if (hasRemain) {
+      this.callbackAble(this.scheduleTask.bind(this));
+      return;
+    }
+    taskQueue.poll();
+    evt.emit("one", fn);
+    if (taskQueue.size() === 0) {
+      evt.emit("done", fn);
+      return this.isScheduling = false;
+    }
+    this.callbackAble(this.scheduleTask.bind(this));
   }
-  list.push(value);
 }
 
-const G = {
-  /** 原子 signal 更新次数 */
-  version: 0,
-  id: 0,
-  /** scope 销毁任务序号 */
-  scopeDisposeI: 0
+let channel = globalThis.MessageChannel ? new MessageChannel() : null;
+if (globalThis.MessageChannel) {
+  channel = new MessageChannel();
+}
+let msgId = 0;
+const macro = (fn) => {
+  if (!channel) {
+    setTimeout(fn);
+  }
+  const memoId = msgId;
+  function onMessage(e) {
+    if (memoId === e.data) {
+      fn();
+      channel.port2.removeEventListener("message", onMessage);
+    }
+  }
+  channel.port2.addEventListener("message", onMessage);
+  channel.port1.postMessage(msgId++);
+};
+const p = Promise.resolve();
+const micro = (cb) => {
+  p.then(cb);
 };
-const dirtyLeafs = SortMap();
-var State;
-(function (State) {
-  State[State["Clean"] = 0] = "Clean";
-  /** 仅用于 scope 节点是否 abort */
-  State[State["ScopeAbort"] = 32] = "ScopeAbort";
-  State[State["OutLink"] = 16] = "OutLink";
-  State[State["Unknown"] = 8] = "Unknown";
-  State[State["Dirty"] = 4] = "Dirty";
-  State[State["Check"] = 2] = "Check";
-  State[State["ScopeReady"] = 1] = "ScopeReady";
-})(State || (State = {}));
-const DirtyState = State.Unknown | State.Dirty;
 
-exports.Scheduler = void 0;
-(function (Scheduler) {
-  Scheduler["Sync"] = "__Sync_";
-  Scheduler["Layout"] = "__Layout_";
-  Scheduler["Micro"] = "__Micro_";
-  Scheduler["Macro"] = "__Macro_";
-})(exports.Scheduler || (exports.Scheduler = {}));
+var Scheduler = /* @__PURE__ */ ((Scheduler2) => {
+  Scheduler2["Sync"] = "__Sync_";
+  Scheduler2["Layout"] = "__Layout_";
+  Scheduler2["Micro"] = "__Micro_";
+  Scheduler2["Macro"] = "__Macro_";
+  return Scheduler2;
+})(Scheduler || {});
 const _scheduler = {
-  [exports.Scheduler.Sync]: defaultScheduler,
-  [exports.Scheduler.Micro]: microScheduler,
-  [exports.Scheduler.Macro]: macroScheduler,
-  [exports.Scheduler.Layout]: schedulerLayout
+  ["__Sync_" /* Sync */]: defaultScheduler,
+  ["__Micro_" /* Micro */]: microScheduler,
+  ["__Macro_" /* Macro */]: macroScheduler,
+  ["__Layout_" /* Layout */]: layoutScheduler
 };
 const scheduler = (key, value) => _scheduler[key] = value;
 function defaultScheduler(effects) {
@@ -128,70 +211,57 @@ function defaultScheduler(effects) {
     effect.runIfDirty();
   }
 }
-const p = Promise.resolve();
-let hasMicroTask = false;
+let microSTaskQueue;
+let macroSTaskQueue;
+let layoutSTaskQueue;
 function microScheduler(effects) {
-  if (hasMicroTask) return;
-  p.then(() => {
-    defaultScheduler(effects);
-    hasMicroTask = false;
-  });
-  hasMicroTask = true;
-}
-let channel, macroQueue;
-if (globalThis.MessageChannel) {
-  channel = new MessageChannel();
-  macroQueue = Queue();
-  channel.port2.onmessage = () => {
-    while (macroQueue.first) {
-      macroQueue.shift()();
-    }
-  };
+  microSTaskQueue = microSTaskQueue || TaskQueue.create({ callbackAble: micro, aIsUrgent: (a, b) => a.time < b.time });
+  microSTaskQueue.pushTask(defaultScheduler.bind(null, effects));
 }
 function macroScheduler(effects) {
-  if (channel) {
-    macroQueue.push(() => defaultScheduler(effects));
-    channel.port1.postMessage('');
-  }
-  setTimeout(() => {
-    defaultScheduler(effects);
-  });
+  macroSTaskQueue = macroSTaskQueue || TaskQueue.create({ callbackAble: macro, aIsUrgent: (a, b) => a.time < b.time });
+  macroSTaskQueue.pushTask(defaultScheduler.bind(null, effects));
 }
-function schedulerLayout(effects) {
-  requestAnimationFrame(() => {
-    defaultScheduler(effects);
-  });
+function layoutScheduler(effects) {
+  layoutSTaskQueue = layoutSTaskQueue || TaskQueue.create({ callbackAble: macro, aIsUrgent: (a, b) => a.time < b.time });
+  layoutSTaskQueue.pushTask(defaultScheduler.bind(null, effects));
 }
 
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
 const DefaultDFSOpt = {
   isUp: false,
-  begin: undefined,
-  complete: undefined,
+  begin: null,
+  complete: null,
   breakStack: [],
-  breakLine: undefined,
-  breakNode: undefined
+  breakLine: null,
+  breakNode: null
 };
 function dfs(root, opt = {}) {
-  const {
-    isUp,
-    begin,
-    complete,
-    breakStack: lineStack,
-    breakLine
-  } = {
-    ...DefaultDFSOpt,
-    ...opt
-  };
+  const { isUp, begin, complete, breakStack: lineStack, breakLine } = __spreadValues$1(__spreadValues$1({}, DefaultDFSOpt), opt);
   let node = opt.breakNode || root;
   let line = breakLine;
-  const listKey = isUp ? 'recStart' : 'emitStart';
-  const nodeKey = isUp ? 'upstream' : 'downstream';
-  // 向上意味着要找所有节点的入度
-  const nextLineKey = isUp ? 'nextRecLine' : 'nextEmitLine';
-  const reverseNodeKey = isUp ? 'downstream' : 'upstream';
+  const listKey = isUp ? "recStart" : "emitStart";
+  const nodeKey = isUp ? "upstream" : "downstream";
+  const nextLineKey = isUp ? "nextRecLine" : "nextEmitLine";
+  const reverseNodeKey = isUp ? "downstream" : "upstream";
   while (1) {
-    let notGoDeep = begin === null || begin === void 0 ? void 0 : begin({
-      node: node,
+    let notGoDeep = begin == null ? void 0 : begin({
+      node,
       lineFromUp: line,
       walkedLine: lineStack
     });
@@ -203,622 +273,303 @@ function dfs(root, opt = {}) {
       continue;
     }
     while (1) {
-      const noGoSibling = complete === null || complete === void 0 ? void 0 : complete({
-        node: node,
+      const noGoSibling = complete == null ? void 0 : complete({
+        node,
         lineToDeep: line,
         walkedLine: lineStack,
         notGoDeep
       });
-      // 只对当前不下钻的节点生效
-      // notGoDeep = false;
       line = lineStack.pop();
-      // 递归出口，回到起点
       if (node === root) {
         return;
       }
       notGoDeep = false;
       const nextLine = line[nextLineKey];
-      // 有兄弟节点， 进入外循环，向下遍历兄弟节点
       if (!noGoSibling && nextLine) {
-        // 外层循环后会把 sibling line 入栈，这里不需要处理
         line = nextLine;
         node = nextLine[nodeKey];
         break;
       }
-      // 没有兄弟节点就上浮
       node = line[reverseNodeKey];
     }
   }
 }
 
-function Line_$$$_link(v1, v2) {
-  let {
-      emitEnd
-    } = v1,
-    {
-      recEnd,
-      recStart
-    } = v2,
-    noRecEnd = !recEnd,
-    /** 模拟头节点 */
-    head = {
-      nextRecLine: recStart
-    },
-    line;
-  recEnd = recEnd || head;
-  const {
-    nextRecLine
-  } = recEnd || {};
-  // 没有下一个收到的线
-  if (!nextRecLine) {
-    line = Line();
-    // 内部会处理空链表的情况，即同步头部
-    Line.emit_line(v1, line);
-    Line.rec_line(v2, line);
-    emitEnd && Line.line_line_emit(emitEnd, line);
-    !noRecEnd && Line.line_line_rec(recEnd, line);
-  }
-  // 复用
-  else if (nextRecLine.upstream === v1) {
-    v2.recEnd = nextRecLine;
-    // TODO: link 版本标记
-  }
-  // 插入(这么做): v1 和 下一个 入度(订阅)节点不同
-  // TODO: v2上次真依赖了 v1 只是没检查出来，需要删除原依赖
-  else {
-    line = Line();
-    Line.emit_line(v1, line);
-    Line.rec_line(v2, line);
-    emitEnd && Line.line_line_emit(emitEnd, line);
-    Line.insert_line_rec(recEnd, nextRecLine, line);
+class Line {
+  constructor() {
+    /** 上游顶点 */
+    this.upstream = null;
+    /** 上游节点 发出的上一条线 */
+    this.prevEmitLine = null;
+    /** 上游节点 发出的下一条线 */
+    this.nextEmitLine = null;
+    /** 下游顶点 */
+    this.downstream = null;
+    /** 下游节点 接收的上一条线 */
+    this.prevRecLine = null;
+    /** 下游节点 接收的下一条线 */
+    this.nextRecLine = null;
+    /** 表示 scope 当前存在的 外部 link  */
+    this.prevOutLink = null;
+    this.nextOutLink = null;
+  }
+  static link(v1, v2) {
+    let { emitEnd } = v1, { recEnd, recStart } = v2, noRecEnd = !recEnd, head = { nextRecLine: recStart }, line;
+    recEnd = recEnd || head;
+    const { nextRecLine } = recEnd || {};
+    if (!nextRecLine) {
+      line = new Line();
+      Line.emit_line(v1, line);
+      Line.rec_line(v2, line);
+      emitEnd && Line.line_line_emit(emitEnd, line);
+      !noRecEnd && Line.line_line_rec(recEnd, line);
+    } else if (nextRecLine.upstream === v1) {
+      v2.recEnd = nextRecLine;
+    } else {
+      line = new Line();
+      Line.emit_line(v1, line);
+      Line.rec_line(v2, line);
+      emitEnd && Line.line_line_emit(emitEnd, line);
+      Line.insert_line_rec(recEnd, nextRecLine, line);
+    }
+    for (const key in head) {
+      head[key] = null;
+    }
+    if (line && v2.scope && v1.scope !== v2.scope && !(v1.state & State.IsScope)) {
+      const first = v2.scope.outLink;
+      if (!first) {
+        v2.scope.outLink = line;
+      } else {
+        first.prevOutLink = line;
+        line.nextOutLink = first;
+        v2.scope.outLink = line;
+      }
+    }
   }
-  // 消除 head
-  for (const key in head) {
-    head[key] = undefined;
+  static unlink(line) {
+    let { prevEmitLine, nextEmitLine, prevRecLine, nextRecLine, upstream, downstream, nextOutLink, prevOutLink } = line;
+    line.prevEmitLine = null;
+    line.nextEmitLine = null;
+    line.prevRecLine = null;
+    line.nextRecLine = null;
+    line.upstream = null;
+    line.downstream = null;
+    line.prevOutLink = null;
+    line.nextOutLink = null;
+    const downNode = downstream;
+    if (prevOutLink) {
+      prevOutLink.nextOutLink = nextOutLink;
+    }
+    if (nextOutLink) {
+      nextOutLink.prevOutLink = prevOutLink;
+    }
+    if (downNode.scope && downNode.scope.outLink === line) {
+      downNode.scope.outLink = nextOutLink;
+    }
+    if (prevEmitLine) {
+      prevEmitLine.nextEmitLine = nextEmitLine;
+    } else {
+      upstream.emitStart = nextEmitLine;
+    }
+    if (nextEmitLine) {
+      nextEmitLine.prevEmitLine = prevEmitLine;
+    } else {
+      upstream.emitEnd = prevEmitLine;
+    }
+    if (prevRecLine) {
+      prevRecLine.nextRecLine = nextRecLine;
+    } else {
+      downstream.recStart = nextRecLine;
+    }
+    if (nextRecLine) {
+      nextRecLine.prevRecLine = prevRecLine;
+    } else {
+      downstream.recEnd = prevRecLine;
+    }
   }
-}
-Line.link = Line_$$$_link;
-function Line_$$$_unlink(line) {
-  let {
-    prevEmitLine,
-    nextEmitLine,
-    prevRecLine,
-    nextRecLine,
-    upstream,
-    downstream
-  } = line;
-  line.prevEmitLine = undefined;
-  line.nextEmitLine = undefined;
-  line.prevRecLine = undefined;
-  line.nextRecLine = undefined;
-  line.upstream = undefined;
-  line.downstream = undefined;
-  /** 上游节点发出的线 前一条 关联 后一条 */
-  if (prevEmitLine) {
-    prevEmitLine.nextEmitLine = nextEmitLine;
-  } else {
-    // 删除的是首个节点
-    upstream.emitStart = nextEmitLine;
+  static unlinkRec(line) {
+    let toDel = line;
+    while (toDel) {
+      const memoNext = toDel.nextRecLine;
+      Line.unlink(toDel);
+      toDel = memoNext;
+    }
   }
-  if (nextEmitLine) {
-    nextEmitLine.prevEmitLine = prevEmitLine;
-  } else {
-    // 删除尾节点
-    upstream.emitEnd = prevEmitLine;
+  static unlinkEmit(line) {
+    let toDel = line;
+    while (toDel) {
+      const memoNext = toDel.nextEmitLine;
+      Line.unlink(toDel);
+      toDel = memoNext;
+    }
   }
-  /** 下游节点接收的线，我们从 recEnd 开始删除的，
-   * 接收信息，不需要设置 recEnd ，
-   * 因为 recStart ~ recEnd 是经过上级 get 确认的有用依赖
-   * */
-  if (prevRecLine) {
-    prevRecLine.nextRecLine = nextRecLine;
-  } else {
-    // 删除的是首个节点，大概率不可能从有依赖 变成无依赖
-    downstream.recStart = nextRecLine;
+  /** 上游节点 连 link */
+  static emit_line(upstream, line) {
+    if (!upstream.emitStart) {
+      upstream.emitStart = line;
+    }
+    upstream.emitEnd = line;
+    line.upstream = upstream;
   }
-  if (nextRecLine) {
-    nextRecLine.prevRecLine = prevRecLine;
-  } else {
-    // 删除尾节点
-    downstream.recEnd = prevRecLine;
+  /** 下游节点 连 link */
+  static rec_line(downstream, line) {
+    if (!downstream.recStart) {
+      downstream.recStart = line;
+    }
+    downstream.recEnd = line;
+    line.downstream = downstream;
+  }
+  /** 同一节点发出的 两个条线 相连 */
+  static line_line_emit(l1, l2) {
+    if (!l1 || !l2) return;
+    l1.nextEmitLine = l2;
+    l2.prevEmitLine = l1;
+  }
+  /** 同一节点接收的 两个条线 相连 */
+  static line_line_rec(l1, l2) {
+    if (!l1 || !l2) return;
+    l1.nextRecLine = l2;
+    l2.prevRecLine = l1;
+  }
+  static insert_line_emit(l1, l2, ins) {
+    l1.nextEmitLine = ins;
+    ins.prevEmitLine = l1;
+    l2.prevEmitLine = ins;
+    ins.nextEmitLine = l2;
+  }
+  static insert_line_rec(l1, l2, ins) {
+    l1.nextRecLine = ins;
+    ins.prevRecLine = l1;
+    l2.prevRecLine = ins;
+    ins.nextRecLine = l2;
   }
 }
-Line.unlink = Line_$$$_unlink;
-function Line_$$$_unlinkRec(line) {
-  // 作为下游，执行完 get 上游节点已经完成了依赖更新，把 recEnd 后的依赖删除即可
+
+function unlinkRecWithScope(line) {
   let toDel = line;
   while (toDel) {
     const memoNext = toDel.nextRecLine;
-    Line.unlink(toDel);
-    toDel = memoNext;
-  }
-}
-Line.unlinkRec = Line_$$$_unlinkRec;
-function Line_$$$_unlinkEmit(line) {
-  // 作为下游，执行完 get 上游节点已经完成了依赖更新，把 recEnd 后的依赖删除即可
-  let toDel = line;
-  while (toDel) {
-    const memoNext = toDel.nextEmitLine;
-    Line.unlink(toDel);
+    const upstream = toDel.upstream;
+    if (upstream.state & State.IsScope) {
+      dispose.call(upstream);
+    } else {
+      unlinkSingleLine(toDel);
+    }
     toDel = memoNext;
   }
 }
-Line.unlinkEmit = Line_$$$_unlinkEmit;
-function Line_$$$_emit_line(upstream, line) {
-  if (!upstream.emitStart) {
-    upstream.emitStart = line;
-  }
-  upstream.emitEnd = line;
-  line.upstream = upstream;
-}
-Line.emit_line = Line_$$$_emit_line;
-function Line_$$$_rec_line(downstream, line) {
-  if (!downstream.recStart) {
-    downstream.recStart = line;
+function unlinkSingleLine(line) {
+  const upstream = line.upstream;
+  if (upstream.emitStart === upstream.emitEnd) {
+    unlinkSingleRefedNode(upstream);
+  } else {
+    Line.unlink(line);
   }
-  downstream.recEnd = line;
-  line.downstream = downstream;
 }
-Line.rec_line = Line_$$$_rec_line;
-function Line_$$$_line_line_emit(l1, l2) {
-  if (!l1 || !l2) return;
-  l1.nextEmitLine = l2;
-  l2.prevEmitLine = l1;
-}
-Line.line_line_emit = Line_$$$_line_line_emit;
-function Line_$$$_line_line_rec(l1, l2) {
-  if (!l1 || !l2) return;
-  l1.nextRecLine = l2;
-  l2.prevRecLine = l1;
-}
-Line.line_line_rec = Line_$$$_line_line_rec;
-function Line_$$$_insert_line_emit(l1, l2, ins) {
-  l1.nextEmitLine = ins;
-  ins.prevEmitLine = l1;
-  l2.prevEmitLine = ins;
-  ins.nextEmitLine = l2;
-}
-Line.insert_line_emit = Line_$$$_insert_line_emit;
-function Line_$$$_insert_line_rec(l1, l2, ins) {
-  l1.nextRecLine = ins;
-  ins.prevRecLine = l1;
-  l2.prevRecLine = ins;
-  ins.nextRecLine = l2;
-}
-Line.insert_line_rec = Line_$$$_insert_line_rec;
-function Line() {
-  return {
-    upstream: null,
-    prevEmitLine: null,
-    nextEmitLine: null,
-    downstream: null,
-    prevRecLine: null,
-    nextRecLine: null
-  };
-}
-
-/**
- * 这是一个优先队列 （满足子节点总是比父节点大）
- *                    1
- *
- *               10          20
- *
- *          15    30      25      30
- *
- *       17
- *  现在插入 7 ， 会按广度优先的顺序插入在数组尾部
- *                    1
- *
- *               10          20
- *
- *          15    30      25      30
- *
- *       17    7
- * 接着我们只需要将 7  逐层与上门的父节点比较， 7 较小则两者交互，一直让 7 上浮到适合的位置
- *
- *                          0
- *
- *                    1           2                 2^0 得到第二层第一个索引
- *
- *              3       4     5       6            2^0 + 2^1 。。。 + 2^n + x = y
- *
- *          7      8
- * 上浮后我们得到以上的树
- */
-// 父子节点的关系
-// 计算一个节点的 index 公式 ①   2^0 + 2^1 。。。 + 2^n + y = x 已知
-// 节点的左子节点 index     ②   2^0 + 2^1 。。。 + 2^n + 2^(n+1) + z = res 求 res
-// ② - ① 得到 2^(n+1) + (z-y) = res - x
-// 2^(n+1) + (z-y) + x = res
-// 而 z 和 y 的关系是，③ z = 2y
-const leakI = (y, max) => y < 0 || y >= max ? null : y;
-const getLeft = (x, max) => leakI(x * 2 + 1, max);
-const getRight = (x, max) => leakI(x * 2 + 2, max);
-const getParent = (x, max) => leakI(x - 1 >>> 1, max);
-const exchange = (arr, i, j) => [arr[i], arr[j]] = [arr[j], arr[i]];
-function PriorityQueue(aIsUrgent) {
-  return {
-    aIsUrgent: aIsUrgent,
-    arr: [],
-    goUp: (arr, current, len) => {
-      let i = len - 1;
-      while (i > 0) {
-        const item = arr[i];
-        const pI = getParent(i, len);
-        const parent = arr[pI];
-        if (this.aIsUrgent(item, parent)) {
-          // console.log(`交换 parent:${parent} -> child:${item} `);
-          exchange(arr, i, pI);
-          // this.logTree();
-          i = pI;
-        } else {
-          // console.log(`parent:${parent} child:${item} 不需要交换 \n`);
-          break;
-        }
+function unlinkSingleRefedNode(delRoot) {
+  let toUnlink;
+  dfs(delRoot, {
+    isUp: true,
+    begin: ({ node }) => {
+      doUnlink(toUnlink);
+      toUnlink = null;
+      if (node.emitStart !== node.emitEnd) {
+        return true;
       }
     },
-    goDown: (arr, i) => {
-      const len = this.size();
-      const half = len >>> 1;
-      while (i < half) {
-        const lI = getLeft(i, len);
-        const rI = getRight(i, len);
-        let point = i;
-        if (lI != null && this.aIsUrgent(arr[lI], arr[point])) {
-          point = lI;
-        }
-        if (rI != null && this.aIsUrgent(arr[rI], arr[point])) {
-          point = rI;
-        }
-        if (point === i) {
-          break;
-        }
-        // console.log(`交换 parent:${arr[i]} -> child:${arr[point]} `);
-        exchange(arr, i, point);
-        // this.logTree();
-        i = point;
+    complete: ({ node, notGoDeep }) => {
+      doUnlink(toUnlink);
+      toUnlink = null;
+      const isSingleRefed = !notGoDeep;
+      if (isSingleRefed) {
+        toUnlink = node.emitStart;
       }
-    },
-    _add: PriorityQueue_$$$__add,
-    add: PriorityQueue_$$$_add,
-    poll: PriorityQueue_$$$_poll,
-    peek: PriorityQueue_$$$_peek,
-    size: PriorityQueue_$$$_size,
-    logTree: PriorityQueue_$$$_logTree
-  };
-}
-// case 1
-// const pq = new PriorityQueue((a, b) => a - b)
-// pq.add(5)
-// pq.add(3)
-// pq.add(1)
-// pq.add(4)
-// pq.add(2)
-// const result = []
-// while (pq.size() > 0) {
-//   result.push(pq.poll())
-// }
-// console.log(result);
-// [1,2,3,4,5]
-// case 2
-// const pq = new PriorityQueue((a, b) => b - a)
-// pq.add(1)
-// pq.add(3)
-// pq.add(4)
-// pq.add(5)
-// pq.add(2)
-// const result = []
-// while (pq.size() > 0) {
-//   result.push(pq.poll())
-// }
-// console.log(result);
-// [5,4,3,2,1]
-function PriorityQueue_$$$__add(current) {
-  // console.log(`加入 ${current}`);
-  this.arr.push(current);
-  const len = this.size();
-  // this.logTree();
-  if (len === 1) {
-    return;
-  }
-  this.goUp(this.arr, current, len);
-}
-function PriorityQueue_$$$_add(...items) {
-  items.forEach(it => this._add(it));
-}
-function PriorityQueue_$$$_poll() {
-  const {
-    arr
-  } = this;
-  // console.log(`弹出 ${arr[0]} 把 ${arr[arr.length - 1]} 放置到队头 `);
-  const len = this.size();
-  if (len <= 2) {
-    return arr.shift();
-  }
-  const last = arr.pop();
-  const first = arr[0];
-  arr[0] = last;
-  // this.logTree();
-  this.goDown(this.arr, 0);
-  return first;
-}
-function PriorityQueue_$$$_peek() {
-  return this.arr[0];
-}
-function PriorityQueue_$$$_size() {
-  return this.arr.length;
-}
-function PriorityQueue_$$$_logTree() {
-  const {
-    arr
-  } = this;
-  let i = 0;
-  let j = 1;
-  let level = 0;
-  const matrix = [];
-  do {
-    matrix.push(arr.slice(i, j));
-    i = i * 2 + 1;
-    j = i + Math.pow(2, level) + 1;
-    level++;
-  } while (i < arr.length);
-  const last = Math.pow(2, matrix.length - 1);
-  const arrStr = JSON.stringify(last);
-  const halfLen = arrStr.length >>> 1;
-  matrix.forEach(it => {
-    const str = JSON.stringify(it);
-    const halfIt = str.length >>> 1;
-    console.log(str.padStart(halfLen + halfIt, ' '));
+    }
   });
-  console.log('\n');
-}
-
-function TaskQueue_$$$_create({
-  callbackAble,
-  aIsUrgent
-}) {
-  const queue = TaskQueue(callbackAble, aIsUrgent);
-  queue.taskQueue = PriorityQueue(aIsUrgent);
-  return queue;
+  doUnlink(toUnlink);
 }
-TaskQueue.create = TaskQueue_$$$_create;
-function TaskQueue(callbackAble, aIsUrgent) {
-  return {
-    callbackAble: callbackAble,
-    aIsUrgent: aIsUrgent,
-    isScheduling: false,
-    pushTask: TaskQueue_$$$_pushTask,
-    scheduleTask: TaskQueue_$$$_scheduleTask
-  };
-}
-function TaskQueue_$$$_pushTask(task) {
-  const {
-    taskQueue,
-    isScheduling
-  } = this;
-  taskQueue._add(task);
-  if (!isScheduling) {
-    this.callbackAble(this.scheduleTask.bind(this));
-    this.isScheduling = true;
-  }
-}
-function TaskQueue_$$$_scheduleTask() {
-  const {
-    taskQueue
-  } = this;
-  // console.log('调度 dispose');
-  const fn = taskQueue.peek();
-  if (!fn) return this.isScheduling = false;
-  const hasRemain = fn();
-  // 未完成
-  if (hasRemain) {
-    this.callbackAble(this.scheduleTask.bind(this));
+function doUnlink(line) {
+  if (!line) {
     return;
   }
-  // 完成
-  taskQueue.poll();
-  if (taskQueue.size() === 0) return this.isScheduling = false;
-  // 任务列表中还有任务
-  this.callbackAble(this.scheduleTask.bind(this));
-}
-
-const ide = globalThis.requestIdleCallback || (globalThis.requestAnimationFrame ? fn => globalThis.requestAnimationFrame(() => {
-  setTimeout(() => {
-    fn();
-  });
-}) : globalThis.setTimeout);
-const now = () => {
-  const timer = globalThis.performance || globalThis.Date;
-  return timer.now();
-};
-
-// export class IdeScheduler {
-//   constructor() {}
-//   isScheduling = false;
-//   taskQueue = new Queue<Function>();
-//   pushTask(task: Function) {
-//     const { taskQueue, isScheduling } = this;
-//     taskQueue.push(task);
-//     if (!isScheduling) {
-//       ide(this.scheduleTask.bind(this));
-//       this.isScheduling = true;
-//     }
-//   }
-//   scheduleTask() {
-//     const { taskQueue } = this;
-//     // console.log('调度 dispose');
-//     const fn = taskQueue.first;
-//     if (!fn) return (this.isScheduling = false);
-//     const hasRemain = fn();
-//     // 未完成
-//     if (hasRemain) {
-//       ide(this.scheduleTask.bind(this));
-//       return;
-//     }
-//     // 完成
-//     taskQueue.shift();
-//     if (taskQueue.len === 0) return (this.isScheduling = false);
-//     // 任务列表中还有任务
-//     ide(this.scheduleTask.bind(this));
-//   }
-// }
-/** scope 捕获，引用外部 signal 孤岛 */
-const unTrackIsland = signal => {
-  // 原来是孤岛，且被 scope 管理的要恢复
-  if (signal.emitStart && signal.emitStart.downstream === signal.scope) {
-    Line.unlink(signal.emitStart);
-  }
-};
-/** scope 释放，被重新连接的孤岛 */
-const trackIsland = signal => {
-  const line = Line();
-  // 上游节点处于孤岛状态，切有引用外部信号，需要被 scope 管理来删除外部依赖
-  if (!signal.emitStart && signal.state & State.OutLink) {
-    const {
-      recEnd
-    } = signal.scope;
-    Line.emit_line(signal, line);
-    Line.rec_line(signal.scope, line);
-    Line.line_line_rec(recEnd, line);
-  }
-};
-const markOutLink = (signal, downstream) => {
-  // 上游是外部节点，或者上游引用了外部节点的， 做传播
-  if (signal.scope !== downstream.scope || signal.state & State.OutLink) {
-    downstream.state |= State.OutLink;
-  }
-  // else {
-  //   downstream.state &= ~State.OutLink;
-  // }
-};
-const BreakErr = '_ERR_BREAK_';
-let remain = {
-  stack: null,
-  node: null,
-  line: null
-};
-const ideScheduler = TaskQueue.create({
-  callbackAble: ide,
-  aIsUrgent(a, b) {
-    return a.index < b.index;
-  }
-});
-function handleOneTask(s, breakStack) {
-  breakStack = remain.stack || breakStack;
-  // 将 s 同步到 remainRoot
-  let lineToRemove = null;
-  const startTime = now();
-  try {
-    dfs(s, {
-      breakStack,
-      breakNode: remain.node,
-      breakLine: remain.line,
-      isUp: true,
-      begin: ({
-        walkedLine,
-        node,
-        lineFromUp
-      }) => {
-        if (lineToRemove) {
-          Line.unlink(lineToRemove);
-          lineToRemove = null;
-        }
-        if (now() - startTime > 5) {
-          remain = {
-            stack: walkedLine,
-            node: node,
-            line: lineFromUp
-          };
-          throw BreakErr;
-        }
-        if (!(node.state & State.OutLink)) {
-          return true;
-        }
-        // 对于嵌套作用域不允许重复进入
-        node.state &= ~State.OutLink;
-      },
-      complete: ({
-        node,
-        notGoDeep,
-        walkedLine
-      }) => {
-        if (lineToRemove) {
-          Line.unlink(lineToRemove);
-          lineToRemove = null;
-        }
-        if (notGoDeep) {
-          const last = walkedLine[walkedLine.length - 1];
-          const downstream = last === null || last === void 0 ? void 0 : last.downstream;
-          // 节点没被标记 OutLink 但是发现与下游节点的 scope 不一致，是需要解除 link 的位置
-          if (downstream && downstream.scope !== node.scope) {
-            lineToRemove = last;
-          }
-        }
-      }
-    });
-    remain = {
-      stack: null,
-      node: null,
-      line: null
-    };
-  } catch (error) {
-    if (error === BreakErr) return true;
-    remain = {
-      stack: null,
-      node: null,
-      line: null
-    };
-    throw error;
-  }
+  Line.unlink(line);
 }
-function unlinkRecWithScope(line) {
-  // 作为下游，执行完 get 上游节点已经完成了依赖更新，把 recEnd 后的依赖删除即可
-  let toDel = line;
+function dispose() {
+  let toDel = this.recStart;
   while (toDel) {
     const memoNext = toDel.nextRecLine;
     const upstream = toDel.upstream;
-    Line.unlink(toDel);
-    // 删除完后看看是否要被 scope 管理
-    trackIsland(upstream);
+    if (upstream.state & State.IsScope) {
+      dfs(upstream, {
+        isUp: true,
+        begin: ({ node }) => {
+          if (!(node.state & State.IsScope) || node.state & ScopeAbort) return true;
+        },
+        complete: ({ node: scope, notGoDeep }) => {
+          const shouldAbort = !notGoDeep;
+          if (shouldAbort) {
+            releaseScope(scope);
+          }
+        }
+      });
+    } else {
+      unlinkSingleLine(toDel);
+    }
     toDel = memoNext;
   }
+  releaseScope(this);
+  doUnlink(this.emitStart);
 }
-
-function Signal_$$$_create(nextValue, {
-  customPull,
-  isScope,
-  ...rest
-}) {
-  const s = Signal(nextValue, customPull);
-  s.pull = s.customPull || s.DEFAULT_PULL;
-  Object.assign(s, rest);
-  if (isScope) {
-    s.scope = s;
+function releaseScope(scope) {
+  var _a;
+  let outLink = scope.outLink;
+  while (outLink) {
+    const memoNext = outLink.nextOutLink;
+    unlinkSingleLine(outLink);
+    outLink = memoNext;
   }
-  return s;
+  scope.state |= State.ScopeAbort;
+  (_a = scope.clean) == null ? void 0 : _a.call(scope);
+  scope.clean = null;
+}
+function clean(cb) {
+  G.PullingSignal.clean = () => runWithPulling(cb, null);
 }
-Signal.create = Signal_$$$_create;
-const markDeep = signal => {
+function runWithPulling(fn, signal) {
+  const prevPulling = G.PullingSignal;
+  G.PullingSignal = signal;
+  fn();
+  G.PullingSignal = prevPulling;
+}
+
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$1.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$1.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const markDeep = (signal) => {
   let level = 0;
   dfs(signal, {
     isUp: false,
-    begin: ({
-      node
-    }) => {
-      /**
-       * 1. 当前节点在预检  应该跳过
-       * 2. 当前节点       已标记
-       * 3. 当前节点       已放弃
-       */
-      // console.log('markBegin', node.id);
-      if (node.state & (State.Check | State.Unknown | State.Dirty) || node.isAbort()) {
+    begin: ({ node }) => {
+      if (node.state & (State.Check | State.Unknown | State.Dirty) || node.isDisabled()) {
         return true;
       }
       const isEffect = level > 0;
-      const isLeaf = !node.emitStart || node.emitStart.downstream['scope'] === node.emitStart.downstream;
+      const isLeaf = !node.emitStart || node.emitStart.downstream === node.scope;
       if (isEffect) {
         node.state |= State.Unknown;
-      } else {
+      } else if (!isLeaf) {
         node.state |= State.Dirty;
       }
       if (isLeaf && isEffect) {
@@ -834,287 +585,272 @@ const markDeep = signal => {
   }
   dirtyLeafs.clear();
 };
-function Signal(nextValue,
-/** 为什么是 shallow，因为 pullDeep 会把
- * 上游节点 get 执行完成，让其可以直接拿到缓存值
- */
-customPull) {
-  return {
-    nextValue: nextValue,
-    customPull: customPull,
-    version: -1,
-    id: G.id++,
-    state: State.Clean,
-    scope: Signal.Pulling,
-    recEnd: null,
-    recStart: null,
-    emitStart: null,
-    emitEnd: null,
-    scheduler: null,
-    value: null,
-    pull: null,
-    DEFAULT_PULL: Signal_$$$_DEFAULT_PULL,
-    pullRecurse: Signal_$$$_pullRecurse,
-    pullDeep: Signal_$$$_pullDeep,
-    get: Signal_$$$_get,
-    markDownStreamsDirty: Signal_$$$_markDownStreamsDirty,
-    set: Signal_$$$_set,
-    run: Signal_$$$_run,
-    runIfDirty: Signal_$$$_runIfDirty,
-    isAbort: Signal_$$$_isAbort
-  };
-}
-function Signal_$$$_DEFAULT_PULL() {
-  return this.nextValue;
-}
-function Signal_$$$_pullRecurse(shouldLink = true) {
-  var _a;
-  let downstream = Signal.Pulling;
-  if (shouldLink && downstream) {
-    // 如果上游节点被 scope 管理了，解除管理
-    unTrackIsland(this);
-    Line.link(this, downstream);
+const _Signal = class _Signal {
+  constructor(nextValue, customPull) {
+    this.nextValue = nextValue;
+    this.customPull = customPull;
+    this.version = -1;
+    this.id = G.id++;
+    this.state = State.Clean;
+    /** 当前节点创建时处于的 effect 就是 scope */
+    this.scope = G.PullingSignal;
+    this.recEnd = null;
+    this.recStart = null;
+    this.emitStart = null;
+    this.emitEnd = null;
+    this.scheduler = null;
+    this.value = null;
+    this.outLink = null;
+    this.pull = null;
+    /** 记录当前 effect 中 clean */
+    this.clean = null;
+  }
+  static create(nextValue, _a) {
+    var _b = _a, { customPull, isScope, immediate } = _b, rest = __objRest(_b, ["customPull", "isScope", "immediate"]);
+    const s = new _Signal(nextValue, customPull);
+    s.pull = s.customPull || s.DEFAULT_PULL;
+    Object.assign(s, rest);
+    if (isScope) {
+      s.state |= State.IsScope;
+    }
+    return s;
   }
-  try {
-    if (this.version === G.version) {
-      return this.value;
+  DEFAULT_PULL() {
+    return this.nextValue;
+  }
+  /**
+   * 递归拉取负责建立以来链
+   */
+  pullRecurse(shouldLink = true) {
+    var _a, _b;
+    let downstream = G.PullingSignal;
+    const isScope = this.state & State.IsScope;
+    if (
+      // 1. 外部支持 link
+      shouldLink && // 2. 有下游
+      downstream && // 3. 下游是 watcher，不链接非 scope
+      !(downstream.state & State.LinkScopeOnly && !isScope)
+    ) {
+      Line.link(this, downstream);
     }
-    this.state &= ~State.OutLink;
-    // 进 pullShallow 前重置 recEnd，让子 getter 重构订阅链表
-    this.recEnd = undefined;
-    Signal.Pulling = this;
-    const v = this.pull();
-    // 如果使用了 DEFAULT_PULL，处理一次 set 的取值后，替换回 customPull，如果有的话
-    this.pull = this.customPull || this.DEFAULT_PULL;
-    this.value = v;
-    // 依赖上游的 版本号
-    this.version = G.version;
-    // if (this.value !== v) {
-    // }
-    return this.value;
-  } catch (error) {
-    console.error('计算属性报错这次不触发，后续状态可能出错', error);
-    return this.value;
-  } finally {
-    // 本 getter 执行完成时上游 getter 通过 link，完成对下游 recLines 的更新
-    const toDel = (_a = this.recEnd) === null || _a === void 0 ? void 0 : _a.nextRecLine;
-    unlinkRecWithScope(toDel);
-    if (shouldLink && downstream) {
-      // 用于 scope 指示哪些节点依赖 scope 外部
-      markOutLink(this, downstream);
+    try {
+      if (this.version === G.version) {
+        return this.value;
+      }
+      this.recEnd = null;
+      G.PullingSignal = this;
+      (_a = this.clean) == null ? void 0 : _a.call(this);
+      this.clean = null;
+      let v = this.pull();
+      if (isScope && typeof v === "function") {
+        const fn = v;
+        this.clean = () => runWithPulling(fn, null);
+        v = this.value;
+      }
+      this.pull = this.customPull || this.DEFAULT_PULL;
+      this.value = v;
+      this.version = G.version;
+      return this.value;
+    } catch (error) {
+      console.error("\u8BA1\u7B97\u5C5E\u6027\u62A5\u9519\u8FD9\u6B21\u4E0D\u89E6\u53D1\uFF0C\u540E\u7EED\u72B6\u6001\u53EF\u80FD\u51FA\u9519", error);
+      return this.value;
+    } finally {
+      const toDel = (_b = this.recEnd) == null ? void 0 : _b.nextRecLine;
+      unlinkRecWithScope(toDel);
+      G.PullingSignal = downstream;
     }
-    Signal.Pulling = downstream;
   }
-}
-function Signal_$$$_pullDeep() {
-  /*----------------- 有上游节点，通过 dfs 重新计算结果 -----------------*/
-  const signal = this;
-  // 优化执行
-  if (!(signal.state & DirtyState)) {
-    return this.value;
-  }
-  dfs(signal, {
-    isUp: true,
-    begin: ({
-      node
-    }) => {
-      // console.log('begin', node.id);
-      /**
-       * 不需要检查
-       * 1. 正在查
-       * 2. 干净
-       * 3. 放弃 或者为 scope 节点
-       */
-      if (node.state & State.Check || !(node.state & DirtyState) || node.isAbort()) {
-        return true;
-      }
-      node.state |= State.Check;
-      // 交给下游重新计算是否 引用外部节点
-      node.state &= ~State.OutLink;
-    },
-    complete: ({
-      node,
-      notGoDeep: currentClean,
-      walkedLine
-    }) => {
-      let noGoSibling = false;
-      const last = walkedLine[walkedLine.length - 1];
-      const downstream = last === null || last === void 0 ? void 0 : last.downstream;
-      // 当前正在检查，生成检查屏障，同时避免重新标记 和
-      if (currentClean) ;
-      // 当前节点需要重新计算
-      else if (node.state & State.Dirty) {
-        // 优化：源节点变化，直接让下游节点重新计算
-        if (!node.recStart && node.value !== node.nextValue) {
-          node.markDownStreamsDirty();
-          node.state &= ~State.Dirty;
-          node.state &= ~State.Check;
-          return;
+  pullDeep() {
+    const signal = this;
+    if (!(signal.state & DirtyState)) {
+      return this.value;
+    }
+    dfs(signal, {
+      isUp: true,
+      begin: ({ node }) => {
+        if (node.state & State.Check || !(node.state & DirtyState) || node.isDisabled()) {
+          return true;
         }
-        // 预检数据
-        else {
-          const prevPulling = Signal.Pulling;
-          Signal.Pulling = downstream;
-          const prevValue = node.value;
-          // 递归转用递归拉取，且不需要重建 link 因为dfs的前提就是上游节点依赖于 本节点
-          node.pullRecurse(false);
-          // dirty 传播， 由于本节点值已被计算出，因此消除 dirty
-          if (prevValue !== node.value) {
+        node.state |= State.Check;
+      },
+      complete: ({ node, notGoDeep: currentClean, walkedLine }) => {
+        let noGoSibling = false;
+        const last = walkedLine[walkedLine.length - 1];
+        const downstream = last == null ? void 0 : last.downstream;
+        if (currentClean) ; else if (node.state & State.Dirty) {
+          if (!node.recStart && node.value !== node.nextValue) {
             node.markDownStreamsDirty();
+            node.state &= ~State.Dirty;
+            node.state &= ~State.Check;
+            return;
+          } else {
+            const prevPulling = G.PullingSignal;
+            G.PullingSignal = downstream;
+            const prevValue = node.value;
+            node.pullRecurse(false);
+            if (prevValue !== node.value) {
+              node.markDownStreamsDirty();
+            }
+            node.state &= ~State.Dirty;
+            G.PullingSignal = prevPulling;
+            noGoSibling = true;
           }
-          node.state &= ~State.Dirty;
-          Signal.Pulling = prevPulling;
-          // 立刻返回父节点重新计算
-          noGoSibling = true;
+        } else if (node.state & State.Unknown) {
+          node.state &= ~State.Unknown;
         }
+        node.version = G.version;
+        node.state &= ~State.Check;
+        return noGoSibling;
       }
-      // 没被上游节点标记为 Dirty，说明是干净的
-      else if (node.state & State.Unknown) {
-        node.state &= ~State.Unknown;
-      }
-      node.version = G.version;
-      node.state &= ~State.Check;
-      if (downstream) {
-        markOutLink(node, downstream);
-      }
-      return noGoSibling;
-    }
-  });
-  return this.value;
-}
-function Signal_$$$_get() {
-  if (this.isAbort()) {
+    });
     return this.value;
   }
-  // 没有上游节点，应该通过递归重新建立
-  if (!this.recStart) {
-    return this.pullRecurse(true);
+  get v() {
+    if (this.isDisabled()) {
+      return this.value;
+    }
+    if (!this.recStart) {
+      return this.pullRecurse(true);
+    }
+    return this.pullDeep();
+  }
+  // pause() {
+  //   this.state |= State.SelfPaused;
+  // }
+  // resume() {
+  //   this.state &= ~State.SelfPaused;
+  // }
+  markDownStreamsDirty() {
+    let point = this.emitStart;
+    while (point != null) {
+      const downstream = point.downstream;
+      downstream.state |= State.Dirty;
+      downstream.state &= ~State.Unknown;
+      point = point.nextEmitLine;
+    }
   }
-  // 有上游节点则采用 dfs 直接遍历，查看情况
-  return this.pullDeep();
-}
-function Signal_$$$_markDownStreamsDirty() {
-  let point = this.emitStart;
-  while (point != null) {
-    const downstream = point.downstream;
-    downstream.state |= State.Dirty;
-    downstream.state &= ~State.Unknown;
-    point = point.nextEmitLine;
+  set v(v) {
+    if (this.isDisabled() || this.nextValue === v) {
+      return;
+    }
+    this.nextValue = v;
+    this.pull = this.DEFAULT_PULL;
+    G.version++;
+    markDeep(this);
   }
-}
-function Signal_$$$_set(v) {
-  if (this.isAbort() || this.nextValue === v) {
-    return;
+  runIfDirty() {
+    this.state & (State.Unknown | State.Dirty) && this.v;
   }
-  this.nextValue = v;
-  // 手动设值后，采用默认拉取，能拉取到设置的值，拉取完成后在替换回 customPull
-  this.pull = this.DEFAULT_PULL;
-  G.version++;
-  markDeep(this);
-}
-function Signal_$$$_run(...args) {
-  if (args.length) {
-    return this.set(args[0]);
+  isDisabled() {
+    return (
+      // scope 被取消
+      this.scope && this.scope.state & State.ScopeAbort || // 是 scope 节点，且处于 ready 状态，不需要重复执行
+      this.state & State.IsScope && this.state & ScopeExecuted
+    );
   }
-  return this.get();
-}
-function Signal_$$$_runIfDirty() {
-  this.state & (State.Unknown | State.Dirty) && this.run();
-}
-function Signal_$$$_isAbort() {
-  return (
-    // scope 被取消
-    this.scope && this.scope.state & State.ScopeAbort ||
-    // 是 scope 节点，且处于 ready 状态，不需要重复执行
-    this === this.scope && this.state & (State.ScopeAbort | State.ScopeReady)
-  );
-}
-Signal.Pulling = null;
-function runWithPulling(fn, signal) {
-  const prevPulling = Signal.Pulling;
-  Signal.Pulling = signal;
-  fn();
-  Signal.Pulling = prevPulling;
-}
+};
+_Signal.Pulling = null;
+let Signal = _Signal;
 
-const DefaultCustomSignalOpt = {
-  scheduler: exports.Scheduler.Sync,
-  isScope: false
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
 };
-const $ = (init, opt = {}) => {
-  let intiValue, pull;
+({
+  scheduler: Scheduler.Sync});
+const $ = (init) => {
+  let intiValue, customPull;
   if (init instanceof Function) {
-    intiValue = undefined;
-    pull = init;
+    intiValue = null;
+    customPull = init;
   } else {
     intiValue = init;
   }
-  const signalOpt = {
-    ...DefaultCustomSignalOpt,
-    ...opt,
-    customPull: pull
-  };
-  const s = Signal.create(intiValue, signalOpt);
-  const bound = s.run.bind(s);
-  bound.ins = s;
-  Object.defineProperty(bound, 'v', {
-    get() {
-      return s.get();
-    },
-    set(v) {
-      return s.set(v);
-    }
+  const s = Signal.create(intiValue, {
+    scheduler: Scheduler.Sync,
+    isScope: false,
+    customPull
   });
-  return bound;
+  return s;
 };
-const watch = (values, watcher, opt) => {
+const effect = (customPull, depOrOpt, opt) => {
+  var _a;
+  const hasDep = Array.isArray(depOrOpt);
+  opt = hasDep ? opt || {} : depOrOpt || {};
+  if (!hasDep) {
+    const s2 = Signal.create(null, __spreadValues({
+      customPull,
+      scheduler: Scheduler.Sync,
+      isScope: true
+    }, opt));
+    s2.v;
+    const bound2 = dispose.bind(s2);
+    bound2.ins = s2;
+    return bound2;
+  }
   let mounted = false;
-  const get = $(() => {
-    for (const get of values) {
-      get();
-    }
-    if (mounted) {
-      runWithPulling(watcher, undefined);
-    }
-    mounted = true;
-  }, opt);
-  get();
-  return get;
+  const deps = depOrOpt;
+  const immediate = deps.length === 0 ? true : (_a = opt.immediate) != null ? _a : true;
+  const vs = Array.from({ length: deps.length }, () => ({ old: null, val: null }));
+  const s = Signal.create(null, __spreadValues({
+    customPull() {
+      for (let i = 0; i < deps.length; i++) {
+        const value = deps[i].v;
+        vs[i].old = vs[i].val;
+        vs[i].val = value;
+      }
+      if (mounted || immediate) {
+        s.state |= State.LinkScopeOnly;
+        customPull(...vs);
+        s.state &= ~State.LinkScopeOnly;
+      }
+      mounted = true;
+    },
+    scheduler: Scheduler.Sync,
+    isScope: true
+  }, opt));
+  s.v;
+  const bound = dispose.bind(s);
+  bound.ins = s;
+  return bound;
 };
-const scope = fn => {
-  const s = Signal.create(undefined, {
-    customPull: fn,
+const scope = (customPull) => {
+  const s = Signal.create(null, {
+    customPull,
+    scheduler: Scheduler.Sync,
     isScope: true
   });
-  s.get();
+  s.v;
   s.state |= State.ScopeReady;
-  function dispose() {
-    s.state |= State.ScopeAbort;
-    const bound = handleOneTask.bind(undefined, s, []);
-    bound.index = G.scopeDisposeI++;
-    ideScheduler.pushTask(bound);
-  }
-  dispose.ins = s;
-  return dispose;
+  const bound = dispose.bind(s);
+  bound.ins = s;
+  return bound;
 };
-/**
- * 数据变化时，自定义 触发订阅函数的时机
- * @param {CustomSignalOpt} opt 配置如下:
- * @prop scheduler: (runIfDirty, effect) => void 执行 runIfDirty 定制触发 effect 时机
- * @prop scope: 用于统一释放 effect link 的作用域 默认是 defaultScope 可以全局获取
- */
-const customSignal = opt => {
-  return (init, innerOpt = {}) => {
-    const s = $(init, {
-      ...opt,
-      ...innerOpt
-    });
-    return s;
-  };
+const customEffect = (opt) => {
+  return ((init, innerOpt = {}) => {
+    return effect(init, __spreadValues(__spreadValues({}, opt), innerOpt));
+  });
 };
 
 exports.$ = $;
-exports.customSignal = customSignal;
+exports.Scheduler = Scheduler;
+exports.TaskQueue = TaskQueue;
+exports.clean = clean;
+exports.customEffect = customEffect;
+exports.effect = effect;
+exports.runWithPulling = runWithPulling;
 exports.scheduler = scheduler;
 exports.scope = scope;
-exports.watch = watch;
+//# sourceMappingURL=aoye.cjs.js.map