aoye 0.0.2 → 0.0.4

package/dist/aoye.cjs.js

@@ -1,249 +1,32 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
+var bobeShared = require('bobe-shared');
 
-class SortMap {
-  constructor() {
-    this.data = {};
-  }
-  clear() {
-    this.data = {};
-  }
-  add(key, value) {
-    const {
-      data
-    } = this;
-    let list = data[key];
-    if (!list) {
-      list = [];
-      data[key] = list;
-    }
-    list.push(value);
-  }
-}
-// 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();
-
-const timestamp = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
-var EventMode;
-(function (EventMode) {
-  EventMode[EventMode["Immediate"] = 0] = "Immediate";
-  EventMode[EventMode["Queue"] = 1] = "Queue";
-})(EventMode || (EventMode = {}));
-var ProcessStatus;
-(function (ProcessStatus) {
-  ProcessStatus[ProcessStatus["None"] = 0] = "None";
-  ProcessStatus[ProcessStatus["Processing"] = 1] = "Processing";
-  ProcessStatus[ProcessStatus["Paused"] = 2] = "Paused";
-})(ProcessStatus || (ProcessStatus = {}));
-const DefaultEventOpt = {
-  mode: EventMode.Immediate
-};
-const ALL = '__ALL_KEY';
-class BaseEvent {
-  constructor(opt = {}) {
-    this.opt = opt;
-    this.eventQueue = [];
-    this.status = ProcessStatus.None;
-    this.subMap = new Map();
-    this.on = (type, fn) => {
-      if (type == null) type = ALL;
-      const suber = this.subMap.get(type) || new Set();
-      suber.add(fn);
-      this.subMap.set(type, suber);
-    };
-    this.off = (type, fn) => {
-      const suber = this.subMap.get(type !== null && type !== void 0 ? type : ALL);
-      if (!suber) return;
-      suber.delete(fn);
-    };
-    this.once = (type, fn) => {
-      fn['once'] = true;
-      this.on(type, fn);
-    };
-    this.promiseOnce = type => {
-      return new Promise(resolve => {
-        this.once(type, (...args) => {
-          resolve(args);
-        });
-      });
-    };
-    this.setScheduler = (type, scheduler) => {
-      if (typeof type !== 'string') {
-        this.scheduler = type;
-        return;
-      }
-      const set = this.subMap.get(type) || new Set();
-      set['scheduler'] = scheduler;
-      this.subMap.set(type, set);
-    };
-    // construct 会初始化为下面其中一种
-    this.emit = (type, ...args) => {
-      this.opt.mode === EventMode.Immediate ? this.emitImmediate(type, ...args) : this.emitQueue(type, ...args);
-    };
-    this.pause = () => this.status = ProcessStatus.Paused;
-    this.unPause = () => this.status = ProcessStatus.None;
-    this.start = () => {
-      this.status = ProcessStatus.None;
-      this.processQueue();
-    };
-    this.process = () => {
-      if (this.scheduler) {
-        return this.scheduler(this.recallScheduler);
-      }
-      return this.processQueue();
-    };
-    this.recallScheduler = () => {
-      this.scheduler(this.recallScheduler);
-    };
-    this.processQueue = () => {
-      // 如果是挂起状态则直接结束
-      if (this.status === ProcessStatus.Paused) return;
-      this.status = ProcessStatus.Processing;
-      let {
-        type,
-        args
-      } = this.eventQueue.shift() || {};
-      if (type) {
-        // 在此过程中用户可通过 pause 和 start 同步控制事件处理
-        const fns = this.subMap.get(type);
-        const allSub = this.subMap.get(ALL);
-        fns === null || fns === void 0 ? void 0 : fns.forEach(it => this.callSub(it, fns, args));
-        allSub === null || allSub === void 0 ? void 0 : allSub.forEach(it => this.callSub(it, allSub, args));
-        if (this.eventQueue.length > 0) {
-          this.processQueue();
-        }
-      }
-      //@ts-ignore 队列全部处理完成，如果执行过程中被 pause 
-      if (this.status !== ProcessStatus.Paused) {
-        this.status = ProcessStatus.None;
-      }
-    };
-    this.dispatchEvent = iList => {
-      // 从大到小排序
-      iList.sort((a, b) => b - a);
-      iList.forEach(idx => {
-        const [item] = this.eventQueue.splice(idx, 1);
-        const {
-          type,
-          args
-        } = item || {};
-        if (type && args) {
-          this.emitImmediate(type, ...args);
-        }
-      });
-    };
-    this.clear = () => {
-      this.subMap.clear();
-      this.eventQueue = [];
-      this.scheduler = undefined;
-    };
-    this.opt = {
-      ...DefaultEventOpt,
-      ...opt
-    };
-  }
-  callSub(it, fns, args) {
-    const doCall = (...args) => {
-      it(...args);
-      if (it['once'] === true) fns.delete(it);
-    };
-    const scheduler = it['scheduler'] || fns['scheduler'];
-    if (scheduler) {
-      scheduler(doCall, ...args);
-    } else {
-      it(...args);
-      if (it['once'] === true) fns.delete(it);
-    }
-  }
-  emitImmediate(type, ...args) {
-    const fns = this.subMap.get(type);
-    const allSub = this.subMap.get(ALL);
-    fns === null || fns === void 0 ? void 0 : fns.forEach(it => this.callSub(it, fns, args));
-    allSub === null || allSub === void 0 ? void 0 : allSub.forEach(it => this.callSub(it, allSub, args));
-  }
-  emitQueue(type, ...args) {
-    this.eventQueue.push({
-      type,
-      args,
-      time: timestamp()
-    });
-    this.process();
-  }
-}
-BaseEvent.a = 19;
-
-const evt = new BaseEvent();
+const evt = new bobeShared.BaseEvent();
 const G = {
   /** 原子 signal 更新次数 */
   version: 0,
   id: 0,
   /** scope 销毁任务序号 */
-  scopeDisposeI: 0
+  scopeDisposeI: 0,
+  PullingSignal: null
 };
