Initial commit

node_modules/alien-signals/cjs/computed.d.ts

@@ -0,0 +1,19 @@
+import { DirtyLevels, IComputed, Link } from './system.js';
+export interface ISignal<T = any> {
+    get(): T;
+}
+export declare function computed<T>(getter: (cachedValue?: T) => T): ISignal<T>;
+export declare class Computed<T = any> implements IComputed {
+    getter: (cachedValue?: T) => T;
+    cachedValue: T | undefined;
+    subs: Link | undefined;
+    subsTail: Link | undefined;
+    deps: Link | undefined;
+    depsTail: Link | undefined;
+    trackId: number;
+    dirtyLevel: DirtyLevels;
+    canPropagate: boolean;
+    constructor(getter: (cachedValue?: T) => T);
+    get(): T;
+    update(): boolean;
+}

node_modules/alien-signals/cjs/effect.d.ts

@@ -0,0 +1,17 @@
+import { Dependency, DirtyLevels, IEffect, Link } from './system.js';
+export declare function effect(fn: () => void): Effect<void>;
+export declare class Effect<T = any> implements IEffect, Dependency {
+    fn: () => T;
+    nextNotify: IEffect | undefined;
+    subs: Link | undefined;
+    subsTail: Link | undefined;
+    deps: Link | undefined;
+    depsTail: Link | undefined;
+    trackId: number;
+    dirtyLevel: DirtyLevels;
+    canPropagate: boolean;
+    constructor(fn: () => T);
+    notify(): void;
+    run(): T;
+    stop(): void;
+}

node_modules/alien-signals/cjs/effectScope.d.ts

@@ -0,0 +1,13 @@
+import { DirtyLevels, Link, Subscriber } from './system.js';
+export declare let activeEffectScope: EffectScope | undefined;
+export declare function effectScope(): EffectScope;
+export declare class EffectScope implements Subscriber {
+    deps: Link | undefined;
+    depsTail: Link | undefined;
+    trackId: number;
+    dirtyLevel: DirtyLevels;
+    canPropagate: boolean;
+    notify(): void;
+    run<T>(fn: () => T): T;
+    stop(): void;
+}

node_modules/alien-signals/cjs/index.cjs

