aoye 0.0.1

package/dist/aoye.cjs.js

@@ -0,0 +1,1120 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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;
+    }
+  };
+}
+function Queue_$$$_push(it) {
+  this.len++;
+  const {
+    _last: last
+  } = this;
+  const item = {
+    v: it
+  };
+  if (!last) {
+    this._first = this._last = item;
+    return;
+  }
+  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;
+  }
+  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;
+  }
+  list.push(value);
+}
+
+const G = {
+  /** 原子 signal 更新次数 */
+  version: 0,
+  id: 0,
+  /** scope 销毁任务序号 */
+  scopeDisposeI: 0
+};
+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 = {}));
+const _scheduler = {
+  [exports.Scheduler.Sync]: defaultScheduler,
+  [exports.Scheduler.Micro]: microScheduler,
+  [exports.Scheduler.Macro]: macroScheduler,
+  [exports.Scheduler.Layout]: schedulerLayout
+};
+const scheduler = (key, value) => _scheduler[key] = value;
+function defaultScheduler(effects) {
+  for (const effect of effects) {
+    effect.runIfDirty();
+  }
+}
+const p = Promise.resolve();
+let hasMicroTask = false;
+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()();
+    }
+  };
+}
+function macroScheduler(effects) {
+  if (channel) {
+    macroQueue.push(() => defaultScheduler(effects));
+    channel.port1.postMessage('');
+  }
+  setTimeout(() => {
+    defaultScheduler(effects);
+  });
+}
+function schedulerLayout(effects) {
+  requestAnimationFrame(() => {
+    defaultScheduler(effects);
+  });
+}
+
+const DefaultDFSOpt = {
+  isUp: false,
+  begin: undefined,
+  complete: undefined,
+  breakStack: [],
+  breakLine: undefined,
+  breakNode: undefined
+};
+function dfs(root, opt = {}) {
+  const {
+    isUp,
+    begin,
+    complete,
+    breakStack: lineStack,
+    breakLine
+  } = {
+    ...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';
+  while (1) {
+    let notGoDeep = begin === null || begin === void 0 ? void 0 : begin({
+      node: node,
+      lineFromUp: line,
+      walkedLine: lineStack
+    });
+    lineStack.push(line);
+    line = node[listKey];
+    if (line && !notGoDeep) {
+      const firstChild = line[nodeKey];
+      node = firstChild;
+      continue;
+    }
+    while (1) {
+      const noGoSibling = complete === null || complete === void 0 ? void 0 : complete({
+        node: 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);
+  }
+  // 消除 head
+  for (const key in head) {
+    head[key] = undefined;
+  }
+}
+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;
+  }
+  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;
+  }
+}
+Line.unlink = Line_$$$_unlink;
+function Line_$$$_unlinkRec(line) {
+  // 作为下游，执行完 get 上游节点已经完成了依赖更新，把 recEnd 后的依赖删除即可
+  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);
+    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;
+  }
+  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;
+        }
+      }
+    },
+    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;
+      }
+    },
+    _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;
+}
+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));
+    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;
+  }
+}
+function unlinkRecWithScope(line) {
+  // 作为下游，执行完 get 上游节点已经完成了依赖更新，把 recEnd 后的依赖删除即可
+  let toDel = line;
+  while (toDel) {
+    const memoNext = toDel.nextRecLine;
+    const upstream = toDel.upstream;
+    Line.unlink(toDel);
+    // 删除完后看看是否要被 scope 管理
+    trackIsland(upstream);
+    toDel = memoNext;
+  }
+}
+
+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;
+  }
+  return s;
+}
+Signal.create = Signal_$$$_create;
+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()) {
+        return true;
+      }
+      const isEffect = level > 0;
+      const isLeaf = !node.emitStart || node.emitStart.downstream['scope'] === node.emitStart.downstream;
+      if (isEffect) {
+        node.state |= State.Unknown;
+      } else {
+        node.state |= State.Dirty;
+      }
+      if (isLeaf && isEffect) {
+        dirtyLeafs.add(node.scheduler, node);
+      }
+      level++;
+    }
+  });
+  for (const key in dirtyLeafs.data) {
+    const effects = dirtyLeafs.data[key];
+    const scheduler = _scheduler[key];
+    scheduler(effects);
+  }
+  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);
+  }
+  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.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);
+    }
+    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;
+        }
+        // 预检数据
+        else {
+          const prevPulling = Signal.Pulling;
+          Signal.Pulling = 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;
+          // 立刻返回父节点重新计算
+          noGoSibling = true;
+        }
+      }
+      // 没被上游节点标记为 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);
+  }
+  // 有上游节点则采用 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;
+  }
+}
+function Signal_$$$_set(v) {
+  if (this.isAbort() || this.nextValue === v) {
+    return;
+  }
+  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]);
+  }
+  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;
+}
+
+const DefaultCustomSignalOpt = {
+  scheduler: exports.Scheduler.Sync,
+  isScope: false
+};
+const $ = (init, opt = {}) => {
+  let intiValue, pull;
+  if (init instanceof Function) {
+    intiValue = undefined;
+    pull = 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);
+    }
+  });
+  return bound;
+};
+const watch = (values, watcher, opt) => {
+  let mounted = false;
+  const get = $(() => {
+    for (const get of values) {
+      get();
+    }
+    if (mounted) {
+      runWithPulling(watcher, undefined);
+    }
+    mounted = true;
+  }, opt);
+  get();
+  return get;
+};
+const scope = fn => {
+  const s = Signal.create(undefined, {
+    customPull: fn,
+    isScope: true
+  });
+  s.get();
+  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;
+};
+/**
+ * 数据变化时，自定义 触发订阅函数的时机
+ * @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;
+  };
+};
+
+exports.$ = $;
+exports.customSignal = customSignal;
+exports.scheduler = scheduler;
+exports.scope = scope;
+exports.watch = watch;