-const dirtyLeafs = new SortMap();
-var State;
-(function (State) {
-  State[State["Clean"] = 0] = "Clean";
-  /** 仅用于 scope 节点是否 abort */
-  State[State["ScopeAborted"] = 64] = "ScopeAborted";
-  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;
-const ScopeExecuted = State.ScopeReady | State.ScopeAbort | State.ScopeAborted;
+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 */;
 
-/**
- * 这是一个优先队列 （满足子节点总是比父节点大）
- *                    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);
@@ -262,12 +45,9 @@ class PriorityQueue {
         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;
         }
       }
@@ -288,33 +68,26 @@ class PriorityQueue {
         if (point === i) {
           break;
         }
-        // console.log(`交换 parent:${arr[i]} -> child:${arr[point]} `);
         exchange(arr, i, point);
-        // this.logTree();
         i = point;
       }
     };
   }
   // 添加一个元素
   _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);
   }
   add(...items) {
-    items.forEach(it => this._add(it));
+    items.forEach((it) => this._add(it));
   }
   // 去除头元素并返回
   poll() {
-    const {
-      arr
-    } = this;
-    // console.log(`弹出 ${arr[0]} 把 ${arr[arr.length - 1]} 放置到队头 `);
+    const { arr } = this;
     const len = this.size();
     if (len <= 2) {
       return arr.shift();
@@ -322,7 +95,6 @@ class PriorityQueue {
     const last = arr.pop();
     const first = arr[0];
     arr[0] = last;
-    // this.logTree();
     this.goDown(this.arr, 0);
     return first;
   }
@@ -335,9 +107,7 @@ class PriorityQueue {
     return this.arr.length;
   }
   logTree() {
-    const {
-      arr
-    } = this;
+    const { arr } = this;
     let i = 0;
     let j = 1;
     let level = 0;
@@ -351,40 +121,14 @@ class PriorityQueue {
     const last = Math.pow(2, matrix.length - 1);
     const arrStr = JSON.stringify(last);
     const halfLen = arrStr.length >>> 1;
-    matrix.forEach(it => {
+    matrix.forEach((it) => {
       const str = JSON.stringify(it);
       const halfIt = str.length >>> 1;
-      console.log(str.padStart(halfLen + halfIt, ' '));
+      console.log(str.padStart(halfLen + halfIt, " "));
     });
-    console.log('\n');
+    console.log("\n");
   }
 }
-// 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]
 
 class TaskQueue {
   constructor(callbackAble, aIsUrgent) {
@@ -392,19 +136,13 @@ class TaskQueue {
     this.aIsUrgent = aIsUrgent;
     this.isScheduling = false;
   }
-  static create({
-    callbackAble,
-    aIsUrgent
-  }) {
+  static create({ callbackAble, aIsUrgent }) {
     const queue = new TaskQueue(callbackAble, aIsUrgent);
     queue.taskQueue = new PriorityQueue(aIsUrgent);
     return queue;
   }
   pushTask(task) {
-    const {
-      taskQueue,
-      isScheduling
-    } = this;
+    const { taskQueue, isScheduling } = this;
     taskQueue._add(task);
     if (!isScheduling) {
       this.callbackAble(this.scheduleTask.bind(this));
@@ -412,45 +150,30 @@ class TaskQueue {
     }
   }
   scheduleTask() {
-    const {
-      taskQueue
-    } = this;
-    // console.log('调度 dispose');
+    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);
+    evt.emit("one", fn);
     if (taskQueue.size() === 0) {
-      evt.emit('done', fn);
+      evt.emit("done", fn);
       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();
-};
 let channel = globalThis.MessageChannel ? new MessageChannel() : null;
 if (globalThis.MessageChannel) {
   channel = new MessageChannel();
 }
 let msgId = 0;
-const macro = fn => {
+const macro = (fn) => {
   if (!channel) {
     setTimeout(fn);
   }
@@ -458,29 +181,29 @@ const macro = fn => {
   function onMessage(e) {
     if (memoId === e.data) {
       fn();
-      channel.port2.removeEventListener('message', onMessage);
+      channel.port2.removeEventListener("message", onMessage);
     }
   }
-  channel.port2.addEventListener('message', onMessage);
+  channel.port2.addEventListener("message", onMessage);
   channel.port1.postMessage(msgId++);
 };
 const p = Promise.resolve();
-const micro = cb => {
+const micro = (cb) => {
   p.then(cb);
 };
 
-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]: layoutScheduler
+  ["__Sync_" /* Sync */]: defaultScheduler,
+  ["__Micro_" /* Micro */]: microScheduler,
+  ["__Macro_" /* Macro */]: macroScheduler,
+  ["__Layout_" /* Layout */]: layoutScheduler
 };
 const scheduler = (key, value) => _scheduler[key] = value;
 function defaultScheduler(effects) {
@@ -492,56 +215,53 @@ let microSTaskQueue;
 let macroSTaskQueue;
 let layoutSTaskQueue;
 function microScheduler(effects) {
-  microSTaskQueue = microSTaskQueue || TaskQueue.create({
-    callbackAble: micro,
-    aIsUrgent: (a, b) => a.time < b.time
-  });
-  microSTaskQueue.pushTask(defaultScheduler.bind(undefined, effects));
+  microSTaskQueue = microSTaskQueue || TaskQueue.create({ callbackAble: micro, aIsUrgent: (a, b) => a.time < b.time });
+  microSTaskQueue.pushTask(defaultScheduler.bind(null, effects));
 }
 function macroScheduler(effects) {
-  macroSTaskQueue = macroSTaskQueue || TaskQueue.create({
-    callbackAble: macro,
-    aIsUrgent: (a, b) => a.time < b.time
-  });
-  macroSTaskQueue.pushTask(defaultScheduler.bind(undefined, effects));
+  macroSTaskQueue = macroSTaskQueue || TaskQueue.create({ callbackAble: macro, aIsUrgent: (a, b) => a.time < b.time });
+  macroSTaskQueue.pushTask(defaultScheduler.bind(null, effects));
 }
 function layoutScheduler(effects) {
-  layoutSTaskQueue = layoutSTaskQueue || TaskQueue.create({
-    callbackAble: macro,
-    aIsUrgent: (a, b) => a.time < b.time
-  });
-  layoutSTaskQueue.pushTask(defaultScheduler.bind(undefined, 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
     });
@@ -553,128 +273,121 @@ 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];
     }
   }
 }
 
 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;
