@solidjs/signals 0.4.8 → 0.4.10

package/dist/prod.js

@@ -45,30 +45,30 @@ function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  if (!globalQueue.z)
+  if (!globalQueue.A)
     queueMicrotask(flush);
 }
 function notifyUnobserved() {
   for (let i = 0; i < Unobserved.length; i++) {
     const source = Unobserved[i];
     if (!source.b || !source.b.length)
-      Unobserved[i].da?.();
+      Unobserved[i].ea?.();
   }
   Unobserved = [];
 }
 var pureQueue = [];
 var Queue = class {
-  m = null;
-  z = false;
-  f = [[], []];
-  e = [];
+  k = null;
+  A = false;
+  g = [[], []];
+  f = [];
   created = clock;
   enqueue(type, fn) {
-    if (ActiveTransition && ActiveTransition.u.has(this))
-      return ActiveTransition.u.get(this).enqueue(type, fn);
+    if (ActiveTransition && ActiveTransition.p.has(this))
+      return ActiveTransition.p.get(this).enqueue(type, fn);
     pureQueue.push(fn);
     if (type)
-      this.f[type - 1].push(fn);
+      this.g[type - 1].push(fn);
     schedule();
   }
   run(type) {
@@ -76,19 +76,19 @@ var Queue = class {
       pureQueue.length && runQueue(pureQueue, type);
       pureQueue = [];
       return;
-    } else if (this.f[type - 1].length) {
-      const effects = this.f[type - 1];
-      this.f[type - 1] = [];
+    } else if (this.g[type - 1].length) {
+      const effects = this.g[type - 1];
+      this.g[type - 1] = [];
       runQueue(effects, type);
     }
-    for (let i = 0; i < this.e.length; i++) {
-      this.e[i].run(type);
+    for (let i = 0; i < this.f.length; i++) {
+      this.f[i].run(type);
     }
   }
   flush() {
-    if (this.z)
+    if (this.A)
       return;
-    this.z = true;
+    this.A = true;
     try {
       this.run(EFFECT_PURE);
       incrementClock();
@@ -96,35 +96,41 @@ var Queue = class {
       this.run(EFFECT_RENDER);
       this.run(EFFECT_USER);
     } finally {
-      this.z = false;
+      this.A = false;
       Unobserved.length && notifyUnobserved();
     }
   }
   addChild(child) {
-    this.e.push(child);
-    child.m = this;
+    if (ActiveTransition && ActiveTransition.p.has(this))
+      return ActiveTransition.p.get(this).addChild(child);
+    this.f.push(child);
+    child.k = this;
   }
   removeChild(child) {
-    const index = this.e.indexOf(child);
-    if (index >= 0)
-      this.e.splice(index, 1);
+    if (ActiveTransition && ActiveTransition.p.has(this))
+      return ActiveTransition.p.get(this).removeChild(child);
+    const index = this.f.indexOf(child);
+    if (index >= 0) {
+      this.f.splice(index, 1);
+      child.k = null;
+    }
   }
   notify(...args) {
-    if (ActiveTransition && ActiveTransition.u.has(this))
-      return ActiveTransition.u.get(this).notify(...args);
-    if (this.m)
-      return this.m.notify(...args);
+    if (ActiveTransition && ActiveTransition.p.has(this))
+      return ActiveTransition.p.get(this).notify(...args);
+    if (this.k)
+      return this.k.notify(...args);
     return false;
   }
   merge(queue) {
-    this.f[0].push.apply(this.f[0], queue.f[0]);
-    this.f[1].push.apply(this.f[1], queue.f[1]);
-    for (let i = 0; i < queue.e.length; i++) {
-      const og = this.e.find((c) => c.h === queue.e[i].h);
+    this.g[0].push.apply(this.g[0], queue.g[0]);
+    this.g[1].push.apply(this.g[1], queue.g[1]);
+    for (let i = 0; i < queue.f.length; i++) {
+      const og = this.f.find((c) => c.e === queue.f[i].e);
       if (og)
-        og.merge(queue.e[i]);
+        og.merge(queue.f[i]);
       else
-        this.addChild(queue.e[i]);
+        this.addChild(queue.f[i]);
     }
   }
 };
@@ -134,34 +140,50 @@ function flush() {
     globalQueue.flush();
   }
 }
+function removeSourceObservers(node, index) {
+  let source;
+  let swap;
+  for (let i = index; i < node.a.length; i++) {
+    source = getTransitionSource(node.a[i]);
+    if (source.b) {
+      if ((swap = source.b.indexOf(node)) !== -1) {
+        source.b[swap] = source.b[source.b.length - 1];
+        source.b.pop();
+      }
+      if (!source.b.length)
+        Unobserved.push(source);
+    }
+  }
+}
 function runQueue(queue, type) {
   for (let i = 0; i < queue.length; i++)
     queue[i](type);
 }
 var Transition = class _Transition {
   a = /* @__PURE__ */ new Map();
-  s = /* @__PURE__ */ new Set();
-  R = /* @__PURE__ */ new Set();
+  t = /* @__PURE__ */ new Set();
+  Q = /* @__PURE__ */ new Set();
   W = /* @__PURE__ */ new Set();
-  J = false;
-  f = [[], []];
-  u = /* @__PURE__ */ new Map();
+  I = false;
+  g = [[], []];
+  p = /* @__PURE__ */ new Map();
   E = [];
-  e = [];
-  m = null;
-  z = false;
+  f = [];
+  k = null;
+  A = false;
   X = false;
+  e = globalQueue;
   created = clock;
   constructor() {
-    this.u.set(globalQueue, this);
-    for (const child of globalQueue.e) {
-      cloneQueue(child, this, this.u);
+    this.p.set(globalQueue, this);
+    for (const child of globalQueue.f) {
+      cloneQueue(child, this, this.p);
     }
   }
   enqueue(type, fn) {
     this.E.push(fn);
     if (type)
-      this.f[type - 1].push(fn);
+      this.g[type - 1].push(fn);
     this.schedule();
   }
   run(type) {
@@ -169,19 +191,19 @@ var Transition = class _Transition {
       this.E.length && runQueue(this.E, type);
       this.E = [];
       return;
-    } else if (this.f[type - 1].length) {
-      const effects = this.f[type - 1];
-      this.f[type - 1] = [];
+    } else if (this.g[type - 1].length) {
+      const effects = this.g[type - 1];
+      this.g[type - 1] = [];
       runQueue(effects, type);
     }
-    for (let i = 0; i < this.e.length; i++) {
-      this.e[i].run(type);
+    for (let i = 0; i < this.f.length; i++) {
+      this.f[i].run(type);
     }
   }
   flush() {
-    if (this.z)
+    if (this.A)
       return;
-    this.z = true;
+    this.A = true;
     let currentTransition = ActiveTransition;
     ActiveTransition = this;
     try {
@@ -191,52 +213,52 @@ var Transition = class _Transition {
       ActiveTransition = currentTransition;
       finishTransition(this);
     } finally {
-      this.z = false;
+      this.A = false;
       ActiveTransition = currentTransition;
     }
   }
   addChild(child) {
-    this.e.push(child);
-    child.m = this;
+    this.f.push(child);
+    child.k = this;
   }
   removeChild(child) {
-    const index = this.e.indexOf(child);
+    const index = this.f.indexOf(child);
     if (index >= 0)
-      this.e.splice(index, 1);
+      this.f.splice(index, 1);
   }
   notify(node, type, flags) {
     if (!(type & LOADING_BIT))
       return false;
     if (flags & LOADING_BIT) {
-      this.s.add(node);
+      this.t.add(node);
     } else {
-      this.s.delete(node);
+      this.t.delete(node);
     }
     return true;
   }
   merge(queue) {
-    this.f[0].push.apply(this.f[0], queue.f[0]);
-    this.f[1].push.apply(this.f[1], queue.f[1]);
+    this.g[0].push.apply(this.g[0], queue.g[0]);
+    this.g[1].push.apply(this.g[1], queue.g[1]);
     this.E.push.apply(this.E, queue.E);
-    for (let i = 0; i < queue.e.length; i++) {
-      const og = this.e.find((c) => c.h === queue.e[i].h);
+    for (let i = 0; i < queue.f.length; i++) {
+      const og = this.f.find((c) => c.e === queue.f[i].e);
       if (og)
-        og.merge(queue.e[i]);
+        og.merge(queue.f[i]);
       else
-        this.addChild(queue.e[i]);
+        this.addChild(queue.f[i]);
     }
   }
   schedule() {
     if (this.X)
       return;
     this.X = true;
-    if (!this.z)
+    if (!this.A)
       queueMicrotask(() => this.flush());
   }
   runTransition(fn, force = false) {
-    if (this.J) {
-      if (this.J instanceof _Transition)
-        return this.J.runTransition(fn, force);
+    if (this.I) {
+      if (this.I instanceof _Transition)
+        return this.I.runTransition(fn, force);
       if (!force)
         throw new Error("Transition already completed");
       fn();
@@ -247,9 +269,9 @@ var Transition = class _Transition {
       const result = fn();
       const transition2 = ActiveTransition;
       if (result instanceof Promise) {
-        transition2.R.add(result);
+        transition2.Q.add(result);
         result.finally(() => {
-          transition2.R.delete(result);
+          transition2.Q.delete(result);
           finishTransition(transition2);
         });
       }
@@ -283,14 +305,12 @@ function cloneGraph(node) {
   }
   const clone = Object.create(Object.getPrototypeOf(node));
   Object.assign(clone, node, {
+    o: null,
     n: null,
-    r: null,
     b: null,
     a: node.a ? [...node.a] : null,
-    h: node
+    e: node
   });
-  if (clone.F)
-    clone.g |= UNINITIALIZED_BIT;
   ActiveTransition.a.set(node, clone);
   node.j = ActiveTransition;
   if (node.a) {
@@ -300,36 +320,35 @@ function cloneGraph(node) {
   if (node.b) {
     clone.b = [];
     for (let i = 0, length = node.b.length; i < length; i++) {
-      !node.b[i].h && clone.b.push(cloneGraph(node.b[i]));
+      !node.b[i].e && clone.b.push(cloneGraph(node.b[i]));
     }
   }
   return clone;
 }
 function replaceSourceObservers(node, transition2) {
   let source;
-  let transitionSource;
   let swap;
   for (let i = 0; i < node.a.length; i++) {
-    transitionSource = transition2.a.get(node.a[i]);
-    source = transitionSource || node.a[i];
+    source = transition2.a.get(node.a[i]) || node.a[i];
     if (source.b && (swap = source.b.indexOf(node)) !== -1) {
-      source.b[swap] = transitionSource ? node.h : source.b[source.b.length - 1];
-      !transitionSource && source.b.pop();
+      const remove = source.b.indexOf(node.e) > -1;
+      source.b[swap] = !remove ? node.e : source.b[source.b.length - 1];
+      remove && source.b.pop();
     }
   }
 }
 function cloneQueue(queue, parent, clonedQueues) {
   const clone = Object.create(Object.getPrototypeOf(queue));
   Object.assign(clone, queue, {
-    h: queue,
-    m: parent,
-    e: [],
+    e: queue,
+    k: parent,
+    f: [],
     enqueue(type, fn) {
       ActiveTransition?.enqueue(type, fn);
     },
     notify(node, type, flags) {
-      node = node.h || node;
-      if (!clone.G || type & LOADING_BIT) {
+      node = node.e || node;
+      if (!clone.F || type & LOADING_BIT) {
         type &= ~LOADING_BIT;
         ActiveTransition?.notify(node, LOADING_BIT, flags);
         if (!type)
@@ -338,26 +357,26 @@ function cloneQueue(queue, parent, clonedQueues) {
       return queue.notify.call(this, node, type, flags);
     }
   });
-  parent.e.push(clone);
+  parent.f.push(clone);
   clonedQueues.set(queue, clone);
-  for (const child of queue.e) {
+  for (const child of queue.f) {
     cloneQueue(child, clone, clonedQueues);
   }
 }
 function resolveQueues(children) {
   for (const child of children) {
-    const og = child.h;
+    const og = child.e;
     if (og) {
-      const clonedChildren = child.e;
+      const clonedChildren = child.f;
       delete child.enqueue;
       delete child.notify;
-      delete child.m;
-      delete child.e;
+      delete child.k;
+      delete child.f;
       Object.assign(og, child);
-      delete og.h;
+      delete og.e;
       resolveQueues(clonedChildren);
-    } else if (child.m.h) {
-      child.m.h.addChild(child);
+    } else if (child.k.e) {
+      child.k.e.addChild(child);
     }
   }
 }
@@ -370,31 +389,57 @@ function mergeTransitions(t1, t2) {
     c.j = t1;
     t1.W.add(c);
   });
-  t2.R.forEach((p) => t1.R.add(p));
-  t2.s.forEach((n) => t1.s.add(n));
+  t2.Q.forEach((p) => t1.Q.add(p));
+  t2.t.forEach((n) => t1.t.add(n));
   t1.merge(t2);
-  t2.J = t1;
+  t2.I = t1;
+}
+function getTransitionSource(input) {
+  return ActiveTransition && ActiveTransition.a.get(input) || input;
+}
+function initialDispose(node) {
+  let current = node.n;
+  while (current !== null && current.k === node) {
+    initialDispose(current);
+    const clone = ActiveTransition.a.get(current);
+    if (clone && !clone.Y)
+      clone.dispose(true);
+    current = current.n;
+  }
 }
 function finishTransition(transition2) {
-  if (transition2.J || transition2.X || transition2.R.size || transition2.s.size)
+  if (transition2.I || transition2.X || transition2.Q.size || transition2.t.size)
     return;
+  globalQueue.g[0].push.apply(globalQueue.g[0], transition2.g[0]);
+  globalQueue.g[1].push.apply(globalQueue.g[1], transition2.g[1]);
+  resolveQueues(transition2.f);
   for (const [source, clone] of transition2.a) {
-    if (source === clone || source.j !== transition2)
+    if (source === clone || source.j !== transition2) {
+      delete source.j;
       continue;
+    }
     if (clone.a)
       replaceSourceObservers(clone, transition2);
-    if (!(clone.g === UNINITIALIZED_BIT)) {
-      source.dispose(false);
+    if (clone.Y || clone.c === STATE_DISPOSED) {
+      source.dispose(clone.c === STATE_DISPOSED);
       source.emptyDisposal();
-      Object.assign(source, clone);
-      delete source.h;
+      delete clone.Y;
+    } else {
+      delete clone.n;
+      delete clone.o;
+    }
+    Object.assign(source, clone);
+    delete source.e;
+    let current = clone.n;
+    if (current?.w === clone)
+      current.w = source;
+    while (current?.k === clone) {
+      current.k = source;
+      current = current.n;
     }
     delete source.j;
   }
-  globalQueue.f[0].push.apply(globalQueue.f[0], transition2.f[0]);
-  globalQueue.f[1].push.apply(globalQueue.f[1], transition2.f[1]);
-  resolveQueues(transition2.e);
-  transition2.J = true;
+  transition2.I = true;
   for (const reset of transition2.W) {
     delete reset.j;
     reset();
@@ -417,14 +462,14 @@ var Owner = class {
   // We flatten the owner tree into a linked list so that we don't need a pointer to .firstChild
   // However, the children are actually added in reverse creation order
   // See comment at the top of the file for an example of the _nextSibling traversal
-  m = null;
-  r = null;
-  B = null;
-  c = STATE_CLEAN;
+  k = null;
   n = null;
-  w = defaultContext;
-  l = globalQueue;
-  ea = 0;
+  w = null;
+  c = STATE_CLEAN;
+  o = null;
+  x = defaultContext;
+  m = globalQueue;
+  fa = 0;
   id = null;
   constructor(id = null, skipAppend = false) {
     this.id = id;
@@ -433,64 +478,63 @@ var Owner = class {
     }
   }
   append(child) {
-    child.m = this;
-    child.B = this;
-    if (this.r)
-      this.r.B = child;
-    child.r = this.r;
-    this.r = child;
+    child.k = this;
+    child.w = this;
+    if (this.n)
+      this.n.w = child;
+    child.n = this.n;
+    this.n = child;
     if (this.id != null && child.id == null)
       child.id = this.getNextChildId();
-    if (child.w !== this.w) {
-      child.w = { ...this.w, ...child.w };
+    if (child.x !== this.x) {
+      child.x = { ...this.x, ...child.x };
     }
-    if (this.l)
-      child.l = this.l;
+    if (this.m)
+      child.m = this.m;
   }
   dispose(self = true) {
     if (this.c === STATE_DISPOSED)
       return;
-    let head = self ? this.B || this.m : this, current = this.r, next = null;
-    while (current && current.m === this) {
+    let head = self ? this.w || this.k : this, current = this.n, next = null;
+    while (current && current.k === this) {
       current.dispose(true);
-      current.K();
-      next = current.r;
-      current.r = null;
+      next = current.n;
+      current.n = null;
       current = next;
     }
-    this.ea = 0;
+    this.fa = 0;
     if (self)
-      this.K();
+      this.R();
     if (current)
-      current.B = !self ? this : this.B;
+      current.w = !self ? this : this.w;
     if (head)
-      head.r = current;
-  }
-  K() {
-    if (this.B)
-      this.B.r = null;
-    this.m = null;
-    this.B = null;
-    this.w = defaultContext;
+      head.n = current;
+  }
+  R() {
+    if (this.w)
+      this.w.n = null;
+    this.k = null;
+    this.w = null;
+    this.x = defaultContext;
     this.c = STATE_DISPOSED;
     this.emptyDisposal();
   }
   emptyDisposal() {
-    if (!this.n)
+    if (!this.o)
       return;
-    if (Array.isArray(this.n)) {
-      for (let i = 0; i < this.n.length; i++) {
-        const callable = this.n[i];
+    if (Array.isArray(this.o)) {
+      for (let i = 0; i < this.o.length; i++) {
+        const callable = this.o[i];
         callable.call(callable);
       }
     } else {
-      this.n.call(this.n);
+      this.o.call(this.o);
     }
-    this.n = null;
+    this.o = null;
   }
   getNextChildId() {
     if (this.id != null)
-      return formatId(this.id, this.ea++);
+      return formatId(this.id, this.fa++);
     throw new Error("Cannot get child id from owner without an id");
   }
 };
@@ -501,7 +545,7 @@ function getContext(context, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  const value = hasContext(context, owner) ? owner.w[context.id] : context.defaultValue;
+  const value = hasContext(context, owner) ? owner.x[context.id] : context.defaultValue;
   if (isUndefined(value)) {
     throw new ContextNotFoundError();
   }
@@ -511,24 +555,24 @@ function setContext(context, value, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  owner.w = {
-    ...owner.w,
+  owner.x = {
+    ...owner.x,
     [context.id]: isUndefined(value) ? context.defaultValue : value
   };
 }
 function hasContext(context, owner = currentOwner) {
-  return !isUndefined(owner?.w[context.id]);
+  return !isUndefined(owner?.x[context.id]);
 }
 function onCleanup(fn) {
   if (!currentOwner)
     return fn;
   const node = currentOwner;
-  if (!node.n) {
-    node.n = fn;
-  } else if (Array.isArray(node.n)) {
-    node.n.push(fn);
+  if (!node.o) {
+    node.o = fn;
+  } else if (Array.isArray(node.o)) {
+    node.o.push(fn);
   } else {
-    node.n = [node.n, fn];
+    node.o = [node.o, fn];
   }
   return fn;
 }
@@ -556,48 +600,48 @@ var UNCHANGED = Symbol(0);
 var Computation = class extends Owner {
   a = null;
   b = null;
-  k;
-  L;
-  F;
+  l;
+  J;
+  K;
   // Used in __DEV__ mode, hopefully removed in production
-  ka;
+  la;
   // Using false is an optimization as an alternative to _equals: () => false
   // which could enable more efficient DIRTY notification
-  $ = isEqual;
-  da;
-  ga = false;
+  aa = isEqual;
+  ea;
+  ha = false;
   /** Whether the computation is an error or has ancestors that are unresolved */
-  g = 0;
+  h = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
-  aa = DEFAULT_FLAGS;
-  M = -1;
-  H = false;
+  ba = DEFAULT_FLAGS;
+  L = -1;
+  G = false;
   j;
-  h;
+  e;
   constructor(initialValue, compute2, options) {
     super(options?.id, compute2 === null);
-    this.F = compute2;
+    this.K = compute2;
     this.c = compute2 ? STATE_DIRTY : STATE_CLEAN;
-    this.g = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
-    this.k = initialValue;
+    this.h = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
+    this.l = initialValue;
     if (options?.equals !== void 0)
-      this.$ = options.equals;
+      this.aa = options.equals;
     if (options?.pureWrite)
-      this.ga = true;
+      this.ha = true;
     if (options?.unobserved)
-      this.da = options?.unobserved;
+      this.ea = options?.unobserved;
     if (ActiveTransition) {
       this.j = ActiveTransition;
       ActiveTransition.a.set(this, this);
     }
   }
-  fa() {
+  ga() {
     track(this);
-    newFlags |= this.g & ~currentMask;
-    if (this.g & ERROR_BIT) {
-      throw this.L;
+    newFlags |= this.h & ~currentMask;
+    if (this.h & ERROR_BIT) {
+      throw this.J;
     } else {
-      return this.k;
+      return this.l;
     }
   }
   /**
@@ -605,18 +649,18 @@ var Computation = class extends Owner {
    * Automatically re-executes the surrounding computation when the value changes
    */
   read() {
-    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.h && this.g & UNINITIALIZED_BIT)) {
+    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.e && this.h & (UNINITIALIZED_BIT | ERROR_BIT))) {
       const clone = ActiveTransition.a.get(this) || cloneGraph(this);
       if (clone !== this)
         return clone.read();
     }
-    if (this.F) {
-      if (this.g & ERROR_BIT && this.M <= clock)
+    if (this.K) {
+      if (this.h & ERROR_BIT && this.L <= clock)
         update(this);
       else
-        this.I();
+        this.H();
     }
-    return this.fa();
+    return this.ga();
   }
   /**
    * Return the current value of this computation
@@ -626,65 +670,65 @@ var Computation = class extends Owner {
    * before continuing
    */
   wait() {
-    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.h && this.g & UNINITIALIZED_BIT)) {
+    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.e && this.h & (UNINITIALIZED_BIT | ERROR_BIT))) {
       const clone = ActiveTransition.a.get(this) || cloneGraph(this);
       if (clone !== this)
         return clone.wait();
     }
-    if (this.F) {
-      if (this.g & ERROR_BIT && this.M <= clock)
+    if (this.K) {
+      if (this.h & ERROR_BIT && this.L <= clock)
         update(this);
       else
-        this.I();
+        this.H();
     }
-    if ((notStale || this.g & UNINITIALIZED_BIT) && this.g & LOADING_BIT) {
+    if ((notStale || this.h & UNINITIALIZED_BIT) && this.h & LOADING_BIT) {
       track(this);
       throw new NotReadyError();
     }
-    if (staleCheck && this.g & LOADING_BIT) {
-      staleCheck.k = true;
+    if (staleCheck && this.h & LOADING_BIT) {
+      staleCheck.l = true;
     }
-    return this.fa();
+    return this.ga();
   }
   /** Update the computation with a new value. */
   write(value, flags = 0, raw = false) {
-    if (ActiveTransition && !this.h) {
+    if (ActiveTransition && !this.e) {
       const clone = cloneGraph(this);
       if (clone !== this)
         return clone.write(value, flags, raw);
     }
-    const newValue = !raw && typeof value === "function" ? value(this.k) : value;
-    const valueChanged = newValue !== UNCHANGED && (!!(this.g & UNINITIALIZED_BIT) || // this._stateFlags & LOADING_BIT & ~flags ||
-    this.$ === false || !this.$(this.k, newValue));
+    const newValue = !raw && typeof value === "function" ? value(this.l) : value;
+    const valueChanged = newValue !== UNCHANGED && (!!(this.h & UNINITIALIZED_BIT) || // this._stateFlags & LOADING_BIT & ~flags ||
+    this.aa === false || !this.aa(this.l, newValue));
     if (valueChanged) {
-      this.k = newValue;
-      this.L = void 0;
+      this.l = newValue;
+      this.J = void 0;
     }
-    const changedFlagsMask = this.g ^ flags, changedFlags = changedFlagsMask & flags;
-    this.g = flags;
-    this.M = clock + 1;
+    const changedFlagsMask = this.h ^ flags, changedFlags = changedFlagsMask & flags;
+    this.h = flags;
+    this.L = clock + 1;
     if (this.b) {
       for (let i = 0; i < this.b.length; i++) {
         if (valueChanged) {
-          this.b[i].x(STATE_DIRTY);
+          this.b[i].y(STATE_DIRTY);
         } else if (changedFlagsMask) {
-          this.b[i].Y(changedFlagsMask, changedFlags);
+          this.b[i].Z(changedFlagsMask, changedFlags);
         }
       }
     }
-    return this.k;
+    return this.l;
   }
   /**
    * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
    */
-  x(state, skipQueue) {
-    if (this.c >= state && !this.H)
+  y(state, skipQueue) {
+    if (this.c >= state && !this.G)
       return;
-    this.H = !!skipQueue;
+    this.G = !!skipQueue;
     this.c = state;
     if (this.b) {
       for (let i = 0; i < this.b.length; i++) {
-        this.b[i].x(STATE_CHECK, skipQueue);
+        this.b[i].y(STATE_CHECK, skipQueue);
       }
     }
   }
@@ -694,36 +738,36 @@ var Computation = class extends Owner {
    * @param mask A bitmask for which flag(s) were changed.
    * @param newFlags The source's new flags, masked to just the changed ones.
    */
-  Y(mask, newFlags2) {
+  Z(mask, newFlags2) {
     if (this.c >= STATE_DIRTY)
       return;
-    if (mask & this.aa) {
-      this.x(STATE_DIRTY);
+    if (mask & this.ba) {
+      this.y(STATE_DIRTY);
       return;
     }
     if (this.c >= STATE_CHECK)
       return;
-    const prevFlags = this.g & mask;
+    const prevFlags = this.h & mask;
     const deltaFlags = prevFlags ^ newFlags2;
     if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
-      this.x(STATE_CHECK);
+      this.y(STATE_CHECK);
     } else {
-      this.g ^= deltaFlags;
+      this.h ^= deltaFlags;
       if (this.b) {
         for (let i = 0; i < this.b.length; i++) {
-          this.b[i].Y(mask, newFlags2);
+          this.b[i].Z(mask, newFlags2);
         }
       }
     }
   }
-  N(error) {
-    if (ActiveTransition && !this.h) {
+  M(error) {
+    if (ActiveTransition && !this.e) {
       const clone = cloneGraph(this);
       if (clone !== this)
-        return clone.N(error);
+        return clone.M(error);
     }
-    this.L = error;
-    this.write(UNCHANGED, this.g & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
+    this.J = error;
+    this.write(UNCHANGED, this.h & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
   }
   /**
    * This is the core part of the reactivity system, which makes sure that the values are updated
@@ -732,8 +776,8 @@ var Computation = class extends Owner {
    *
    * This function will ensure that the value and states we read from the computation are up to date
    */
-  I() {
-    if (!this.F) {
+  H() {
+    if (!this.K) {
       return;
     }
     if (this.c === STATE_DISPOSED) {
@@ -745,9 +789,9 @@ var Computation = class extends Owner {
     let observerFlags = 0;
     if (this.c === STATE_CHECK) {
       for (let i = 0; i < this.a.length; i++) {
-        const source = ActiveTransition && ActiveTransition.a.get(this.a[i]) || this.a[i];
-        source.I();
-        observerFlags |= source.g & ~UNINITIALIZED_BIT;
+        const source = getTransitionSource(this.a[i]);
+        source.H();
+        observerFlags |= source.h & ~UNINITIALIZED_BIT;
         if (this.c === STATE_DIRTY) {
           break;
         }
@@ -763,17 +807,17 @@ var Computation = class extends Owner {
   /**
    * Remove ourselves from the owner graph and the computation graph
    */
-  K() {
+  R() {
     if (this.c === STATE_DISPOSED)
       return;
     if (this.a)
       removeSourceObservers(this, 0);
-    super.K();
+    super.R();
   }
 };
 function track(computation) {
-  if (ActiveTransition && computation.h)
-    computation = computation.h;
+  if (ActiveTransition && computation.e)
+    computation = computation.e;
   if (currentObserver) {
     if (!newSources && currentObserver.a && currentObserver.a[newSourcesIndex] === computation) {
       newSourcesIndex++;
@@ -783,7 +827,7 @@ function track(computation) {
       newSources.push(computation);
     }
     if (updateCheck) {
-      updateCheck.k = computation.M > currentObserver.M;
+      updateCheck.l = computation.L > currentObserver.L;
     }
   }
 }
@@ -793,15 +837,19 @@ function update(node) {
   newSourcesIndex = 0;
   newFlags = 0;
   try {
+    if (ActiveTransition && node.e && !node.Y) {
+      initialDispose(node.e);
+      node.Y = true;
+    }
     node.dispose(false);
     node.emptyDisposal();
-    const result = compute(node, node.F, node);
+    const result = compute(node, node.K, node);
     node.write(result, newFlags, true);
   } catch (error) {
     if (error instanceof NotReadyError) {
-      node.write(UNCHANGED, newFlags | LOADING_BIT | node.g & UNINITIALIZED_BIT);
+      node.write(UNCHANGED, newFlags | LOADING_BIT | node.h & UNINITIALIZED_BIT);
     } else {
-      node.N(error);
+      node.M(error);
     }
   } finally {
     if (newSources) {
@@ -817,7 +865,7 @@ function update(node) {
       }
       let source;
       for (let i = newSourcesIndex; i < node.a.length; i++) {
-        source = ActiveTransition && ActiveTransition.a.get(node.a[i]) || node.a[i];
+        source = getTransitionSource(node.a[i]);
         if (!source.b)
           source.b = [node];
         else
@@ -830,25 +878,10 @@ function update(node) {
     newSources = prevSources;
     newSourcesIndex = prevSourcesIndex;
     newFlags = prevFlags;
-    node.M = clock + 1;
+    node.L = clock + 1;
     node.c = STATE_CLEAN;
   }
 }
-function removeSourceObservers(node, index) {
-  let source;
-  let swap;
-  for (let i = index; i < node.a.length; i++) {
-    source = ActiveTransition && ActiveTransition.a.get(node.a[i]) || node.a[i];
-    if (source.b) {
-      if ((swap = source.b.indexOf(node)) !== -1) {
-        source.b[swap] = source.b[source.b.length - 1];
-        source.b.pop();
-      }
-      if (!source.b.length)
-        Unobserved.push(source);
-    }
-  }
-}
 function isEqual(a, b) {
   return a === b;
 }
@@ -859,20 +892,20 @@ function untrack(fn) {
 }
 function hasUpdated(fn) {
   const current = updateCheck;
-  updateCheck = { k: false };
+  updateCheck = { l: false };
   try {
     fn();
-    return updateCheck.k;
+    return updateCheck.l;
   } finally {
     updateCheck = current;
   }
 }
 function pendingCheck(fn, loadingValue) {
   const current = staleCheck;
-  staleCheck = { k: false };
+  staleCheck = { l: false };
   try {
     latest(fn);
-    return staleCheck.k;
+    return staleCheck.l;
   } catch (err) {
     if (!(err instanceof NotReadyError))
       return false;
@@ -887,7 +920,7 @@ function isPending(fn, loadingValue) {
   if (!currentObserver)
     return pendingCheck(fn, loadingValue);
   const c = new Computation(void 0, () => pendingCheck(fn, loadingValue));
-  c.aa |= LOADING_BIT;
+  c.ba |= LOADING_BIT;
   return c.read();
 }
 function latest(fn, fallback) {
@@ -917,10 +950,10 @@ function runWithObserver(observer, run) {
     if (error instanceof NotReadyError) {
       observer.write(
         UNCHANGED,
-        newFlags | LOADING_BIT | observer.g & UNINITIALIZED_BIT
+        newFlags | LOADING_BIT | observer.h & UNINITIALIZED_BIT
       );
     } else {
-      observer.N(error);
+      observer.M(error);
     }
   } finally {
     if (newSources) {
@@ -949,10 +982,10 @@ function runWithObserver(observer, run) {
 function compute(owner, fn, observer) {
   const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask, prevNotStale = notStale;
   currentObserver = observer;
-  currentMask = observer?.aa ?? DEFAULT_FLAGS;
+  currentMask = observer?.ba ?? DEFAULT_FLAGS;
   notStale = true;
   try {
-    return fn.call(observer, observer ? observer.k : void 0);
+    return fn.call(observer, observer ? observer.l : void 0);
   } finally {
     setOwner(prevOwner);
     currentObserver = prevObserver;
@@ -963,99 +996,99 @@ function compute(owner, fn, observer) {
 
 // src/core/effect.ts
 var Effect = class extends Computation {
-  ba;
-  Z;
-  O;
-  ca = false;
+  ca;
   _;
-  A;
+  N;
+  da = false;
+  $;
+  B;
   constructor(initialValue, compute2, effect, error, options) {
     super(initialValue, compute2, options);
-    this.ba = effect;
-    this.Z = error;
-    this._ = initialValue;
-    this.A = options?.render ? EFFECT_RENDER : EFFECT_USER;
-    if (this.A === EFFECT_RENDER) {
-      this.F = function(p) {
-        return !this.h && clock > this.l.created && !(this.g & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
+    this.ca = effect;
+    this._ = error;
+    this.$ = initialValue;
+    this.B = options?.render ? EFFECT_RENDER : EFFECT_USER;
+    if (this.B === EFFECT_RENDER) {
+      this.K = function(p) {
+        return !this.e && clock > this.m.created && !(this.h & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
       };
     }
-    this.I();
-    !options?.defer && (this.A === EFFECT_USER ? this.l.enqueue(this.A, this.C.bind(this)) : this.C(this.A));
+    this.H();
+    !options?.defer && (this.B === EFFECT_USER ? this.m.enqueue(this.B, this.C.bind(this)) : this.C(this.B));
   }
   write(value, flags = 0) {
     if (this.c == STATE_DIRTY) {
-      this.g = flags;
-      if (this.A === EFFECT_RENDER) {
-        this.l.notify(this, LOADING_BIT | ERROR_BIT, this.g);
+      this.h = flags;
+      if (this.B === EFFECT_RENDER) {
+        this.m.notify(this, LOADING_BIT | ERROR_BIT, this.h);
       }
     }
     if (value === UNCHANGED)
-      return this.k;
-    this.k = value;
-    this.ca = true;
-    this.L = void 0;
+      return this.l;
+    this.l = value;
+    this.da = true;
+    this.J = void 0;
     return value;
   }
-  x(state, skipQueue) {
+  y(state, skipQueue) {
     if (this.c >= state || skipQueue)
       return;
     if (this.c === STATE_CLEAN)
-      this.l.enqueue(this.A, this.C.bind(this));
+      this.m.enqueue(this.B, this.C.bind(this));
     this.c = state;
   }
-  Y(mask, newFlags2) {
-    if (this.h) {
+  Z(mask, newFlags2) {
+    if (this.e) {
       if (this.c >= STATE_DIRTY)
         return;
       if (mask & 3) {
-        this.x(STATE_DIRTY);
+        this.y(STATE_DIRTY);
         return;
       }
     }
-    super.Y(mask, newFlags2);
+    super.Z(mask, newFlags2);
   }
-  N(error) {
-    this.L = error;
-    this.l.notify(this, LOADING_BIT, 0);
-    this.g = ERROR_BIT;
-    if (this.A === EFFECT_USER) {
+  M(error) {
+    this.J = error;
+    this.m.notify(this, LOADING_BIT, 0);
+    this.h = ERROR_BIT;
+    if (this.B === EFFECT_USER) {
       try {
-        return this.Z ? this.Z(error, () => {
-          this.O?.();
-          this.O = void 0;
+        return this._ ? this._(error, () => {
+          this.N?.();
+          this.N = void 0;
         }) : console.error(error);
       } catch (e) {
         error = e;
       }
     }
-    if (!this.l.notify(this, ERROR_BIT, ERROR_BIT))
+    if (!this.m.notify(this, ERROR_BIT, ERROR_BIT))
       throw error;
   }
-  K() {
+  R() {
     if (this.c === STATE_DISPOSED)
       return;
-    this.ba = void 0;
+    this.ca = void 0;
+    this.$ = void 0;
     this._ = void 0;
-    this.Z = void 0;
-    this.O?.();
-    this.O = void 0;
-    this.l.notify(this, ERROR_BIT | LOADING_BIT, 0);
-    super.K();
+    this.N?.();
+    this.N = void 0;
+    this.m.notify(this, ERROR_BIT | LOADING_BIT, 0);
+    super.R();
   }
   C(type) {
     if (type) {
-      const effect = this.h || this;
-      if (effect.ca && effect.c !== STATE_DISPOSED) {
-        effect.O?.();
+      const effect = this.e || this;
+      if (effect.da && effect.c !== STATE_DISPOSED) {
+        effect.N?.();
         try {
-          effect.O = effect.ba(effect.k, effect._);
+          effect.N = effect.ca(effect.l, effect.$);
         } catch (e) {
-          if (!effect.l.notify(effect, ERROR_BIT, ERROR_BIT))
+          if (!effect.m.notify(effect, ERROR_BIT, ERROR_BIT))
             throw e;
         } finally {
-          effect._ = effect.k;
-          effect.ca = false;
+          effect.$ = effect.l;
+          effect.da = false;
         }
       }
     } else
@@ -1065,14 +1098,14 @@ var Effect = class extends Computation {
 var EagerComputation = class extends Computation {
   constructor(initialValue, compute2, options) {
     super(initialValue, compute2, options);
-    !options?.defer && this.I();
+    !options?.defer && this.H();
   }
-  x(state, skipQueue) {
-    if (this.c >= state && !this.H)
+  y(state, skipQueue) {
+    if (this.c >= state && !this.G)
       return;
-    if (!skipQueue && (this.c === STATE_CLEAN || this.c === STATE_CHECK && this.H))
-      this.l.enqueue(EFFECT_PURE, this.C.bind(this));
-    super.x(state, skipQueue);
+    if (!skipQueue && (this.c === STATE_CLEAN || this.c === STATE_CHECK && this.G))
+      this.m.enqueue(EFFECT_PURE, this.C.bind(this));
+    super.y(state, skipQueue);
   }
   C() {
     this.c !== STATE_CLEAN && runTop(this);
@@ -1083,13 +1116,13 @@ var FirewallComputation = class extends Computation {
   constructor(compute2) {
     super(void 0, compute2);
   }
-  x(state, skipQueue) {
-    if (this.c >= state && !this.H)
+  y(state, skipQueue) {
+    if (this.c >= state && !this.G)
       return;
-    if (!skipQueue && (this.c === STATE_CLEAN || this.c === STATE_CHECK && this.H))
-      this.l.enqueue(EFFECT_PURE, this.C.bind(this));
-    super.x(state, true);
-    this.H = !!skipQueue;
+    if (!skipQueue && (this.c === STATE_CLEAN || this.c === STATE_CHECK && this.G))
+      this.m.enqueue(EFFECT_PURE, this.C.bind(this));
+    super.y(state, true);
+    this.G = !!skipQueue;
   }
   C() {
     this.c !== STATE_CLEAN && runTop(this);
@@ -1097,14 +1130,16 @@ var FirewallComputation = class extends Computation {
 };
 function runTop(node) {
   const ancestors = [];
-  for (let current = node; current !== null; current = current.m) {
+  for (let current = node; current !== null; current = current.k) {
+    if (ActiveTransition && current.j)
+      current = ActiveTransition.a.get(current);
     if (current.c !== STATE_CLEAN) {
       ancestors.push(current);
     }
   }
   for (let i = ancestors.length - 1; i >= 0; i--) {
     if (ancestors[i].c !== STATE_DISPOSED)
-      ancestors[i].I();
+      ancestors[i].H();
   }
 }
 
@@ -1238,7 +1273,7 @@ var storeTraps = {
         return desc.get.call(receiver);
     }
     if (Writing?.has(receiver)) {
-      let value2 = tracked && (overridden || !proxySource) ? tracked.k : storeValue[property];
+      let value2 = tracked && (overridden || !proxySource) ? tracked.l : storeValue[property];
       value2 === $DELETED && (value2 = void 0);
       if (!isWrappable(value2))
         return value2;
@@ -1775,7 +1810,7 @@ function createMemo(compute2, value, options) {
         return resolvedValue;
       }
       resolvedValue = node.wait();
-      if (!node.a?.length && node.r?.m !== node && !(node.g & UNINITIALIZED_BIT)) {
+      if (!node.a?.length && node.n?.k !== node && !(node.h & UNINITIALIZED_BIT)) {
         node.dispose();
         node = void 0;
       }
@@ -1811,8 +1846,8 @@ function createAsync(compute2, value, options) {
             if (abort)
               return;
             if (transition2)
-              return transition2.runTransition(() => node.N(error), true);
-            node.N(error);
+              return transition2.runTransition(() => node.M(error), true);
+            node.M(error);
           }
         );
       } else {
@@ -1837,12 +1872,12 @@ function createAsync(compute2, value, options) {
   const read = node.wait.bind(node);
   read.refresh = () => {
     let n = node;
-    if (ActiveTransition && !node.h) {
+    if (ActiveTransition && !node.e) {
       n = cloneGraph(node);
     }
     n.c = STATE_DIRTY;
     refreshing = true;
-    n.I();
+    n.H();
   };
   return read;
 }
@@ -1955,47 +1990,47 @@ function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
   return updateKeyedMap.bind({
     S: new Owner(),
-    o: 0,
-    ha: list,
+    q: 0,
+    ia: list,
     D: [],
-    P: map,
+    O: map,
     i: [],
     d: [],
-    Q: keyFn,
-    p: keyFn || options?.keyed === false ? [] : void 0,
-    q: map.length > 1 ? [] : void 0,
+    P: keyFn,
+    r: keyFn || options?.keyed === false ? [] : void 0,
+    s: map.length > 1 ? [] : void 0,
     T: options?.fallback
   });
 }
 var pureOptions = { pureWrite: true };
 function updateKeyedMap() {
-  const newItems = this.ha() || [], newLen = newItems.length;
+  const newItems = this.ia() || [], newLen = newItems.length;
   newItems[$TRACK];
   runWithOwner(this.S, () => {
-    let i, j, mapper = this.p ? () => {
-      this.p[j] = new Computation(newItems[j], null, pureOptions);
-      this.q && (this.q[j] = new Computation(j, null, pureOptions));
-      return this.P(
-        Computation.prototype.read.bind(this.p[j]),
-        this.q ? Computation.prototype.read.bind(this.q[j]) : void 0
+    let i, j, mapper = this.r ? () => {
+      this.r[j] = new Computation(newItems[j], null, pureOptions);
+      this.s && (this.s[j] = new Computation(j, null, pureOptions));
+      return this.O(
+        Computation.prototype.read.bind(this.r[j]),
+        this.s ? Computation.prototype.read.bind(this.s[j]) : void 0
       );
-    } : this.q ? () => {
+    } : this.s ? () => {
       const item = newItems[j];
-      this.q[j] = new Computation(j, null, pureOptions);
-      return this.P(() => item, Computation.prototype.read.bind(this.q[j]));
+      this.s[j] = new Computation(j, null, pureOptions);
+      return this.O(() => item, Computation.prototype.read.bind(this.s[j]));
     } : () => {
       const item = newItems[j];
-      return this.P(() => item);
+      return this.O(() => item);
     };
     if (newLen === 0) {
-      if (this.o !== 0) {
+      if (this.q !== 0) {
         this.S.dispose(false);
         this.d = [];
         this.D = [];
         this.i = [];
-        this.o = 0;
-        this.p && (this.p = []);
-        this.q && (this.q = []);
+        this.q = 0;
+        this.r && (this.r = []);
+        this.s && (this.s = []);
       }
       if (this.T && !this.i[0]) {
         this.i[0] = compute(
@@ -2004,7 +2039,7 @@ function updateKeyedMap() {
           null
         );
       }
-    } else if (this.o === 0) {
+    } else if (this.q === 0) {
       if (this.d[0])
         this.d[0].dispose();
       this.i = new Array(newLen);
@@ -2012,37 +2047,37 @@ function updateKeyedMap() {
         this.D[j] = newItems[j];
         this.i[j] = compute(this.d[j] = new Owner(), mapper, null);
       }
-      this.o = newLen;
+      this.q = newLen;
     } else {
-      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.p ? new Array(newLen) : void 0, tempIndexes = this.q ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.o, newLen); start < end && (this.D[start] === newItems[start] || this.p && compare(this.Q, this.D[start], newItems[start])); start++) {
-        if (this.p)
-          this.p[start].write(newItems[start]);
+      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.r ? new Array(newLen) : void 0, tempIndexes = this.s ? new Array(newLen) : void 0;
+      for (start = 0, end = Math.min(this.q, newLen); start < end && (this.D[start] === newItems[start] || this.r && compare(this.P, this.D[start], newItems[start])); start++) {
+        if (this.r)
+          this.r[start].write(newItems[start]);
       }
-      for (end = this.o - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.D[end] === newItems[newEnd] || this.p && compare(this.Q, this.D[end], newItems[newEnd])); end--, newEnd--) {
+      for (end = this.q - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.D[end] === newItems[newEnd] || this.r && compare(this.P, this.D[end], newItems[newEnd])); end--, newEnd--) {
         temp[newEnd] = this.i[end];
         tempNodes[newEnd] = this.d[end];
-        tempRows && (tempRows[newEnd] = this.p[end]);
-        tempIndexes && (tempIndexes[newEnd] = this.q[end]);
+        tempRows && (tempRows[newEnd] = this.r[end]);
+        tempIndexes && (tempIndexes[newEnd] = this.s[end]);
       }
       newIndices = /* @__PURE__ */ new Map();
       newIndicesNext = new Array(newEnd + 1);
       for (j = newEnd; j >= start; j--) {
         item = newItems[j];
-        key = this.Q ? this.Q(item) : item;
+        key = this.P ? this.P(item) : item;
         i = newIndices.get(key);
         newIndicesNext[j] = i === void 0 ? -1 : i;
         newIndices.set(key, j);
       }
       for (i = start; i <= end; i++) {
         item = this.D[i];
-        key = this.Q ? this.Q(item) : item;
+        key = this.P ? this.P(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
           temp[j] = this.i[i];
           tempNodes[j] = this.d[i];
-          tempRows && (tempRows[j] = this.p[i]);
-          tempIndexes && (tempIndexes[j] = this.q[i]);
+          tempRows && (tempRows[j] = this.r[i]);
+          tempIndexes && (tempIndexes[j] = this.s[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
         } else
@@ -2053,18 +2088,18 @@ function updateKeyedMap() {
           this.i[j] = temp[j];
           this.d[j] = tempNodes[j];
           if (tempRows) {
-            this.p[j] = tempRows[j];
-            this.p[j].write(newItems[j]);
+            this.r[j] = tempRows[j];
+            this.r[j].write(newItems[j]);
           }
           if (tempIndexes) {
-            this.q[j] = tempIndexes[j];
-            this.q[j].write(j);
+            this.s[j] = tempIndexes[j];
+            this.s[j].write(j);
           }
         } else {
           this.i[j] = compute(this.d[j] = new Owner(), mapper, null);
         }
       }
-      this.i = this.i.slice(0, this.o = newLen);
+      this.i = this.i.slice(0, this.q = newLen);
       this.D = newItems.slice(0);
     }
   });
@@ -2073,26 +2108,26 @@ function updateKeyedMap() {
 function repeat(count, map, options) {
   return updateRepeat.bind({
     S: new Owner(),
-    o: 0,
-    y: 0,
-    ia: count,
-    P: map,
+    q: 0,
+    z: 0,
+    ja: count,
+    O: map,
     d: [],
     i: [],
-    ja: options?.from,
+    ka: options?.from,
     T: options?.fallback
   });
 }
 function updateRepeat() {
-  const newLen = this.ia();
-  const from = this.ja?.() || 0;
+  const newLen = this.ja();
+  const from = this.ka?.() || 0;
   runWithOwner(this.S, () => {
     if (newLen === 0) {
-      if (this.o !== 0) {
+      if (this.q !== 0) {
         this.S.dispose(false);
         this.d = [];
         this.i = [];
-        this.o = 0;
+        this.q = 0;
       }
       if (this.T && !this.i[0]) {
         this.i[0] = compute(
@@ -2104,20 +2139,20 @@ function updateRepeat() {
       return;
     }
     const to = from + newLen;
-    const prevTo = this.y + this.o;
-    if (this.o === 0 && this.d[0])
+    const prevTo = this.z + this.q;
+    if (this.q === 0 && this.d[0])
       this.d[0].dispose();
     for (let i = to; i < prevTo; i++)
-      this.d[i - this.y].dispose();
-    if (this.y < from) {
-      let i = this.y;
-      while (i < from && i < this.o)
+      this.d[i - this.z].dispose();
+    if (this.z < from) {
+      let i = this.z;
+      while (i < from && i < this.q)
         this.d[i++].dispose();
-      this.d.splice(0, from - this.y);
-      this.i.splice(0, from - this.y);
-    } else if (this.y > from) {
-      let i = prevTo - this.y - 1;
-      let difference = this.y - from;
+      this.d.splice(0, from - this.z);
+      this.i.splice(0, from - this.z);
+    } else if (this.z > from) {
+      let i = prevTo - this.z - 1;
+      let difference = this.z - from;
       this.d.length = this.i.length = newLen;
       while (i >= difference) {
         this.d[i] = this.d[i - difference];
@@ -2127,7 +2162,7 @@ function updateRepeat() {
       for (let i2 = 0; i2 < difference; i2++) {
         this.i[i2] = compute(
           this.d[i2] = new Owner(),
-          () => this.P(i2 + from),
+          () => this.O(i2 + from),
           null
         );
       }
@@ -2135,13 +2170,13 @@ function updateRepeat() {
     for (let i = prevTo; i < to; i++) {
       this.i[i - from] = compute(
         this.d[i - from] = new Owner(),
-        () => this.P(i),
+        () => this.O(i),
         null
       );
     }
     this.i = this.i.slice(0, newLen);
-    this.y = from;
-    this.o = newLen;
+    this.z = from;
+    this.q = newLen;
   });
   return this.i;
 }
@@ -2158,17 +2193,17 @@ var BoundaryComputation = class extends EagerComputation {
   }
   write(value, flags) {
     super.write(value, flags & ~this.U);
-    if (this.U & LOADING_BIT && !(this.g & UNINITIALIZED_BIT)) {
+    if (this.U & LOADING_BIT && !(this.h & UNINITIALIZED_BIT || ActiveTransition)) {
       flags &= ~LOADING_BIT;
     }
-    this.l.notify(this, this.U, flags);
-    return this.k;
+    this.m.notify(this, this.U, flags);
+    return this.l;
   }
 };
 function createBoundChildren(owner, fn, queue, mask) {
-  const parentQueue = owner.l;
-  parentQueue.addChild(owner.l = queue);
-  onCleanup(() => parentQueue.removeChild(owner.l));
+  const parentQueue = owner.m;
+  parentQueue.addChild(owner.m = queue);
+  onCleanup(() => parentQueue.removeChild(owner.m));
   return compute(
     owner,
     () => {
@@ -2179,27 +2214,27 @@ function createBoundChildren(owner, fn, queue, mask) {
   );
 }
 var ConditionalQueue = class extends Queue {
-  t;
+  u;
   V = /* @__PURE__ */ new Set();
-  s = /* @__PURE__ */ new Set();
+  t = /* @__PURE__ */ new Set();
   constructor(disabled) {
     super();
-    this.t = disabled;
+    this.u = disabled;
   }
   run(type) {
-    if (!type || this.t.read())
+    if (!type || this.u.read())
       return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (ActiveTransition && ActiveTransition.u.has(this))
-      return ActiveTransition.u.get(this).notify(node, type, flags);
-    if (this.t.read()) {
+    if (ActiveTransition && ActiveTransition.p.has(this))
+      return ActiveTransition.p.get(this).notify(node, type, flags);
+    if (this.u.read()) {
       if (type & LOADING_BIT) {
         if (flags & LOADING_BIT) {
-          this.s.add(node);
+          this.t.add(node);
           type &= ~LOADING_BIT;
-        } else if (this.s.delete(node))
+        } else if (this.t.delete(node))
           type &= ~LOADING_BIT;
       }
       if (type & ERROR_BIT) {
@@ -2213,43 +2248,43 @@ var ConditionalQueue = class extends Queue {
     return type ? super.notify(node, type, flags) : true;
   }
   merge(queue) {
-    queue.s.forEach((n) => this.notify(n, LOADING_BIT, LOADING_BIT));
+    queue.t.forEach((n) => this.notify(n, LOADING_BIT, LOADING_BIT));
     queue.V.forEach((n) => this.notify(n, ERROR_BIT, ERROR_BIT));
     super.merge(queue);
   }
 };
 var CollectionQueue = class extends Queue {
-  G;
+  F;
   d = /* @__PURE__ */ new Set();
-  t = new Computation(false, null, { pureWrite: true });
+  u = new Computation(false, null, { pureWrite: true });
   constructor(type) {
     super();
-    this.G = type;
+    this.F = type;
   }
   run(type) {
-    if (!type || this.t.read())
+    if (!type || this.u.read())
       return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (ActiveTransition && ActiveTransition.u.has(this))
-      return ActiveTransition.u.get(this).notify(node, type, flags);
-    if (!(type & this.G))
+    if (ActiveTransition && ActiveTransition.p.has(this))
+      return ActiveTransition.p.get(this).notify(node, type, flags);
+    if (!(type & this.F))
       return super.notify(node, type, flags);
-    if (flags & this.G) {
+    if (flags & this.F) {
       this.d.add(node);
       if (this.d.size === 1)
-        this.t.write(true);
-    } else {
+        this.u.write(true);
+    } else if (this.d.size > 0) {
       this.d.delete(node);
       if (this.d.size === 0)
-        this.t.write(false);
+        this.u.write(false);
     }
-    type &= ~this.G;
+    type &= ~this.F;
     return type ? super.notify(node, type, flags) : true;
   }
   merge(queue) {
-    queue.d.forEach((n) => this.notify(n, this.G, this.G));
+    queue.d.forEach((n) => this.notify(n, this.F, this.F));
     super.merge(queue);
   }
 };
@@ -2260,25 +2295,25 @@ function createBoundary(fn, condition) {
   );
   const tree = createBoundChildren(owner, fn, queue, 0);
   new EagerComputation(void 0, () => {
-    const disabled = queue.t.read();
+    const disabled = queue.u.read();
     tree.U = disabled ? ERROR_BIT | LOADING_BIT : 0;
     if (!disabled) {
-      queue.s.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
+      queue.t.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
       queue.V.forEach((node) => queue.notify(node, ERROR_BIT, ERROR_BIT));
-      queue.s.clear();
+      queue.t.clear();
       queue.V.clear();
     }
   });
-  return () => queue.t.read() ? void 0 : tree.read();
+  return () => queue.u.read() ? void 0 : tree.read();
 }
 function createCollectionBoundary(type, fn, fallback) {
   const owner = new Owner();
   const queue = new CollectionQueue(type);
   const tree = createBoundChildren(owner, fn, queue, type);
   const decision = new Computation(void 0, () => {
-    if (!queue.t.read()) {
+    if (!queue.u.read()) {
       const resolved = tree.read();
-      if (!queue.t.read())
+      if (!queue.u.read())
         return resolved;
     }
     return fallback(queue);
@@ -2290,15 +2325,14 @@ function createSuspense(fn, fallback) {
 }
 function createErrorBoundary(fn, fallback) {
   return createCollectionBoundary(ERROR_BIT, fn, (queue) => {
-    let node = queue.d.values().next().value;
-    ActiveTransition && ActiveTransition.a.has(node) && (node = ActiveTransition.a.get(node));
-    return fallback(node.L, () => {
+    let node = getTransitionSource(queue.d.values().next().value);
+    return fallback(node.J, () => {
       incrementClock();
       for (let node2 of queue.d) {
-        if (ActiveTransition && !node2.h)
+        if (ActiveTransition && !node2.e)
           node2 = cloneGraph(node2);
         node2.c = STATE_DIRTY;
-        node2.l?.enqueue(node2.A, node2.C.bind(node2));
+        node2.m?.enqueue(node2.B, node2.C.bind(node2));
       }
     });
   });