@@ -0,0 +1,895 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Computed: () => Computed,
+  Effect: () => Effect,
+  EffectScope: () => EffectScope,
+  Signal: () => Signal,
+  SubscriberFlags: () => SubscriberFlags,
+  activeEffectScope: () => activeEffectScope,
+  activeScopeTrackId: () => activeScopeTrackId,
+  activeSub: () => activeSub,
+  activeTrackId: () => activeTrackId,
+  checkDirty: () => checkDirty,
+  computed: () => computed,
+  effect: () => effect,
+  effectScope: () => effectScope,
+  endBatch: () => endBatch,
+  endTrack: () => endTrack,
+  lastTrackId: () => lastTrackId,
+  link: () => link,
+  nextTrackId: () => nextTrackId,
+  propagate: () => propagate,
+  setActiveScope: () => setActiveScope,
+  setActiveSub: () => setActiveSub,
+  shallowPropagate: () => shallowPropagate,
+  signal: () => signal,
+  startBatch: () => startBatch,
+  startTrack: () => startTrack,
+  unstable: () => unstable,
+  untrack: () => untrack,
+  untrackScope: () => untrackScope
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/system.ts
+var SubscriberFlags = /* @__PURE__ */ ((SubscriberFlags2) => {
+  SubscriberFlags2[SubscriberFlags2["None"] = 0] = "None";
+  SubscriberFlags2[SubscriberFlags2["Tracking"] = 1] = "Tracking";
+  SubscriberFlags2[SubscriberFlags2["Recursed"] = 2] = "Recursed";
+  SubscriberFlags2[SubscriberFlags2["InnerEffectsPending"] = 4] = "InnerEffectsPending";
+  SubscriberFlags2[SubscriberFlags2["ToCheckDirty"] = 8] = "ToCheckDirty";
+  SubscriberFlags2[SubscriberFlags2["Dirty"] = 16] = "Dirty";
+  return SubscriberFlags2;
+})(SubscriberFlags || {});
+var batchDepth = 0;
+var queuedEffects;
+var queuedEffectsTail;
+var linkPool;
+function startBatch() {
+  ++batchDepth;
+}
+function endBatch() {
+  if (!--batchDepth) {
+    drainQueuedEffects();
+  }
+}
+function drainQueuedEffects() {
+  while (queuedEffects !== void 0) {
+    const effect2 = queuedEffects;
+    const queuedNext = effect2.nextNotify;
+    if (queuedNext !== void 0) {
+      effect2.nextNotify = void 0;
+      queuedEffects = queuedNext;
+    } else {
+      queuedEffects = void 0;
+      queuedEffectsTail = void 0;
+    }
+    effect2.notify();
+  }
+}
+function link(dep, sub) {
+  const currentDep = sub.depsTail;
+  const nextDep = currentDep !== void 0 ? currentDep.nextDep : sub.deps;
+  if (nextDep !== void 0 && nextDep.dep === dep) {
+    sub.depsTail = nextDep;
+  } else {
+    linkNewDep(dep, sub, nextDep, currentDep);
+  }
+}
+function linkNewDep(dep, sub, nextDep, depsTail) {
+  let newLink;
+  if (linkPool !== void 0) {
+    newLink = linkPool;
+    linkPool = newLink.nextDep;
+    newLink.nextDep = nextDep;
+    newLink.dep = dep;
+    newLink.sub = sub;
+  } else {
+    newLink = {
+      dep,
+      sub,
+      nextDep,
+      prevSub: void 0,
+      nextSub: void 0
+    };
+  }
+  if (depsTail === void 0) {
+    sub.deps = newLink;
+  } else {
+    depsTail.nextDep = newLink;
+  }
+  if (dep.subs === void 0) {
+    dep.subs = newLink;
+  } else {
+    const oldTail = dep.subsTail;
+    newLink.prevSub = oldTail;
+    oldTail.nextSub = newLink;
+  }
+  sub.depsTail = newLink;
+  dep.subsTail = newLink;
+}
+function propagate(link2) {
+  let targetFlag = 16 /* Dirty */;
+  let subs = link2;
+  let stack = 0;
+  top: do {
+    const sub = link2.sub;
+    const subFlags = sub.flags;
+    if (!(subFlags & (1 /* Tracking */ | 2 /* Recursed */ | 4 /* InnerEffectsPending */ | 8 /* ToCheckDirty */ | 16 /* Dirty */)) && (sub.flags = subFlags | targetFlag, true) || (subFlags & (1 /* Tracking */ | 2 /* Recursed */)) === 2 /* Recursed */ && (sub.flags = subFlags & ~2 /* Recursed */ | targetFlag, true) || !(subFlags & (4 /* InnerEffectsPending */ | 8 /* ToCheckDirty */ | 16 /* Dirty */)) && isValidLink(link2, sub) && (sub.flags = subFlags | 2 /* Recursed */ | targetFlag, sub.subs !== void 0)) {
+      const subSubs = sub.subs;
+      if (subSubs !== void 0) {
+        if (subSubs.nextSub !== void 0) {
+          subSubs.prevSub = subs;
+          link2 = subs = subSubs;
+          targetFlag = 8 /* ToCheckDirty */;
+          ++stack;
+        } else {
+          link2 = subSubs;
+          targetFlag = "notify" in sub ? 4 /* InnerEffectsPending */ : 8 /* ToCheckDirty */;
+        }
+        continue;
+      }
+      if ("notify" in sub) {
+        if (queuedEffectsTail !== void 0) {
+          queuedEffectsTail.nextNotify = sub;
+        } else {
+          queuedEffects = sub;
+        }
+        queuedEffectsTail = sub;
+      }
+    } else if (!(subFlags & (1 /* Tracking */ | targetFlag)) || !(subFlags & targetFlag) && subFlags & (4 /* InnerEffectsPending */ | 8 /* ToCheckDirty */ | 16 /* Dirty */) && isValidLink(link2, sub)) {
+      sub.flags = subFlags | targetFlag;
+    }
+    if ((link2 = subs.nextSub) !== void 0) {
+      subs = link2;
+      targetFlag = stack ? 8 /* ToCheckDirty */ : 16 /* Dirty */;
+      continue;
+    }
+    while (stack) {
+      --stack;
+      const dep = subs.dep;
+      const depSubs = dep.subs;
+      subs = depSubs.prevSub;
+      depSubs.prevSub = void 0;
+      if ((link2 = subs.nextSub) !== void 0) {
+        subs = link2;
+        targetFlag = stack ? 8 /* ToCheckDirty */ : 16 /* Dirty */;
+        continue top;
+      }
+    }
+    break;
+  } while (true);
+  if (!batchDepth) {
+    drainQueuedEffects();
+  }
+}
+function shallowPropagate(link2) {
+  do {
+    const updateSub = link2.sub;
+    const updateSubFlags = updateSub.flags;
+    if ((updateSubFlags & (8 /* ToCheckDirty */ | 16 /* Dirty */)) === 8 /* ToCheckDirty */) {
+      updateSub.flags = updateSubFlags | 16 /* Dirty */;
+    }
+    link2 = link2.nextSub;
+  } while (link2 !== void 0);
+}
+function isValidLink(subLink, sub) {
+  const depsTail = sub.depsTail;
+  if (depsTail !== void 0) {
+    let link2 = sub.deps;
+    do {
+      if (link2 === subLink) {
+        return true;
+      }
+      if (link2 === depsTail) {
+        break;
+      }
+      link2 = link2.nextDep;
+    } while (link2 !== void 0);
+  }
+  return false;
+}
+function checkDirty(link2) {
+  let stack = 0;
+  let dirty;
+  top: do {
+    dirty = false;
+    const dep = link2.dep;
+    if ("update" in dep) {
+      const depFlags = dep.flags;
+      if (depFlags & 16 /* Dirty */) {
+        if (dep.update()) {
+          const subs = dep.subs;
+          if (subs.nextSub !== void 0) {
+            shallowPropagate(subs);
+          }
+          dirty = true;
+        }
+      } else if (depFlags & 8 /* ToCheckDirty */) {
+        const depSubs = dep.subs;
+        if (depSubs.nextSub !== void 0) {
+          depSubs.prevSub = link2;
+        }
+        link2 = dep.deps;
+        ++stack;
+        continue;
+      }
+    }
+    if (!dirty && link2.nextDep !== void 0) {
+      link2 = link2.nextDep;
+      continue;
+    }
+    if (stack) {
+      let sub = link2.sub;
+      do {
+        --stack;
+        const subSubs = sub.subs;
+        if (dirty) {
+          if (sub.update()) {
+            if ((link2 = subSubs.prevSub) !== void 0) {
+              subSubs.prevSub = void 0;
+              shallowPropagate(sub.subs);
+              sub = link2.sub;
+            } else {
+              sub = subSubs.sub;
+            }
+            continue;
+          }
+        } else {
+          sub.flags &= ~8 /* ToCheckDirty */;
+        }
+        if ((link2 = subSubs.prevSub) !== void 0) {
+          subSubs.prevSub = void 0;
+          if (link2.nextDep !== void 0) {
+            link2 = link2.nextDep;
+            continue top;
+          }
+          sub = link2.sub;
+        } else {
+          if ((link2 = subSubs.nextDep) !== void 0) {
+            continue top;
+          }
+          sub = subSubs.sub;
+        }
+        dirty = false;
+      } while (stack);
+    }
+    return dirty;
+  } while (true);
+}
+function startTrack(sub) {
+  sub.depsTail = void 0;
+  sub.flags = 1 /* Tracking */;
+}
+function endTrack(sub) {
+  const depsTail = sub.depsTail;
+  if (depsTail !== void 0) {
+    const nextDep = depsTail.nextDep;
+    if (nextDep !== void 0) {
+      clearTrack(nextDep);
+      depsTail.nextDep = void 0;
+    }
+  } else if (sub.deps !== void 0) {
+    clearTrack(sub.deps);
+    sub.deps = void 0;
+  }
+  sub.flags &= ~1 /* Tracking */;
+}
+function clearTrack(link2) {
+  do {
+    const dep = link2.dep;
+    const nextDep = link2.nextDep;
+    const nextSub = link2.nextSub;
+    const prevSub = link2.prevSub;
+    if (nextSub !== void 0) {
+      nextSub.prevSub = prevSub;
+      link2.nextSub = void 0;
+    } else {
+      dep.subsTail = prevSub;
+      if ("lastTrackedId" in dep) {
+        dep.lastTrackedId = 0;
+      }
+    }
+    if (prevSub !== void 0) {
+      prevSub.nextSub = nextSub;
+      link2.prevSub = void 0;
+    } else {
+      dep.subs = nextSub;
+    }
+    link2.dep = void 0;
+    link2.sub = void 0;
+    link2.nextDep = linkPool;
+    linkPool = link2;
+    if (dep.subs === void 0 && "deps" in dep) {
+      if ("notify" in dep) {
+        dep.flags = 0 /* None */;
+      } else {
+        const depFlags = dep.flags;
+        if (!(depFlags & 16 /* Dirty */)) {
+          dep.flags = depFlags | 16 /* Dirty */;
+        }
+      }
+      const depDeps = dep.deps;
+      if (depDeps !== void 0) {
+        link2 = depDeps;
+        dep.depsTail.nextDep = nextDep;
+        dep.deps = void 0;
+        dep.depsTail = void 0;
+        continue;
+      }
+    }
+    link2 = nextDep;
+  } while (link2 !== void 0);
+}
+
+// src/effectScope.ts
+var activeEffectScope = void 0;
+var activeScopeTrackId = 0;
+function untrackScope(fn) {
+  const prevSub = activeEffectScope;
+  const prevTrackId = activeScopeTrackId;
+  setActiveScope(void 0, 0);
+  try {
+    return fn();
+  } finally {
+    setActiveScope(prevSub, prevTrackId);
+  }
+}
+function setActiveScope(sub, trackId) {
+  activeEffectScope = sub;
+  activeScopeTrackId = trackId;
+}
+function effectScope() {
+  return new EffectScope();
+}
+var EffectScope = class {
+  constructor() {
+    // Subscriber
+    this.deps = void 0;
+    this.depsTail = void 0;
+    this.flags = 0 /* None */;
+    this.trackId = nextTrackId();
+  }
+  notify() {
+    const flags = this.flags;
+    if (flags & 4 /* InnerEffectsPending */) {
+      this.flags = flags & ~4 /* InnerEffectsPending */;
+      let link2 = this.deps;
+      do {
+        const dep = link2.dep;
+        if ("notify" in dep) {
+          dep.notify();
+        }
+        link2 = link2.nextDep;
+      } while (link2 !== void 0);
+    }
+  }
+  run(fn) {
+    const prevSub = activeEffectScope;
+    const prevTrackId = activeScopeTrackId;
+    setActiveScope(this, this.trackId);
+    try {
+      return fn();
+    } finally {
+      setActiveScope(prevSub, prevTrackId);
+    }
+  }
+  stop() {
+    startTrack(this);
+    endTrack(this);
+  }
+};
+
+// src/effect.ts
+var activeSub;
+var activeTrackId = 0;
+var lastTrackId = 0;
+function untrack(fn) {
+  const prevSub = activeSub;
+  const prevTrackId = activeTrackId;
+  setActiveSub(void 0, 0);
+  try {
+    return fn();
+  } finally {
+    setActiveSub(prevSub, prevTrackId);
+  }
+}
+function setActiveSub(sub, trackId) {
+  activeSub = sub;
+  activeTrackId = trackId;
+}
+function nextTrackId() {
+  return ++lastTrackId;
+}
+function effect(fn) {
+  const e = new Effect(fn);
+  e.run();
+  return e;
+}
+var Effect = class {
+  constructor(fn) {
+    this.fn = fn;
+    this.nextNotify = void 0;
+    // Dependency
+    this.subs = void 0;
+    this.subsTail = void 0;
+    // Subscriber
+    this.deps = void 0;
+    this.depsTail = void 0;
+    this.flags = 16 /* Dirty */;
+    if (activeTrackId) {
+      link(this, activeSub);
+    } else if (activeScopeTrackId) {
+      link(this, activeEffectScope);
+    }
+  }
+  notify() {
+    let flags = this.flags;
+    if (flags & 16 /* Dirty */) {
+      this.run();
+      return;
+    }
+    if (flags & 8 /* ToCheckDirty */) {
+      if (checkDirty(this.deps)) {
+        this.run();
+        return;
+      } else {
+        this.flags = flags &= ~8 /* ToCheckDirty */;
+      }
+    }
+    if (flags & 4 /* InnerEffectsPending */) {
+      this.flags = flags & ~4 /* InnerEffectsPending */;
+      let link2 = this.deps;
+      do {
+        const dep = link2.dep;
+        if ("notify" in dep) {
+          dep.notify();
+        }
+        link2 = link2.nextDep;
+      } while (link2 !== void 0);
+    }
+  }
+  run() {
+    const prevSub = activeSub;
+    const prevTrackId = activeTrackId;
+    setActiveSub(this, nextTrackId());
+    startTrack(this);
+    try {
+      return this.fn();
+    } finally {
+      setActiveSub(prevSub, prevTrackId);
+      endTrack(this);
+    }
+  }
+  stop() {
+    startTrack(this);
+    endTrack(this);
+  }
+};
+
+// src/computed.ts
+function computed(getter) {
+  return new Computed(getter);
+}
+var Computed = class {
+  constructor(getter) {
+    this.getter = getter;
+    this.currentValue = void 0;
+    // Dependency
+    this.subs = void 0;
+    this.subsTail = void 0;
+    this.lastTrackedId = 0;
+    // Subscriber
+    this.deps = void 0;
+    this.depsTail = void 0;
+    this.flags = 16 /* Dirty */;
+  }
+  get() {
+    const flags = this.flags;
+    if (flags & 16 /* Dirty */) {
+      if (this.update()) {
+        const subs = this.subs;
+        if (subs !== void 0) {
+          shallowPropagate(subs);
+        }
+      }
+    } else if (flags & 8 /* ToCheckDirty */) {
+      if (checkDirty(this.deps)) {
+        if (this.update()) {
+          const subs = this.subs;
+          if (subs !== void 0) {
+            shallowPropagate(subs);
+          }
+        }
+      } else {
+        this.flags = flags & ~8 /* ToCheckDirty */;
+      }
+    }
+    if (activeTrackId) {
+      if (this.lastTrackedId !== activeTrackId) {
+        this.lastTrackedId = activeTrackId;
+        link(this, activeSub);
+      }
+    } else if (activeScopeTrackId) {
+      if (this.lastTrackedId !== activeScopeTrackId) {
+        this.lastTrackedId = activeScopeTrackId;
+        link(this, activeEffectScope);
+      }
+    }
+    return this.currentValue;
+  }
+  update() {
+    const prevSub = activeSub;
+    const prevTrackId = activeTrackId;
+    setActiveSub(this, nextTrackId());
+    startTrack(this);
+    try {
+      const oldValue = this.currentValue;
+      const newValue = this.getter(oldValue);
+      if (oldValue !== newValue) {
+        this.currentValue = newValue;
+        return true;
+      }
+      return false;
+    } finally {
+      setActiveSub(prevSub, prevTrackId);
+      endTrack(this);
+    }
+  }
+};
+
+// src/signal.ts
+function signal(oldValue) {
+  return new Signal(oldValue);
+}
+var Signal = class {
+  constructor(currentValue) {
+    this.currentValue = currentValue;
+    // Dependency
+    this.subs = void 0;
+    this.subsTail = void 0;
+    this.lastTrackedId = 0;
+  }
+  get() {
+    if (activeTrackId && this.lastTrackedId !== activeTrackId) {
+      this.lastTrackedId = activeTrackId;
+      link(this, activeSub);
+    }
+    return this.currentValue;
+  }
+  set(value) {
+    if (this.currentValue !== value) {
+      this.currentValue = value;
+      const subs = this.subs;
+      if (subs !== void 0) {
+        propagate(subs);
+      }
+    }
+  }
+};
+
+// src/unstable/asyncSystem.ts
+async function asyncCheckDirty(link2) {
+  let stack = 0;
+  let dirty;
+  let nextDep;
+  top: do {
+    dirty = false;
+    const dep = link2.dep;
+    if ("update" in dep) {
+      const depFlags = dep.flags;
+      if (depFlags & 16 /* Dirty */) {
+        if (await dep.update()) {
+          const subs = dep.subs;
+          if (subs.nextSub !== void 0) {
+            shallowPropagate(subs);
+          }
+          dirty = true;
+        }
+      } else if (depFlags & 8 /* ToCheckDirty */) {
+        const depSubs = dep.subs;
+        if (depSubs.nextSub !== void 0) {
+          depSubs.prevSub = link2;
+        }
+        link2 = dep.deps;
+        ++stack;
+        continue;
+      }
+    }
+    if (dirty || (nextDep = link2.nextDep) === void 0) {
+      if (stack) {
+        let sub = link2.sub;
+        do {
+          --stack;
+          const subSubs = sub.subs;
+          let prevLink = subSubs.prevSub;
+          if (prevLink !== void 0) {
+            subSubs.prevSub = void 0;
+            if (dirty) {
+              if (await sub.update()) {
+                shallowPropagate(sub.subs);
+                sub = prevLink.sub;
+                continue;
+              }
+            } else {
+              sub.flags &= ~8 /* ToCheckDirty */;
+            }
+          } else {
+            if (dirty) {
+              if (await sub.update()) {
+                sub = subSubs.sub;
+                continue;
+              }
+            } else {
+              sub.flags &= ~8 /* ToCheckDirty */;
+            }
+            prevLink = subSubs;
+          }
+          link2 = prevLink.nextDep;
+          if (link2 !== void 0) {
+            continue top;
+          }
+          sub = prevLink.sub;
+          dirty = false;
+        } while (stack);
+      }
+      return dirty;
+    }
+    link2 = nextDep;
+  } while (true);
+}
+
+// src/unstable/asyncComputed.ts
+function asyncComputed(getter) {
+  return new AsyncComputed(getter);
+}
+var AsyncComputed = class extends Computed {
+  async get() {
+    const flags = this.flags;
+    if (flags & 16 /* Dirty */) {
+      if (await this.update()) {
+        const subs = this.subs;
+        if (subs !== void 0) {
+          shallowPropagate(subs);
+        }
+      }
+    } else if (flags & 8 /* ToCheckDirty */) {
+      if (await asyncCheckDirty(this.deps)) {
+        if (await this.update()) {
+          const subs = this.subs;
+          if (subs !== void 0) {
+            shallowPropagate(subs);
+          }
+        }
+      } else {
+        this.flags = flags & ~8 /* ToCheckDirty */;
+      }
+    }
+    return this.currentValue;
+  }
+  // @ts-expect-error
+  async update() {
+    try {
+      startTrack(this);
+      const trackId = nextTrackId();
+      const oldValue = this.currentValue;
+      const generator = this.getter(oldValue);
+      let current = await generator.next();
+      while (!current.done) {
+        const dep = current.value;
+        if (dep.lastTrackedId !== trackId) {
+          dep.lastTrackedId = trackId;
+          link(dep, this);
+        }
+        current = await generator.next();
+      }
+      const newValue = await current.value;
+      if (oldValue !== newValue) {
+        this.currentValue = newValue;
+        return true;
+      }
+      return false;
+    } finally {
+      endTrack(this);
+    }
+  }
+};
+
+// src/unstable/asyncEffect.ts
+function asyncEffect(fn) {
+  const e = new AsyncEffect(fn);
+  e.run();
+  return e;
+}
+var AsyncEffect = class extends Effect {
+  async notify() {
+    let flags = this.flags;
+    if (flags & 16 /* Dirty */) {
+      this.run();
+      return;
+    }
+    if (flags & 8 /* ToCheckDirty */) {
+      if (await asyncCheckDirty(this.deps)) {
+        this.run();
+        return;
+      } else {
+        this.flags = flags &= ~8 /* ToCheckDirty */;
+      }
+    }
+    if (flags & 4 /* InnerEffectsPending */) {
+      this.flags = flags & ~4 /* InnerEffectsPending */;
+      let link2 = this.deps;
+      do {
+        const dep = link2.dep;
+        if ("notify" in dep) {
+          dep.notify();
+        }
+        link2 = link2.nextDep;
+      } while (link2 !== void 0);
+    }
+  }
+  async run() {
+    try {
+      startTrack(this);
+      const trackId = nextTrackId();
+      const generator = this.fn();
+      let current = await generator.next();
+      while (!current.done) {
+        const dep = current.value;
+        if (dep.lastTrackedId !== trackId) {
+          dep.lastTrackedId = trackId;
+          link(dep, this);
+        }
+        current = await generator.next();
+      }
+      return await current.value;
+    } finally {
+      endTrack(this);
+    }
+  }
+};
+
+// src/unstable/computedArray.ts
+function computedArray(arr, getGetter) {
+  const length = computed(() => arr.get().length);
+  const keys = computed(
+    () => {
+      const keys2 = [];
+      for (let i = 0; i < length.get(); i++) {
+        keys2.push(String(i));
+      }
+      return keys2;
+    }
+  );
+  const items = computed(
+    (array) => {
+      array ??= [];
+      while (array.length < length.get()) {
+        const index = array.length;
+        const item = computed(() => arr.get()[index]);
+        array.push(computed(getGetter(item, index)));
+      }
+      if (array.length > length.get()) {
+        array.length = length.get();
+      }
+      return array;
+    }
+  );
+  return new Proxy({}, {
+    get(_, p, receiver) {
+      if (p === "length") {
+        return length.get();
+      }
+      if (typeof p === "string" && !isNaN(Number(p))) {
+        return items.get()[Number(p)]?.get();
+      }
+      return Reflect.get(items.get(), p, receiver);
+    },
+    has(_, p) {
+      return Reflect.has(items.get(), p);
+    },
+    ownKeys() {
+      return keys.get();
+    }
+  });
+}
+
+// src/unstable/computedSet.ts
+function computedSet(source) {
+  return computed(
+    (oldValue) => {
+      const newValue = source.get();
+      if (oldValue?.size === newValue.size && [...oldValue].every((c) => newValue.has(c))) {
+        return oldValue;
+      }
+      return newValue;
+    }
+  );
+}
+
+// src/unstable/equalityComputed.ts
+function equalityComputed(getter) {
+  return new EqualityComputed(getter);
+}
+var EqualityComputed = class extends Computed {
+  constructor(getter) {
+    super((oldValue) => {
+      const newValue = getter();
+      if (this.equals(oldValue, newValue)) {
+        return oldValue;
+      }
+      return newValue;
+    });
+  }
+  equals(a, b) {
+    if (a === b) {
+      return true;
+    }
+    if (a === null || b === null || typeof a !== typeof b) {
+      return false;
+    }
+    if (typeof a === "object") {
+      if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length) {
+          return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+          if (!this.equals(a[i], b[i])) {
+            return false;
+          }
+        }
+        return true;
+      }
+      if (!Array.isArray(a) && !Array.isArray(b)) {
+        for (const key in a) {
+          if (a.hasOwnProperty(key)) {
+            if (!b.hasOwnProperty(key) || !this.equals(a[key], b[key])) {
+              return false;
+            }
+          }
+        }
+        for (const key in b) {
+          if (b.hasOwnProperty(key) && !a.hasOwnProperty(key)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      return false;
+    }
+    return false;
+  }
+};
+
+// src/unstable/index.ts
+var unstable = {
+  AsyncComputed,
+  asyncComputed,
+  AsyncEffect,
+  asyncEffect,
+  asyncCheckDirty,
+  computedArray,
+  computedSet,
+  EqualityComputed,
+  equalityComputed
+};

node_modules/alien-signals/cjs/index.d.ts

@@ -0,0 +1,6 @@
+export * from './computed.js';
+export * from './effect.js';
+export * from './effectScope.js';
+export * from './signal.js';
+export * from './system.js';
+export * as Unstable from './unstable/index.js';

node_modules/alien-signals/cjs/signal.d.ts

@@ -0,0 +1,15 @@
+import { ISignal } from './computed.js';
+import { Dependency, Link } from './system.js';
+export interface IWritableSignal<T = any> extends ISignal<T> {
+    set(value: T): void;
+}
+export declare function signal<T>(): Signal<T | undefined>;
+export declare function signal<T>(oldValue: T): Signal<T>;
+export declare class Signal<T = any> implements Dependency {
+    currentValue: T;
+    subs: Link | undefined;
+    subsTail: Link | undefined;
+    constructor(currentValue: T);
+    get(): NonNullable<T>;
+    set(value: T): void;
+}

node_modules/alien-signals/cjs/system.d.ts

@@ -0,0 +1,56 @@
+export interface IEffect extends Subscriber {
+    nextNotify: IEffect | undefined;
+    notify(): void;
+}
+export interface IComputed extends Dependency, Subscriber {
+    update(): boolean;
+}
+export interface Dependency {
+    subs: Link | undefined;
+    subsTail: Link | undefined;
+}
+export interface Subscriber {
+    trackId: number;
+    canPropagate: boolean;
+    dirtyLevel: DirtyLevels;
+    deps: Link | undefined;
+    depsTail: Link | undefined;
+}
+export interface Link {
+    dep: Dependency | IComputed | (Dependency & IEffect);
+    sub: Subscriber | IComputed | IEffect;
+    trackId: number;
+    prevSub: Link | undefined;
+    nextSub: Link | undefined;
+    nextDep: Link | undefined;
+}
+export declare const enum DirtyLevels {
+    None = 0,
+    SideEffectsOnly = 1,
+    MaybeDirty = 2,
+    Dirty = 3
+}
+export declare namespace System {
+    let activeSub: Subscriber | undefined;
+    let activeTrackId: number;
+    let batchDepth: number;
+    let lastTrackId: number;
+    let queuedEffects: IEffect | undefined;
+    let queuedEffectsTail: IEffect | undefined;
+}
+export declare function startBatch(): void;
+export declare function endBatch(): void;
+export declare namespace Link {
+    function get(dep: Dependency, sub: Subscriber, nextDep: Link | undefined): Link;
+    function release(link: Link): void;
+}
+export declare namespace Dependency {
+    function link(dep: Dependency, sub: Subscriber): void;
+    function propagate(subs: Link): void;
+}
+export declare namespace Subscriber {
+    function checkDirty(link: Link, depth?: number): boolean;
+    function startTrack(sub: Subscriber): Subscriber | undefined;
+    function endTrack(sub: Subscriber, prevSub: Subscriber | undefined): void;
+    function clearTrack(link: Link): void;
+}

node_modules/alien-signals/cjs/unstable/computedArray.d.ts

@@ -0,0 +1,2 @@
+import { ISignal } from '../index.js';
+export declare function computedArray<I, O>(arr: ISignal<I[]>, getGetter: (item: ISignal<I>, index: number) => () => O): readonly Readonly<O>[];

node_modules/alien-signals/cjs/unstable/computedSet.d.ts

@@ -0,0 +1,2 @@
+import { ISignal } from '../index.js';
+export declare function computedSet<T>(source: ISignal<Set<T>>): ISignal<Set<T>>;

node_modules/alien-signals/cjs/unstable/equalityComputed.d.ts

@@ -0,0 +1,6 @@
+import { Computed, ISignal } from '../index.js';
+export declare function equalityComputed<T>(getter: () => T): ISignal<T>;
+export declare class EqualityComputed<T = any> extends Computed<T> {
+    constructor(getter: () => T);
+    equals(a: any, b: any): boolean;
+}

node_modules/alien-signals/cjs/unstable/index.d.ts

@@ -0,0 +1,3 @@
+export * from './computedArray.js';
+export * from './computedSet.js';
+export * from './equalityComputed.js';