+    let { emitEnd } = v1, { recEnd, recStart } = v2, noRecEnd = !recEnd, head = { nextRecLine: recStart }, line;
     recEnd = recEnd || head;
-    const {
-      nextRecLine
-    } = recEnd || {};
-    // 没有下一个收到的线
+    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) {
+    } else if (nextRecLine.upstream === v1) {
       v2.recEnd = nextRecLine;
-      // TODO: link 版本标记
-    }
-    // 插入(这么做): v1 和 下一个 入度(订阅)节点不同
-    // TODO: v2上次真依赖了 v1 只是没检查出来，需要删除原依赖
-    else {
+    } 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);
     }
-    // 消除 head
     for (const key in head) {
-      head[key] = undefined;
+      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;
+      }
     }
   }
   static 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;
-    /** 上游节点发出的线 前一条 关联 后一条 */
+    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;
     }
-    /** 下游节点接收的线，我们从 recEnd 开始删除的，
-     * 接收信息，不需要设置 recEnd ，
-     * 因为 recStart ~ recEnd 是经过上级 get 确认的有用依赖
-     * */
     if (prevRecLine) {
       prevRecLine.nextRecLine = nextRecLine;
     } else {
-      // 删除的是首个节点，大概率不可能从有依赖 变成无依赖
       downstream.recStart = nextRecLine;
     }
     if (nextRecLine) {
       nextRecLine.prevRecLine = prevRecLine;
     } else {
-      // 删除尾节点
       downstream.recEnd = prevRecLine;
     }
   }
   static unlinkRec(line) {
-    // 作为下游，执行完 get 上游节点已经完成了依赖更新，把 recEnd 后的依赖删除即可
     let toDel = line;
     while (toDel) {
       const memoNext = toDel.nextRecLine;
@@ -683,7 +396,6 @@ class Line {
     }
   }
   static unlinkEmit(line) {
-    // 作为下游，执行完 get 上游节点已经完成了依赖更新，把 recEnd 后的依赖删除即可
     let toDel = line;
     while (toDel) {
       const memoNext = toDel.nextEmitLine;
@@ -731,198 +443,133 @@ class Line {
     l2.prevRecLine = ins;
     ins.nextRecLine = l2;
   }
-  constructor() {
-    /** 上游顶点 */
-    this.upstream = null;
-    /** 上游节点 发出的上一条线 */
-    this.prevEmitLine = null;
-    /** 上游节点 发出的下一条线 */
-    this.nextEmitLine = null;
-    /** 下游顶点 */
-    this.downstream = null;
-    /** 下游节点 接收的上一条线 */
-    this.prevRecLine = null;
-    /** 下游节点 接收的下一条线 */
-    this.nextRecLine = null;
-  }
 }
 
-/** scope 捕获，引用外部 signal 孤岛 */
-const unTrackIsland = signal => {
-  // 原来是孤岛，且被 scope 管理的要恢复
-  if (signal.emitStart && signal.emitStart.downstream === signal.scope) {
-    Line.unlink(signal.emitStart);
-  }
-};
-/** scope 释放，被重新连接的孤岛 */
-const trackIsland = signal => {
-  const line = new 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);
-  }
-};
-/** 子 scope 释放，把其 only 被其持有的 signal 挂回其属于的 scope */
-const trackByOtherScopeDispose = signal => {
-  const line = new Line();
-  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 unlinkRecWithScope(line) {
+  let toDel = line;
+  while (toDel) {
+    const memoNext = toDel.nextRecLine;
+    const upstream = toDel.upstream;
+    if (upstream.state & State.IsScope) {
+      dispose.call(upstream);
+    } else {
+      unlinkSingleLine(toDel);
+    }
+    toDel = memoNext;
   }
-});
-function handleOneTask(scope, breakStack) {
-  breakStack = remain.stack || breakStack;
-  // 将 s 同步到 remainRoot
-  let lineToRemove = null;
-  const startTime = now();
-  if (scope.emitStart) {
-    Line.unlink(scope.emitStart);
+}
+function unlinkSingleLine(line) {
+  const upstream = line.upstream;
+  if (upstream.emitStart === upstream.emitEnd) {
+    unlinkSingleRefedNode(upstream);
+  } else {
+    Line.unlink(line);
   }
-  try {
-    dfs(scope, {
-      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;
-        }
-        // 1. 未标记的节点，是外部节点
-        if (!(node.state & State.OutLink)) {
-          return true;
-        }
-        // 2. 标记的节点，但是 scope 不一样，说明外部节点也引用了 另一 scope 的节点
-        if (lineFromUp && node.scope !== lineFromUp.downstream['scope']) {
-          // 是仅被 node 引用的外部节点
-          if (node.emitStart === node.emitEnd) {
-            // 已经 abort 只能继续释放
-            if (scope.state & State.ScopeAborted) {
-              const bound = handleOneTask.bind(undefined, node, []);
-              bound.index = G.scopeDisposeI++;
-              ideScheduler.pushTask(bound);
-            }
-            // 可以将其交给 原 scope 释放
-            else {
-              trackByOtherScopeDispose(node);
-            }
-          }
-          // 任何外部引用都应该被断开
-          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;
-          }
-        }
+}
+function unlinkSingleRefedNode(delRoot) {
+  let toUnlink;
+  dfs(delRoot, {
+    isUp: true,
+    begin: ({ node }) => {
+      doUnlink(toUnlink);
+      toUnlink = null;
+      if (node.emitStart !== node.emitEnd) {
+        return true;
       }
-    });
-    remain = {
-      stack: null,
-      node: null,
-      line: null
-    };
-    scope.state |= State.ScopeAborted;
-  } catch (error) {
-    if (error === BreakErr) return true;
-    remain = {
-      stack: null,
-      node: null,
-      line: null
-    };
-    throw error;
+    },
+    complete: ({ node, notGoDeep }) => {
+      doUnlink(toUnlink);
+      toUnlink = null;
+      const isSingleRefed = !notGoDeep;
+      if (isSingleRefed) {
+        toUnlink = node.emitStart;
+      }
+    }
+  });
+  doUnlink(toUnlink);
+}
+function doUnlink(line) {
+  if (!line) {
+    return;
   }
+  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 releaseScope(scope) {
+  var _a;
+  let outLink = scope.outLink;
+  while (outLink) {
+    const memoNext = outLink.nextOutLink;
+    unlinkSingleLine(outLink);
+    outLink = memoNext;
+  }
+  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);
+}
+function runWithPulling(fn, signal) {
+  const prevPulling = G.PullingSignal;
+  G.PullingSignal = signal;
+  fn();
+  G.PullingSignal = prevPulling;
 }
 
