@solidjs/signals 0.0.1 → 0.0.3

package/dist/prod.js

@@ -46,30 +46,30 @@ 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
-  q = null;
-  l = null;
+  r = null;
+  m = null;
   o = null;
   a = STATE_CLEAN;
-  g = null;
-  m = defaultContext;
   h = null;
+  n = defaultContext;
+  i = null;
   e = null;
   constructor(signal = false) {
     if (currentOwner && !signal)
       currentOwner.append(this);
   }
   append(child) {
-    child.q = this;
+    child.r = this;
     child.o = this;
-    if (this.l)
-      this.l.o = child;
-    child.l = this.l;
-    this.l = child;
-    if (child.m !== this.m) {
-      child.m = { ...this.m, ...child.m };
+    if (this.m)
+      this.m.o = child;
+    child.m = this.m;
+    this.m = child;
+    if (child.n !== this.n) {
+      child.n = { ...this.n, ...child.n };
     }
-    if (this.h) {
-      child.h = !child.h ? this.h : [...child.h, ...this.h];
+    if (this.i) {
+      child.i = !child.i ? this.i : [...child.i, ...this.i];
     }
     if (this.e)
       child.e = this.e;
@@ -77,51 +77,51 @@ var Owner = class {
   dispose(self = true) {
     if (this.a === STATE_DISPOSED)
       return;
-    let head = self ? this.o || this.q : this, current = this.l, next = null;
-    while (current && current.q === this) {
+    let head = self ? this.o || this.r : this, current = this.m, next = null;
+    while (current && current.r === this) {
       current.dispose(true);
-      current.w();
-      next = current.l;
-      current.l = null;
+      current.x();
+      next = current.m;
+      current.m = null;
       current = next;
     }
     if (self)
-      this.w();
+      this.x();
     if (current)
       current.o = !self ? this : this.o;
     if (head)
-      head.l = current;
+      head.m = current;
   }
-  w() {
+  x() {
     if (this.o)
-      this.o.l = null;
-    this.q = null;
+      this.o.m = null;
+    this.r = null;
     this.o = null;
-    this.m = defaultContext;
-    this.h = null;
+    this.n = defaultContext;
+    this.i = null;
     this.a = STATE_DISPOSED;
     this.emptyDisposal();
   }
   emptyDisposal() {
-    if (!this.g)
+    if (!this.h)
       return;
-    if (Array.isArray(this.g)) {
-      for (let i = 0; i < this.g.length; i++) {
-        const callable = this.g[i];
+    if (Array.isArray(this.h)) {
+      for (let i = 0; i < this.h.length; i++) {
+        const callable = this.h[i];
         callable.call(callable);
       }
     } else {
-      this.g.call(this.g);
+      this.h.call(this.h);
     }
-    this.g = null;
+    this.h = null;
   }
   handleError(error) {
-    if (!this.h)
+    if (!this.i)
       throw error;
-    let i = 0, len = this.h.length;
+    let i = 0, len = this.i.length;
     for (i = 0; i < len; i++) {
       try {
-        this.h[i](error);
+        this.i[i](error);
         break;
       } catch (e) {
         error = e;
@@ -138,7 +138,7 @@ function getContext(context, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  const value = hasContext(context, owner) ? owner.m[context.id] : context.defaultValue;
+  const value = hasContext(context, owner) ? owner.n[context.id] : context.defaultValue;
   if (isUndefined(value)) {
     throw new ContextNotFoundError();
   }
@@ -148,24 +148,24 @@ function setContext(context, value, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  owner.m = {
-    ...owner.m,
+  owner.n = {
+    ...owner.n,
     [context.id]: isUndefined(value) ? context.defaultValue : value
   };
 }
 function hasContext(context, owner = currentOwner) {
-  return !isUndefined(owner?.m[context.id]);
+  return !isUndefined(owner?.n[context.id]);
 }
 function onCleanup(disposable) {
   if (!currentOwner)
     return;
   const node = currentOwner;
-  if (!node.g) {
-    node.g = disposable;
-  } else if (Array.isArray(node.g)) {
-    node.g.push(disposable);
+  if (!node.h) {
+    node.h = disposable;
+  } else if (Array.isArray(node.h)) {
+    node.h.push(disposable);
   } else {
-    node.g = [node.g, disposable];
+    node.h = [node.h, disposable];
   }
 }
 
@@ -196,37 +196,37 @@ var Computation = class extends Owner {
   b = null;
   c = null;
   d;
-  C;
+  D;
   // Used in __DEV__ mode, hopefully removed in production
-  U;
+  V;
   // Using false is an optimization as an alternative to _equals: () => false
   // which could enable more efficient DIRTY notification
-  D = isEqual;
+  E = isEqual;
   N;
   /** Whether the computation is an error or has ancestors that are unresolved */
-  i = 0;
+  j = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
   A = DEFAULT_FLAGS;
-  E = null;
   F = null;
-  G = -1;
+  G = null;
+  H = -1;
   constructor(initialValue, compute2, options) {
     super(compute2 === null);
-    this.C = compute2;
+    this.D = compute2;
     this.a = compute2 ? STATE_DIRTY : STATE_CLEAN;
     this.d = initialValue;
     if (options?.equals !== void 0)
-      this.D = options.equals;
+      this.E = options.equals;
     if (options?.unobserved)
       this.N = options?.unobserved;
   }
   O() {
-    if (this.C)
-      this.r();
+    if (this.D)
+      this.s();
     if (!this.b || this.b.length)
       track(this);
-    newFlags |= this.i & ~currentMask;
-    if (this.i & ERROR_BIT) {
+    newFlags |= this.j & ~currentMask;
+    if (this.j & ERROR_BIT) {
       throw this.d;
     } else {
       return this.d;
@@ -260,34 +260,34 @@ var Computation = class extends Owner {
    * loading state changes
    */
   loading() {
-    if (this.F === null) {
-      this.F = loadingState(this);
+    if (this.G === null) {
+      this.G = loadingState(this);
     }
-    return this.F.read();
+    return this.G.read();
   }
   /**
    * Return true if the computation is the computation threw an error
    * Triggers re-execution of the computation when the error state changes
    */
   error() {
-    if (this.E === null) {
-      this.E = errorState(this);
+    if (this.F === null) {
+      this.F = errorState(this);
     }
-    return this.E.read();
+    return this.F.read();
   }
   /** Update the computation with a new value. */
   write(value, flags = 0, raw = false) {
     const newValue = !raw && typeof value === "function" ? value(this.d) : value;
-    const valueChanged = newValue !== UNCHANGED && (!!(flags & ERROR_BIT) || this.D === false || !this.D(this.d, newValue));
+    const valueChanged = newValue !== UNCHANGED && (!!(flags & ERROR_BIT) || this.E === false || !this.E(this.d, newValue));
     if (valueChanged)
       this.d = newValue;
-    const changedFlagsMask = this.i ^ flags, changedFlags = changedFlagsMask & flags;
-    this.i = flags;
-    this.G = clock + 1;
+    const changedFlagsMask = this.j ^ flags, changedFlags = changedFlagsMask & flags;
+    this.j = flags;
+    this.H = clock + 1;
     if (this.c) {
       for (let i = 0; i < this.c.length; i++) {
         if (valueChanged) {
-          this.c[i].s(STATE_DIRTY);
+          this.c[i].t(STATE_DIRTY);
         } else if (changedFlagsMask) {
           this.c[i].P(changedFlagsMask, changedFlags);
         }
@@ -298,13 +298,13 @@ var Computation = class extends Owner {
   /**
    * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
    */
-  s(state) {
+  t(state) {
     if (this.a >= state)
       return;
     this.a = state;
     if (this.c) {
       for (let i = 0; i < this.c.length; i++) {
-        this.c[i].s(STATE_CHECK);
+        this.c[i].t(STATE_CHECK);
       }
     }
   }
@@ -318,17 +318,17 @@ var Computation = class extends Owner {
     if (this.a >= STATE_DIRTY)
       return;
     if (mask & this.A) {
-      this.s(STATE_DIRTY);
+      this.t(STATE_DIRTY);
       return;
     }
     if (this.a >= STATE_CHECK)
       return;
-    const prevFlags = this.i & mask;
+    const prevFlags = this.j & mask;
     const deltaFlags = prevFlags ^ newFlags2;
     if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
-      this.s(STATE_CHECK);
+      this.t(STATE_CHECK);
     } else {
-      this.i ^= deltaFlags;
+      this.j ^= deltaFlags;
       if (this.c) {
         for (let i = 0; i < this.c.length; i++) {
           this.c[i].P(mask, newFlags2);
@@ -337,7 +337,7 @@ var Computation = class extends Owner {
     }
   }
   Q(error) {
-    this.write(error, this.i | ERROR_BIT);
+    this.write(error, this.j | ERROR_BIT);
   }
   /**
    * This is the core part of the reactivity system, which makes sure that the values are updated
@@ -346,7 +346,7 @@ var Computation = class extends Owner {
    *
    * This function will ensure that the value and states we read from the computation are up to date
    */
-  r() {
+  s() {
     if (this.a === STATE_DISPOSED) {
       throw new Error("Tried to read a disposed computation");
     }
@@ -356,8 +356,8 @@ var Computation = class extends Owner {
     let observerFlags = 0;
     if (this.a === STATE_CHECK) {
       for (let i = 0; i < this.b.length; i++) {
-        this.b[i].r();
-        observerFlags |= this.b[i].i;
+        this.b[i].s();
+        observerFlags |= this.b[i].j;
         if (this.a === STATE_DIRTY) {
           break;
         }
@@ -373,23 +373,23 @@ var Computation = class extends Owner {
   /**
    * Remove ourselves from the owner graph and the computation graph
    */
-  w() {
+  x() {
     if (this.a === STATE_DISPOSED)
       return;
     if (this.b)
       removeSourceObservers(this, 0);
-    super.w();
+    super.x();
   }
 };
 function loadingState(node) {
-  const prevOwner = setOwner(node.q);
+  const prevOwner = setOwner(node.r);
   const options = void 0;
   const computation = new Computation(
     void 0,
     () => {
       track(node);
-      node.r();
-      return !!(node.i & LOADING_BIT);
+      node.s();
+      return !!(node.j & LOADING_BIT);
     },
     options
   );
@@ -398,14 +398,14 @@ function loadingState(node) {
   return computation;
 }
 function errorState(node) {
-  const prevOwner = setOwner(node.q);
+  const prevOwner = setOwner(node.r);
   const options = void 0;
   const computation = new Computation(
     void 0,
     () => {
       track(node);
-      node.r();
-      return !!(node.i & ERROR_BIT);
+      node.s();
+      return !!(node.j & ERROR_BIT);
     },
     options
   );
@@ -423,7 +423,7 @@ function track(computation) {
       newSources.push(computation);
     }
     if (updateCheck) {
-      updateCheck.d = computation.G > currentObserver.G;
+      updateCheck.d = computation.H > currentObserver.H;
     }
   }
 }
@@ -435,7 +435,7 @@ function update(node) {
   try {
     node.dispose(false);
     node.emptyDisposal();
-    const result = compute(node, node.C, node);
+    const result = compute(node, node.D, node);
     node.write(result, newFlags, true);
   } catch (error) {
     if (error instanceof NotReadyError) {
@@ -546,50 +546,50 @@ function schedule() {
   queueMicrotask(flushSync);
 }
 var Queue = class {
-  H = false;
-  t = [[], [], []];
-  y = [];
+  I = false;
+  u = [[], [], []];
+  z = [];
   enqueue(type, node) {
-    this.t[0].push(node);
+    this.u[0].push(node);
     if (type)
-      this.t[type].push(node);
+      this.u[type].push(node);
     schedule();
   }
   run(type) {
-    if (this.t[type].length) {
+    if (this.u[type].length) {
       if (type === EFFECT_PURE) {
-        runPureQueue(this.t[type]);
-        this.t[type] = [];
+        runPureQueue(this.u[type]);
+        this.u[type] = [];
       } else {
-        const effects = this.t[type];
-        this.t[type] = [];
+        const effects = this.u[type];
+        this.u[type] = [];
         runEffectQueue(effects);
       }
     }
-    for (let i = 0; i < this.y.length; i++) {
-      this.y[i].run(type);
+    for (let i = 0; i < this.z.length; i++) {
+      this.z[i].run(type);
     }
   }
   flush() {
-    if (this.H)
+    if (this.I)
       return;
-    this.H = true;
+    this.I = true;
     try {
       this.run(EFFECT_PURE);
       incrementClock();
       this.run(EFFECT_RENDER);
       this.run(EFFECT_USER);
     } finally {
-      this.H = false;
+      this.I = false;
     }
   }
   addChild(child) {
-    this.y.push(child);
+    this.z.push(child);
   }
   removeChild(child) {
-    const index = this.y.indexOf(child);
+    const index = this.z.indexOf(child);
     if (index >= 0)
-      this.y.splice(index, 1);
+      this.z.splice(index, 1);
   }
 };
 var globalQueue = new Queue();
@@ -606,14 +606,14 @@ function createBoundary(fn, queue) {
 }
 function runTop(node) {
   const ancestors = [];
-  for (let current = node; current !== null; current = current.q) {
+  for (let current = node; current !== null; current = current.r) {
     if (current.a !== STATE_CLEAN) {
       ancestors.push(current);
     }
   }
   for (let i = ancestors.length - 1; i >= 0; i--) {
     if (ancestors[i].a !== STATE_DISPOSED)
-      ancestors[i].r();
+      ancestors[i].s();
   }
 }
 function runPureQueue(queue) {
@@ -623,57 +623,59 @@ function runPureQueue(queue) {
   }
 }
 function runEffectQueue(queue) {
-  for (let i = 0; i < queue.length; i++) {
-    if (queue[i].I && queue[i].a !== STATE_DISPOSED) {
-      queue[i].J(queue[i].d, queue[i].B);
-      queue[i].I = false;
-      queue[i].B = queue[i].d;
-    }
-  }
+  for (let i = 0; i < queue.length; i++)
+    queue[i].R();
 }
 
 // src/core/effect.ts
 var Effect = class extends Computation {
   J;
-  I = false;
+  K = false;
   B;
-  K;
+  C;
   e;
   constructor(initialValue, compute2, effect, options) {
     super(initialValue, compute2, options);
     this.J = effect;
     this.B = initialValue;
-    this.K = options?.render ? EFFECT_RENDER : EFFECT_USER;
+    this.C = options?.render ? EFFECT_RENDER : EFFECT_USER;
     this.e = getOwner()?.e || globalQueue;
-    this.e.enqueue(this.K, this);
-    this.r();
+    this.s();
+    this.C === EFFECT_USER ? this.e.enqueue(this.C, this) : this.R();
   }
   write(value, flags = 0) {
-    const currentFlags = this.i;
-    this.i = flags;
+    const currentFlags = this.j;
+    this.j = flags;
     if ((flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
-      this.e.S?.(this);
+      this.e.T?.(this);
     }
     if (value === UNCHANGED)
       return this.d;
     this.d = value;
-    this.I = true;
+    this.K = true;
     return value;
   }
-  s(state) {
+  t(state) {
     if (this.a >= state)
       return;
     if (this.a === STATE_CLEAN)
-      this.e.enqueue(this.K, this);
+      this.e.enqueue(this.C, this);
     this.a = state;
   }
   Q(error) {
     this.handleError(error);
   }
-  w() {
+  x() {
     this.J = void 0;
     this.B = void 0;
-    super.w();
+    super.x();
+  }
+  R() {
+    if (this.K && this.a !== STATE_DISPOSED) {
+      this.J(this.d, this.B);
+      this.B = this.d;
+      this.K = false;
+    }
   }
 };
 var EagerComputation = class extends Computation {
@@ -681,38 +683,38 @@ var EagerComputation = class extends Computation {
   constructor(initialValue, compute2, options) {
     super(initialValue, compute2, options);
     this.e = getOwner()?.e || globalQueue;
-    this.r();
+    this.s();
   }
-  s(state) {
+  t(state) {
     if (this.a >= state)
       return;
     if (this.a === STATE_CLEAN)
       this.e.enqueue(EFFECT_PURE, this);
-    super.s(state);
+    super.t(state);
   }
 };
 
 // src/core/suspense.ts
 var SuspenseQueue = class extends Queue {
-  k = /* @__PURE__ */ new Set();
-  z = false;
+  f = /* @__PURE__ */ new Set();
+  p = false;
   L = new Computation(false, null);
   run(type) {
-    if (type && this.z)
+    if (type && this.p)
       return;
     super.run(type);
   }
-  S(node) {
-    if (node.i & LOADING_BIT) {
-      this.k.add(node);
-      if (!this.z) {
-        this.z = true;
+  T(node) {
+    if (node.j & LOADING_BIT) {
+      this.f.add(node);
+      if (!this.p) {
+        this.p = true;
         queueMicrotask(() => this.L.write(true));
       }
     } else {
-      this.k.delete(node);
-      if (this.k.size === 0) {
-        this.z = false;
+      this.f.delete(node);
+      if (this.f.size === 0) {
+        this.p = false;
         queueMicrotask(() => this.L.write(false));
       }
     }
@@ -721,7 +723,7 @@ var SuspenseQueue = class extends Queue {
 function createSuspense(fn, fallbackFn) {
   const queue = new SuspenseQueue();
   const tree = createBoundary(fn, queue);
-  const equality = new Computation(null, () => queue.L.read() || queue.z);
+  const equality = new Computation(null, () => queue.L.read() || queue.p);
   const comp = new Computation(null, () => equality.read() ? untrack(fallbackFn) : tree);
   return comp.read.bind(comp);
 }
@@ -831,7 +833,7 @@ function runWithOwner(owner, run) {
 }
 function catchError(fn, handler) {
   const owner = new Owner();
-  owner.h = owner.h ? [handler, ...owner.h] : [handler];
+  owner.i = owner.i ? [handler, ...owner.i] : [handler];
   try {
     compute(owner, fn, null);
   } catch (error) {
@@ -849,15 +851,22 @@ var STORE_NODE = "n";
 var STORE_HAS = "h";
 function wrap(value) {
   let p = value[$PROXY];
-  if (!p)
+  if (!p) {
+    let target;
+    if (Array.isArray(value)) {
+      target = [];
+      target.v = value;
+    } else
+      target = { v: value };
     Object.defineProperty(value, $PROXY, {
-      value: p = new Proxy({ v: value }, proxyTraps),
+      value: p = new Proxy(target, proxyTraps),
       writable: true
     });
+  }
   return p;
 }
 function isWrappable(obj) {
-  return obj != null && typeof obj === "object";
+  return obj != null && typeof obj === "object" && !Object.isFrozen(obj);
 }
 function unwrap(item, deep = true, set) {
   let result, unwrapped, v, prop;
@@ -909,8 +918,10 @@ function getNode(nodes, property, value, equals = isEqual) {
   });
 }
 function proxyDescriptor(target, property) {
+  if (property === $PROXY)
+    return { value: target[$PROXY], writable: true, configurable: true };
   const desc = Reflect.getOwnPropertyDescriptor(target[STORE_VALUE], property);
-  if (!desc || desc.get || !desc.configurable || property === $PROXY)
+  if (!desc || desc.get || !desc.configurable)
     return desc;
   delete desc.value;
   delete desc.writable;
@@ -976,7 +987,10 @@ var proxyTraps = {
     return true;
   },
   ownKeys,
-  getOwnPropertyDescriptor: proxyDescriptor
+  getOwnPropertyDescriptor: proxyDescriptor,
+  getPrototypeOf(target) {
+    return Object.getPrototypeOf(target[STORE_VALUE]);
+  }
 };
 function setProperty(state, property, value, deleting = false) {
   const prev = state[property];
@@ -1130,6 +1144,7 @@ function reconcile(value, key) {
     if (keyFn(value) !== keyFn(state))
       throw new Error("Cannot reconcile states with different identity");
     applyState(value, state, keyFn);
+    return state;
   };
 }
 
@@ -1170,7 +1185,7 @@ function resolveSource(s) {
 }
 var $SOURCES = Symbol(0);
 function merge(...sources) {
-  if (sources.length === 1)
+  if (sources.length === 1 && typeof sources[0] !== "function")
     return sources[0];
   let proxy = false;
   const flattened = [];
@@ -1284,120 +1299,120 @@ function omit(props, ...keys) {
 // src/map.ts
 function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
-  return Computation.prototype.read.bind(
-    new Computation(
-      [],
-      updateKeyedMap.bind({
-        R: new Owner(),
-        u: 0,
-        T: list,
-        p: [],
-        M: map,
-        n: [],
-        k: [],
-        x: keyFn,
-        f: keyFn || options?.keyed === false ? [] : void 0,
-        j: map.length > 1 ? [] : void 0
-      }),
-      options
-    )
-  );
+  return updateKeyedMap.bind({
+    S: new Owner(),
+    w: 0,
+    U: list,
+    q: [],
+    M: map,
+    k: [],
+    f: [],
+    y: keyFn,
+    g: keyFn || options?.keyed === false ? [] : void 0,
+    l: map.length > 1 ? [] : void 0,
+    p: options?.fallback
+  });
 }
 function updateKeyedMap() {
-  const newItems = this.T() || [], newLen = newItems.length;
+  const newItems = this.U() || [], newLen = newItems.length;
   newItems[$TRACK];
-  runWithOwner(this.R, () => {
-    let i, j, mapper = this.f ? () => {
-      this.f[j] = new Computation(newItems[j], null);
-      this.j[j] = new Computation(j, null);
+  runWithOwner(this.S, () => {
+    let i, j, mapper = this.g ? () => {
+      this.g[j] = new Computation(newItems[j], null);
+      this.l[j] = new Computation(j, null);
       return this.M(
-        Computation.prototype.read.bind(this.f[j]),
-        Computation.prototype.read.bind(this.j[j])
+        Computation.prototype.read.bind(this.g[j]),
+        Computation.prototype.read.bind(this.l[j])
       );
-    } : this.j ? () => {
+    } : this.l ? () => {
       const item = newItems[j];
-      this.j[j] = new Computation(j, null);
-      return this.M(() => item, Computation.prototype.read.bind(this.j[j]));
+      this.l[j] = new Computation(j, null);
+      return this.M(() => item, Computation.prototype.read.bind(this.l[j]));
     } : () => {
       const item = newItems[j];
       return this.M(() => item);
     };
     if (newLen === 0) {
-      if (this.u !== 0) {
-        this.R.dispose(false);
+      if (this.w !== 0) {
+        this.S.dispose(false);
+        this.f = [];
+        this.q = [];
         this.k = [];
-        this.p = [];
-        this.n = [];
-        this.u = 0;
-        this.f && (this.f = []);
-        this.j && (this.j = []);
+        this.w = 0;
+        this.g && (this.g = []);
+        this.l && (this.l = []);
+      }
+      if (this.p && !this.k[0]) {
+        this.k[0] = compute(this.f[0] = new Owner(), this.p, null);
       }
-    } else if (this.u === 0) {
-      this.n = new Array(newLen);
+    } else if (this.w === 0) {
+      if (this.f[0])
+        this.f[0].dispose();
+      this.k = new Array(newLen);
       for (j = 0; j < newLen; j++) {
-        this.p[j] = newItems[j];
-        this.n[j] = compute(this.k[j] = new Owner(), mapper, null);
+        this.q[j] = newItems[j];
+        this.k[j] = compute(this.f[j] = new Owner(), mapper, null);
       }
-      this.u = newLen;
+      this.w = newLen;
     } else {
-      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.f ? new Array(newLen) : void 0, tempIndexes = this.j ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.u, newLen); start < end && (this.p[start] === newItems[start] || this.f && compare(this.x, this.p[start], newItems[start])); start++) {
-        if (this.f)
-          this.f[start].write(newItems[start]);
+      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.g ? new Array(newLen) : void 0, tempIndexes = this.l ? new Array(newLen) : void 0;
+      for (start = 0, end = Math.min(this.w, newLen); start < end && (this.q[start] === newItems[start] || this.g && compare(this.y, this.q[start], newItems[start])); start++) {
+        if (this.g)
+          this.g[start].write(newItems[start]);
       }
-      for (end = this.u - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.p[end] === newItems[newEnd] || this.f && compare(this.x, this.p[end], newItems[newEnd])); end--, newEnd--) {
-        temp[newEnd] = this.n[end];
-        tempNodes[newEnd] = this.k[end];
-        tempRows && (tempRows[newEnd] = this.f[end]);
-        tempIndexes && (tempIndexes[newEnd] = this.j[end]);
+      for (end = this.w - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.q[end] === newItems[newEnd] || this.g && compare(this.y, this.q[end], newItems[newEnd])); end--, newEnd--) {
+        temp[newEnd] = this.k[end];
+        tempNodes[newEnd] = this.f[end];
+        tempRows && (tempRows[newEnd] = this.g[end]);
+        tempIndexes && (tempIndexes[newEnd] = this.l[end]);
       }
       newIndices = /* @__PURE__ */ new Map();
       newIndicesNext = new Array(newEnd + 1);
       for (j = newEnd; j >= start; j--) {
         item = newItems[j];
-        key = this.x ? this.x(item) : item;
+        key = this.y ? this.y(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.p[i];
-        key = this.x ? this.x(item) : item;
+        item = this.q[i];
+        key = this.y ? this.y(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
-          temp[j] = this.n[i];
-          tempNodes[j] = this.k[i];
-          tempRows && (tempRows[j] = this.f[i]);
-          tempIndexes && (tempIndexes[j] = this.j[i]);
+          temp[j] = this.k[i];
+          tempNodes[j] = this.f[i];
+          tempRows && (tempRows[j] = this.g[i]);
+          tempIndexes && (tempIndexes[j] = this.l[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
         } else
-          this.k[i].dispose();
+          this.f[i].dispose();
       }
       for (j = start; j < newLen; j++) {
         if (j in temp) {
-          this.n[j] = temp[j];
-          this.k[j] = tempNodes[j];
+          this.k[j] = temp[j];
+          this.f[j] = tempNodes[j];
           if (tempRows) {
-            this.f[j] = tempRows[j];
-            this.f[j].write(newItems[j]);
+            this.g[j] = tempRows[j];
+            this.g[j].write(newItems[j]);
           }
           if (tempIndexes) {
-            this.j[j] = tempIndexes[j];
-            this.j[j].write(j);
+            this.l[j] = tempIndexes[j];
+            this.l[j].write(j);
           }
         } else {
-          this.n[j] = compute(this.k[j] = new Owner(), mapper, null);
+          this.k[j] = compute(this.f[j] = new Owner(), mapper, null);
         }
       }
-      this.n = this.n.slice(0, this.u = newLen);
-      this.p = newItems.slice(0);
+      this.k = this.k.slice(0, this.w = newLen);
+      this.q = newItems.slice(0);
     }
   });
-  return this.n;
+  return this.k;
 }
 function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
 }
 
-export { $PROXY, $RAW, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, catchError, createAsync, createBoundary, createContext, createEffect, createMemo, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, runWithOwner, setContext, untrack, unwrap };
+export { $PROXY, $RAW, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, catchError, createAsync, createBoundary, createContext, createEffect, createMemo, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, runWithOwner, setContext, untrack, unwrap };