aoye 0.0.2 → 0.0.6

package/dist/index.umd.js

@@ -0,0 +1,860 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('bobe-shared')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'bobe-shared'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Aoye = {}, global.BobeShared));
+})(this, (function (exports, bobeShared) { 'use strict';
+
+  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;
+      }
+      this.goUp(this.arr, current, len);
+    }
+    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");
+    }
+  }
+
+  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));
+    }
+  }
+
+  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);
+  };
+
+  var Scheduler = /* @__PURE__ */ ((Scheduler2) => {
+    Scheduler2["Sync"] = "__Sync_";
+    Scheduler2["Layout"] = "__Layout_";
+    Scheduler2["Micro"] = "__Micro_";
+    Scheduler2["Macro"] = "__Macro_";
+    return Scheduler2;
+  })(Scheduler || {});
+  const _scheduler = {
+    ["__Sync_" /* Sync */]: defaultScheduler,
+    ["__Micro_" /* Micro */]: microScheduler,
+    ["__Macro_" /* Macro */]: macroScheduler,
+    ["__Layout_" /* Layout */]: layoutScheduler
+  };
+  const scheduler = (key, value) => _scheduler[key] = value;
+  function defaultScheduler(effects) {
+    for (const effect of effects) {
+      effect.runIfDirty();
+    }
+  }
+  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(null, effects));
+  }
+  function macroScheduler(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(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: null,
+    complete: null,
+    breakStack: [],
+    breakLine: null,
+    breakNode: null
+  };
+  function dfs(root, 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";
+    while (1) {
+      let notGoDeep = begin == null ? void 0 : begin({
+        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 ? void 0 : complete({
+          node,
+          lineToDeep: line,
+          walkedLine: lineStack,
+          notGoDeep
+        });
+        line = lineStack.pop();
+        if (node === root) {
+          return;
+        }
+        notGoDeep = false;
+        const nextLine = line[nextLineKey];
+        if (!noGoSibling && nextLine) {
+          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;
+      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;
+        }
+      }
+    }
+    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;
+      }
+    }
+    static unlinkRec(line) {
+      let toDel = line;
+      while (toDel) {
+        const memoNext = toDel.nextRecLine;
+        Line.unlink(toDel);
+        toDel = memoNext;
+      }
+    }
+    static unlinkEmit(line) {
+      let toDel = line;
+      while (toDel) {
+        const memoNext = toDel.nextEmitLine;
+        Line.unlink(toDel);
+        toDel = memoNext;
+      }
+    }
+    /** 上游节点 连 link */
+    static emit_line(upstream, line) {
+      if (!upstream.emitStart) {
+        upstream.emitStart = line;
+      }
+      upstream.emitEnd = line;
+      line.upstream = upstream;
+    }
+    /** 下游节点 连 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;
+    }
+  }
+
+  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 unlinkSingleLine(line) {
+    const upstream = line.upstream;
+    if (upstream.emitStart === upstream.emitEnd) {
+      unlinkSingleRefedNode(upstream);
+    } else {
+      Line.unlink(line);
+    }
+  }
+  function unlinkSingleRefedNode(delRoot) {
+    let toUnlink;
+    dfs(delRoot, {
+      isUp: true,
+      begin: ({ node }) => {
+        doUnlink(toUnlink);
+        toUnlink = null;
+        if (node.emitStart !== node.emitEnd) {
+          return true;
+        }
+      },
+      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 dispose() {
+    let toDel = this.recStart;
+    while (toDel) {
+      const memoNext = toDel.nextRecLine;
+      const upstream = toDel.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;
+  }
+
+  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 }) => {
+        if (node.state & (State.Check | State.Unknown | State.Dirty) || node.isDisabled()) {
+          return true;
+        }
+        const isEffect = level > 0;
+        const isLeaf = !node.emitStart || node.emitStart.downstream === node.scope;
+        if (isEffect) {
+          node.state |= State.Unknown;
+        } else if (!isLeaf) {
+          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();
+  };
+  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;
+    }
+    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);
+      }
+      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;
+      }
+    }
+    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;
+          }
+          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;
+            }
+          } else if (node.state & State.Unknown) {
+            node.state &= ~State.Unknown;
+          }
+          node.version = G.version;
+          node.state &= ~State.Check;
+          return noGoSibling;
+        }
+      });
+      return this.value;
+    }
+    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;
+      }
+    }
+    set v(v) {
+      if (this.isDisabled() || this.nextValue === v) {
+        return;
+      }
+      this.nextValue = v;
+      this.pull = this.DEFAULT_PULL;
+      G.version++;
+      markDeep(this);
+    }
+    runIfDirty() {
+      this.state & (State.Unknown | State.Dirty) && this.v;
+    }
+    isDisabled() {
+      return (
+        // scope 被取消
+        this.scope && this.scope.state & State.ScopeAbort || // 是 scope 节点，且处于 ready 状态，不需要重复执行
+        this.state & State.IsScope && this.state & ScopeExecuted
+      );
+    }
+  };
+  _Signal.Pulling = null;
+  let Signal = _Signal;
+
+  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;
+  };
+  ({
+    scheduler: Scheduler.Sync});
+  const $ = (init) => {
+    let intiValue, customPull;
+    if (init instanceof Function) {
+      intiValue = null;
+      customPull = init;
+    } else {
+      intiValue = init;
+    }
+    const s = Signal.create(intiValue, {
+      scheduler: Scheduler.Sync,
+      isScope: false,
+      customPull
+    });
+    return s;
+  };
+  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 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 = (customPull) => {
+    const s = Signal.create(null, {
+      customPull,
+      scheduler: Scheduler.Sync,
+      isScope: true
+    });
+    s.v;
+    s.state |= State.ScopeReady;
+    const bound = dispose.bind(s);
+    bound.ins = s;
+    return bound;
+  };
+  const customEffect = (opt) => {
+    return ((init, innerOpt = {}) => {
+      return effect(init, __spreadValues(__spreadValues({}, opt), innerOpt));
+    });
+  };
+
+  exports.$ = $;
+  exports.Scheduler = Scheduler;
+  exports.TaskQueue = TaskQueue;
+  exports.clean = clean;
+  exports.customEffect = customEffect;
+  exports.effect = effect;
+  exports.runWithPulling = runWithPulling;
+  exports.scheduler = scheduler;
+  exports.scope = scope;
+
+}));
+//# sourceMappingURL=index.umd.js.map