-const markDeep = signal => {
+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) {
@@ -938,37 +585,33 @@ const markDeep = signal => {
   }
   dirtyLeafs.clear();
 };
-class Signal {
-  constructor(nextValue,
-  /** 为什么是 shallow，因为 pullDeep 会把
-   * 上游节点 get 执行完成，让其可以直接拿到缓存值
-   */
-  customPull) {
+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 = Signal.Pulling;
+    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, {
-    customPull,
-    isScope,
-    ...rest
-  }) {
-    const s = new Signal(nextValue, customPull);
+  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.scope = s;
+      s.state |= State.IsScope;
     }
     return s;
   }
@@ -979,131 +622,104 @@ class Signal {
    * 递归拉取负责建立以来链
    */
   pullRecurse(shouldLink = true) {
-    var _a;
-    let downstream = Signal.Pulling;
-    if (shouldLink && downstream) {
-      // 如果上游节点被 scope 管理了，解除管理
-      unTrackIsland(this);
+    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);
     }
     try {
       if (this.version === G.version) {
         return this.value;
       }
-      this.state &= ~State.OutLink;
-      // 进 pullShallow 前重置 recEnd，让子 getter 重构订阅链表
-      this.recEnd = undefined;
-      Signal.Pulling = this;
-      const v = this.pull();
-      // 如果使用了 DEFAULT_PULL，处理一次 set 的取值后，替换回 customPull，如果有的话
+      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;
-      // if (this.value !== v) {
-      // }
       return this.value;
     } catch (error) {
-      console.error('计算属性报错这次不触发，后续状态可能出错', 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 {
-      // 本 getter 执行完成时上游 getter 通过 link，完成对下游 recLines 的更新
-      const toDel = (_a = this.recEnd) === null || _a === void 0 ? void 0 : _a.nextRecLine;
+      const toDel = (_b = this.recEnd) == null ? void 0 : _b.nextRecLine;
       unlinkRecWithScope(toDel);
-      if (shouldLink && downstream) {
-        // 用于 scope 指示哪些节点依赖 scope 外部
-        markOutLink(this, downstream);
-      }
-      Signal.Pulling = downstream;
+      G.PullingSignal = downstream;
     }
   }
   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()) {
+      begin: ({ node }) => {
+        if (node.state & State.Check || !(node.state & DirtyState) || node.isDisabled()) {
           return true;
         }
         node.state |= State.Check;
-        // 交给下游重新计算是否 引用外部节点
-        node.state &= ~State.OutLink;
       },
-      complete: ({
-        node,
-        notGoDeep: currentClean,
-        walkedLine
-      }) => {
+      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) {
-          // 优化：源节点变化，直接让下游节点重新计算
+        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 = Signal.Pulling;
-            Signal.Pulling = downstream;
+          } else {
+            const prevPulling = G.PullingSignal;
+            G.PullingSignal = downstream;
             const prevValue = node.value;
-            // 递归转用递归拉取，且不需要重建 link 因为dfs的前提就是上游节点依赖于 本节点
             node.pullRecurse(false);
-            // dirty 传播， 由于本节点值已被计算出，因此消除 dirty
             if (prevValue !== node.value) {
               node.markDownStreamsDirty();
             }
             node.state &= ~State.Dirty;
-            Signal.Pulling = prevPulling;
-            // 立刻返回父节点重新计算
+            G.PullingSignal = prevPulling;
             noGoSibling = true;
           }
-        }
-        // 没被上游节点标记为 Dirty，说明是干净的
-        else if (node.state & State.Unknown) {
+        } 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;
   }
-  get() {
-    if (this.isAbort()) {
+  get v() {
+    if (this.isDisabled()) {
       return this.value;
     }
-    // 没有上游节点，应该通过递归重新建立
     if (!this.recStart) {
       return this.pullRecurse(true);
     }
-    // 有上游节点则采用 dfs 直接遍历，查看情况
     return this.pullDeep();
   }
+  // pause() {
+  //   this.state |= State.SelfPaused;
+  // }
+  // resume() {
+  //   this.state &= ~State.SelfPaused;
+  // }
   markDownStreamsDirty() {
     let point = this.emitStart;
     while (point != null) {
@@ -1113,166 +729,128 @@ class Signal {
       point = point.nextEmitLine;
     }
   }
-  set(v) {
-    if (this.isAbort() || this.nextValue === v) {
+  set v(v) {
+    if (this.isDisabled() || this.nextValue === v) {
       return;
     }
     this.nextValue = v;
-    // 手动设值后，采用默认拉取，能拉取到设置的值，拉取完成后在替换回 customPull
     this.pull = this.DEFAULT_PULL;
     G.version++;
     markDeep(this);
   }
-  run(...args) {
-    if (args.length) {
-      return this.set(args[0]);
-    }
-    return this.get();
-  }
   runIfDirty() {
-    this.state & (State.Unknown | State.Dirty) && this.run();
+    this.state & (State.Unknown | State.Dirty) && this.v;
   }
-  isAbort() {
+  isDisabled() {
     return (
       // scope 被取消
-      this.scope && this.scope.state & State.ScopeAbort ||
-      // 是 scope 节点，且处于 ready 状态，不需要重复执行
-      this === this.scope && this.state & ScopeExecuted
+      this.scope && this.scope.state & State.ScopeAbort || // 是 scope 节点，且处于 ready 状态，不需要重复执行
+      this.state & State.IsScope && this.state & ScopeExecuted
     );
   }
-}
-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));
+  });
 };
-// const globalSignal = $(10);
-// let outerA, outerB, innerX, innerY, outerResult, innerResult, innerDispose;
-// const outerDispose = scope(() => {
-//   outerA = $(1);
-//   outerB = $(2);
-//   // 外层计算信号
-//   outerResult = $(() => {
-//     const res = globalSignal.v + outerA.v + outerB.v;
-//     return res;
-//   });
-//   innerDispose = scope(() => {
-//     innerX = $(3);
-//     innerY = $(4);
-//     // 内层计算信号，既依赖内层也依赖外层信号
-//     innerResult = $(() => {
-//       const res = outerA.v + innerX.v + innerY.v;
-//       return res;
-//     });
-//     // 访问信号以建立依赖关系
-//     innerResult();
-//   });
-//   // 访问外层信号
-//   outerResult();
-//   // 将内层dispose函数绑定到外层scope，这样可以测试嵌套行为
-//   (outerResult as any).innerDispose = innerDispose;
-// });
-// outerA.v = 5;
-// innerX.v = 6;
-// globalSignal.v = 20;
-// // 先释放内层scope
-// innerDispose();
-// innerX.v = 7;
-// outerA.v = 8;
-// outerDispose();
-// evt.on('one', ({ index }) => {
-//   switch (index) {
-//     case 0:
-//       console.log({ index });
-//       break;
-//     case 1:
-//       console.log({ index });
-//     default:
-//       break;
-//   }
-// });
 
 exports.$ = $;
+exports.Scheduler = Scheduler;
 exports.TaskQueue = TaskQueue;
-exports.customSignal = customSignal;
+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