@solidjs/signals 2.0.0-rc.8 → 2.0.0-rc.9

package/dist/observe/store/index.js

@@ -1,5 +1,7 @@
 import "../core/core.js";
 
+import "../core/dev.js";
+
 import "../core/scheduler.js";
 
 import "../core/invariants.js";

package/dist/observe/store/next/optimistic.js

@@ -1,6 +1,6 @@
 import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, STATUS_UNINITIALIZED, NOT_PENDING, CONFIG_OPTIMISTIC, CONFIG_HELD_TRUTH, unwrapOverride } from "../../core/constants.js";
 
-import { computed, setSignal, isEqual } from "../../core/core.js";
+import { computed, hasActiveOverride, setSignal, isEqual, visibleOverride } from "../../core/core.js";
 
 import { getOwner } from "../../core/owner.js";
 
@@ -8,6 +8,8 @@ import { activeTransition, GlobalQueue, currentTransition, globalQueue, createTr
 
 import "../../core/invariants.js";
 
+import "../../core/dev.js";
+
 import "../../core/verdict.js";
 
 import "../../core/effect.js";
@@ -18,7 +20,7 @@ import { $TARGET, markRawIngest, setNextOptimisticViewResolver, isWrappable, raw
 
 import { runProjectionComputedNext } from "./projection.js";
 
-import { wrapNext, runAuthoritative, storeSetterNext, hasActiveOverride, unwrapValue, targetsEqual, heldMaskView, getNode, getHasNode, getKeySetNode, bumpDeep, stagedTruthPB, authoritativeRead } from "./store.js";
+import { wrapNext, runAuthoritative, storeSetterNext, unwrapValue, targetsEqual, heldMaskView, getNode, getHasNode, getKeySetNode, bumpDeep, stagedTruthPB, authoritativeRead } from "./store.js";
 
 import { sameKey } from "./reconcile.js";
 
@@ -55,7 +57,7 @@ import { setOptHooks, $OWNER, lookupTarget } from "./target.js";
  * staged values to converge (normal speculation). Resolves merges first:
  * merge unions optimistic nodes/stores into the target. */ function transitionHoldsOptimism(e) {
     const t = currentTransition(e);
-    return t.Ut !== true && (t.en.length !== 0 || t.nn.size !== 0);
+    return t.yt !== true && (t.tn.length !== 0 || t.rn.size !== 0);
 }
 
 let blockedInstalled = false;
@@ -72,12 +74,15 @@ function installNextBlockedHalf() {
         applyTentative: applyTentative,
         retainsOptimism: transitionHoldsOptimism
     });
-    setNextOptimisticViewResolver((e, t) => optimisticView(e, t));
+    // The affects() declaration walk is a WRITER channel (A28 (5)): tagging a
+    // parent covers the record as the writer sees it, this tick's optimistic
+    // writes included — the draft view, not the reader view.
+        setNextOptimisticViewResolver((e, t) => optimisticView(e, t, true));
     // Scheduler flush tails call _clearOptimisticStores whenever tracked
     // stores exist; next has no layer to clear — reverts are engine-native —
     // so the hook only empties the batch set.
-        if (!GlobalQueue.ri) {
-        GlobalQueue.ri = e => {
+        if (!GlobalQueue.zn) {
+        GlobalQueue.zn = e => {
             for (const t of e) {
                 const e = t?.[$TARGET];
                 const n = e?.fam?.overlaid;
@@ -96,24 +101,24 @@ function installNextBlockedHalf() {
             e.clear();
         };
     }
-    const e = GlobalQueue.Pn;
-    GlobalQueue.Pn = t => {
-        for (const e of t.nn) {
+    const e = GlobalQueue.kn;
+    GlobalQueue.kn = t => {
+        for (const e of t.rn) {
             const n = e?.[$TARGET];
             const i = n?.fam;
-            const o = i?.node;
+            const r = i?.node;
             // The hold exists to keep optimistic state alive until the store's own
             // truth lands (#2951). Once the family carries NO live overrides (a
             // landing consumed them, or they never existed), a pending firewall is
             // no reason to park the transaction — blocking then leaks it forever
             // when the in-flight question is never answered (undisposed fixtures).
-                        if (o == null || !(o.S & STATUS_PENDING)) continue;
+                        if (r == null || !(r.S & STATUS_PENDING)) continue;
             // Ownership is declared (#3146): only the flight's OWN transaction
             // parks on the flight (the #2951 anchor routed the bare write there).
             // A transaction that merely brushed the store never waits for truth
             // it does not carry.
-                        const r = i.ft != null ? liveTransition(i.ft) : null;
-            if (r !== null && r !== currentTransition(t)) continue;
+                        const o = i.ft != null ? liveTransition(i.ft) : null;
+            if (o !== null && o !== currentTransition(t)) continue;
             if (familyHasLiveOverrides(i)) return true;
         }
         return e(t);
@@ -128,10 +133,10 @@ function familyHasLiveOverrides(e) {
             if (t === null) continue;
             for (const e of Reflect.ownKeys(t)) {
                 const n = t[e];
-                if (n.o?.De !== undefined && n.o?.De !== NOT_PENDING) return true;
+                if (n.o?.Ne !== undefined && n.o?.Ne !== NOT_PENDING) return true;
             }
         }
-        if (e.k !== null && e.k.o?.De !== undefined && e.k.o?.De !== NOT_PENDING) return true;
+        if (e.k !== null && e.k.o?.Ne !== undefined && e.k.o?.Ne !== NOT_PENDING) return true;
     }
     t.clear();
  // nothing live — drop the bookkeeping
@@ -144,23 +149,23 @@ function createOptimisticStoreNext(e, t, n) {
     installOptimisticEngine();
     installNextBlockedHalf();
     const i = typeof e === "function";
-    const o = i ? n : t;
-    const r = i ? t : e;
+    const r = i ? n : t;
+    const o = i ? t : e;
     const s = {
         map: new WeakMap,
         node: null,
-        shallow: !!o?.shallow,
+        shallow: !!r?.shallow,
         opt: true
     };
-    const l = wrapNext(r, null, null, s);
+    const l = wrapNext(o, null, null, s);
     s.px = l;
     // Same key resolution the projection channels use ("id" default) — replay's
     // satisfaction rule reads it off the family.
-        const u = o?.key === undefined ? "id" : o.key;
+        const u = r?.key === undefined ? "id" : r.key;
     s.key = typeof u === "function" ? u : u === null ? null : e => isWrappable(e) ? e[u] : undefined;
     if (s.shallow) {
         l[$TARGET].s = true;
-        markRawIngest(r);
+        markRawIngest(o);
     }
     if (i) {
         const t = e;
@@ -178,7 +183,7 @@ function createOptimisticStoreNext(e, t, n) {
             if (e == null) return;
             let t = liveTransition(e);
             if (t === null) s.ft = t = createTransition();
-            s.node.Ee = t;
+            s.node.Te = t;
             globalQueue.initTransition(t);
         };
         // Landing router (#3164 fold ruling): while a transaction retains
@@ -223,8 +228,8 @@ function createOptimisticStoreNext(e, t, n) {
         // (#2933: the loading rail is transaction-invisible); a sync run clears
         // the declaration.
                 const declareFlight = e => {
-            if (e.o?.Se == null) {
-                if (!e.de) s.ft = null;
+            if (e.o?.ce == null) {
+                if (!e.Se) s.ft = null;
                 return;
             }
             // First flight (#3146 carve-out): nothing has ever committed, so there
@@ -236,32 +241,32 @@ function createOptimisticStoreNext(e, t, n) {
             // fallback never showed and the whole page stayed blank. The loading
             // window (#2933) already declares nothing for the same reason; once
             // the first truth lands, every refetch flight declares as before.
-                        if (e.de || e.S & STATUS_UNINITIALIZED) return;
+                        if (e.Se || e.S & STATUS_UNINITIALIZED) return;
             let t = activeTransition;
             if (t === null) globalQueue.initTransition(t = createTransition());
             s.ft = t;
-            e.Ee = t;
-            let n = t.Ie.get(e);
-            if (n === undefined) t.Ie.set(e, n = new Set);
+            e.Te = t;
+            let n = t.ot.get(e);
+            if (n === undefined) t.ot.set(e, n = new Set);
             n.add(e);
         };
         let n;
-        if (o?.seedLoadingValue) n = {
+        if (r?.seedLoadingValue) n = {
             loadingValue: undefined
         };
-        if (o?.name) n = {
+        if (r?.name) n = {
             ...n,
-            name: o.name
+            name: r.name
         };
         const i = computed(() => {
             const e = getOwner();
             try {
-                runAuthoritative(() => runProjectionComputedNext(l, t, o?.key === undefined ? "id" : o.key, wrapCommit, aroundDraftWrite));
+                runAuthoritative(() => runProjectionComputedNext(l, t, r?.key === undefined ? "id" : r.key, wrapCommit, aroundDraftWrite));
             } finally {
                 declareFlight(e);
             }
         }, n);
-        i.T &= ~CONFIG_AUTO_DISPOSE;
+        i.C &= ~CONFIG_AUTO_DISPOSE;
         s.node = i;
     }
     return [ l, e => {
@@ -278,8 +283,8 @@ function createOptimisticStoreNext(e, t, n) {
 
 /** Resolve a retained transition through its merge chain (`_done` holds the
  * merge target while merged, `true` once settled). Null = dead. */ function liveTransition(e) {
-    while (typeof e.Ut === "object") e = e.Ut;
-    return e.Ut === true ? null : e;
+    while (typeof e.yt === "object") e = e.yt;
+    return e.yt === true ? null : e;
 }
 
 /** The transaction truth landings fold into: the first live member of the
@@ -324,11 +329,11 @@ function createOptimisticStoreNext(e, t, n) {
  * stay unarmed — the override is their display and its revert their
  * notification, A17). */ function runFolded(e, t) {
     runAsTransitionBatch(e, t);
-    const n = e.tn;
+    const n = e.sn;
     for (let t = 0; t < n.length; t++) {
         const i = n[t];
-        i.Ee = e;
-        if (i.T & CONFIG_OPTIMISTIC && !hasActiveOverride(i)) i.T |= CONFIG_HELD_TRUTH;
+        i.Te = e;
+        if (i.C & CONFIG_OPTIMISTIC && !hasActiveOverride(i)) i.C |= CONFIG_HELD_TRUTH;
     }
 }
 
@@ -344,15 +349,15 @@ function createOptimisticStoreNext(e, t, n) {
         if (n !== null) {
             // Occurrence-aware key queues (parity with the adoption window):
             // duplicate keys match per occurrence, each current row consumed once.
-            let o = null;
-            const r = e.length;
-            for (let t = 0; t < r; t++) {
+            let r = null;
+            const o = e.length;
+            for (let t = 0; t < o; t++) {
                 const i = unwrapValue(e[t]);
                 if (!isWrappable(i)) continue;
-                const r = n(i);
-                if (r === undefined) continue;
-                const s = (o ??= new Map).get(r);
-                if (s === undefined) o.set(r, [ i ]); else s.push(i);
+                const o = n(i);
+                if (o === undefined) continue;
+                const s = (r ??= new Map).get(o);
+                if (s === undefined) r.set(o, [ i ]); else s.push(i);
             }
             // Echo adoption: an optimistic structural add whose key the landing
             // confirms must keep its raw (and so its proxy — list drivers keep the
@@ -367,42 +372,42 @@ function createOptimisticStoreNext(e, t, n) {
                 for (const e of Reflect.ownKeys(s)) {
                     const t = s[e];
                     if (!hasActiveOverride(t)) continue;
-                    const i = unwrapValue(unwrapOverride(t.o.De));
+                    const i = unwrapValue(unwrapOverride(t.o.Ne));
                     if (!isWrappable(i)) continue;
-                    const r = n(i);
-                    if (r === undefined) continue;
-                    const l = (o ??= new Map).get(r);
-                    if (l === undefined) o.set(r, [ i ]); else l.push(i);
+                    const o = n(i);
+                    if (o === undefined) continue;
+                    const l = (r ??= new Map).get(o);
+                    if (l === undefined) r.set(o, [ i ]); else l.push(i);
                 }
             }
-            for (let r = 0; r < i; r++) {
-                const i = t[r];
+            for (let o = 0; o < i; o++) {
+                const i = t[o];
                 let s;
-                if (isWrappable(i) && o !== null) {
+                if (isWrappable(i) && r !== null) {
                     const e = n(i);
                     if (e !== undefined) {
-                        for (const [t, n] of o) {
+                        for (const [t, n] of r) {
                             if (!sameKey(t, e)) continue;
                             s = n.shift();
-                            if (n.length === 0) o.delete(t);
+                            if (n.length === 0) r.delete(t);
                             break;
                         }
                     }
                 }
                 if (s !== undefined) {
-                    if (unwrapValue(e[r]) !== s) e[r] = s;
-                    stagedApply(e[r], i, n);
+                    if (unwrapValue(e[o]) !== s) e[o] = s;
+                    stagedApply(e[o], i, n);
                 } else {
-                    const t = unwrapValue(e[r]);
-                    if (!isEqual(t, i) && !targetsEqual(t, i)) e[r] = i;
+                    const t = unwrapValue(e[o]);
+                    if (!isEqual(t, i) && !targetsEqual(t, i)) e[o] = i;
                 }
             }
         } else {
-            for (let o = 0; o < i; o++) {
-                const i = t[o];
-                const r = unwrapValue(e[o]);
-                if (r === i) continue;
-                if (isWrappable(i) && isWrappable(r) && Array.isArray(i) === Array.isArray(r)) stagedApply(e[o], i, n); else if (!isEqual(r, i) && !targetsEqual(r, i)) e[o] = i;
+            for (let r = 0; r < i; r++) {
+                const i = t[r];
+                const o = unwrapValue(e[r]);
+                if (o === i) continue;
+                if (isWrappable(i) && isWrappable(o) && Array.isArray(i) === Array.isArray(o)) stagedApply(e[r], i, n); else if (!isEqual(o, i) && !targetsEqual(o, i)) e[r] = i;
             }
         }
         if (e.length !== i) e.length = i;
@@ -410,25 +415,25 @@ function createOptimisticStoreNext(e, t, n) {
     }
     // Object merge; also the degenerate root-kind-change shape (arrays accept
     // keyed writes/deletes, so a wholesale restatement still lands staged).
-        for (const o of Reflect.ownKeys(t)) {
-        if (i && o === "length" || o === $OWNER) continue;
-        const r = t[o];
-        const s = unwrapValue(e[o]);
-        if (s === r) continue;
-        if (isWrappable(r) && isWrappable(s) && Array.isArray(r) === Array.isArray(s)) {
+        for (const r of Reflect.ownKeys(t)) {
+        if (i && r === "length" || r === $OWNER) continue;
+        const o = t[r];
+        const s = unwrapValue(e[r]);
+        if (s === o) continue;
+        if (isWrappable(o) && isWrappable(s) && Array.isArray(o) === Array.isArray(s)) {
             // Different-keyed entities never merge (tentative-channel parity):
             // the incoming object replaces the slot wholesale.
             if (n !== null) {
                 const t = n(s);
-                const i = n(r);
+                const i = n(o);
                 if (t !== undefined && i !== undefined && !sameKey(t, i)) {
-                    e[o] = r;
+                    e[r] = o;
                     continue;
                 }
             }
-            stagedApply(e[o], r, n);
-        } else if (!isEqual(s, r) && !targetsEqual(s, r)) {
-            e[o] = r;
+            stagedApply(e[r], o, n);
+        } else if (!isEqual(s, o) && !targetsEqual(s, o)) {
+            e[r] = o;
         }
     }
     for (const n of Reflect.ownKeys(e)) {
@@ -472,46 +477,46 @@ function createOptimisticStoreNext(e, t, n) {
     // churned for the life of the action and snapped back at settle (#3323).
         const visible = (t, n) => {
         const i = e.n?.[t];
-        return unwrapValue(i !== undefined && hasActiveOverride(i) ? unwrapOverride(i.o?.De) : n);
+        return unwrapValue(i !== undefined && hasActiveOverride(i) ? unwrapOverride(i.o?.Ne) : n);
     };
     const visiblePresent = t => {
         const n = e.h?.[t];
-        return n !== undefined && hasActiveOverride(n) ? !!unwrapOverride(n.o?.De) : t in i;
+        return n !== undefined && hasActiveOverride(n) ? !!unwrapOverride(n.o?.Ne) : t in i;
     };
-    let o = false;
-    const r = Array.isArray(t);
+    let r = false;
+    const o = Array.isArray(t);
     for (const n of Reflect.ownKeys(t)) {
-        if (r && n === "length" || n === $OWNER) continue;
+        if (o && n === "length" || n === $OWNER) continue;
         const s = unwrapValue(t[n]);
         if (!visiblePresent(n)) {
             // Optimistic add: value node + presence node + membership bump.
             setSignal(getNode(e, n, i[n]), () => s);
             setSignal(getHasNode(e, n, n in i), true);
-            o = true;
+            r = true;
         } else {
             const t = visible(n, i[n]);
             if (!isEqual(t, s) && !targetsEqual(t, s)) {
                 setSignal(getNode(e, n, t), () => s);
-                if (r) o = true;
+                if (o) r = true;
             }
         }
     }
     for (const n of Reflect.ownKeys(i)) {
-        if (r && n === "length" || n === $OWNER) continue;
+        if (o && n === "length" || n === $OWNER) continue;
         if (n in t || !visiblePresent(n)) continue;
         // Optimistic delete: node reads undefined, presence flips, membership bumps.
                 setSignal(getNode(e, n, i[n]), () => undefined);
         setSignal(getHasNode(e, n, true), false);
-        o = true;
+        r = true;
     }
-    if (r) {
+    if (o) {
         const n = visible("length", i.length);
         if (n !== t.length) {
             setSignal(getNode(e, "length", n), () => t.length);
-            o = true;
+            r = true;
         }
     }
-    if (o) setSignal(getKeySetNode(e), e => e + 1);
+    if (r) setSignal(getKeySetNode(e), e => e + 1);
     // Deep-witness: optimistic value writes notify deep() subscribers too
     // (structural ones already ride the key-set bump above).
         bumpDeep(e);
@@ -522,7 +527,7 @@ function createOptimisticStoreNext(e, t, n) {
         e.pb = stagedTruthPB.get(e) ?? null;
     if (e.pb !== null) stagedTruthPB.delete(e);
     (e.fam.overlaid ??= new Set).add(e);
-    GlobalQueue.Hn?.(e.fam.px ?? e.px);
+    GlobalQueue.jn?.(e.fam.px ?? e.px);
 }
 
 /** Optimistic-view composition for snapshot/deep (O1: snapshot is the CURRENT
@@ -530,18 +535,20 @@ function createOptimisticStoreNext(e, t, n) {
  * RUL-12). Returns `src` untouched when no override is active on `t`.
  * Authoritative-view reads (until()'s predicate) skip composition entirely:
  * the predicate observes authoritative truth, never the caller's tentative
- * overlay. (Write-side emission callers never run under such a compute.) */ function optimisticView(e, t) {
+ * overlay. (Write-side emission callers never run under such a compute.) */ function optimisticView(e, t, n = false) {
     if (e.fam?.opt !== true || authoritativeRead()) return t;
-    let n = null;
-    const ensure = () => n ??= Array.isArray(t) ? [ ...t ] : {
+    let i = null;
+    const ensure = () => i ??= Array.isArray(t) ? [ ...t ] : {
         ...t
     };
-    const i = e.n;
-    if (i !== null) {
-        for (const e of Reflect.ownKeys(i)) {
-            const n = i[e];
-            if (!hasActiveOverride(n)) continue;
-            const o = unwrapOverride(n.o?.De);
+    const r = e.n;
+    if (r !== null) {
+        for (const e of Reflect.ownKeys(r)) {
+            const i = r[e];
+            // A28 (5): readers see an optimistic write once a flush carried it;
+            // the draft (writer channel) composes on it now.
+                        if (!(n ? hasActiveOverride(i) : visibleOverride(i))) continue;
+            const o = unwrapOverride(i.o?.Ne);
             if (e === "length" && Array.isArray(t)) {
                 if (t.length !== o) ensure().length = o;
             } else if (!isEqual(t[e], o)) ensure()[e] = o;
@@ -550,21 +557,23 @@ function createOptimisticStoreNext(e, t, n) {
     const o = e.h;
     if (o !== null) {
         for (const e of Reflect.ownKeys(o)) {
-            const i = o[e];
-            if (!hasActiveOverride(i)) continue;
-            const r = !!unwrapOverride(i.o?.De);
-            if (!r && e in (n ?? t)) delete ensure()[e];
+            const r = o[e];
+            // A28 (5): readers see an optimistic write once a flush carried it;
+            // the draft (writer channel) composes on it now.
+                        if (!(n ? hasActiveOverride(r) : visibleOverride(r))) continue;
+            const s = !!unwrapOverride(r.o?.Ne);
+            if (!s && e in (i ?? t)) delete ensure()[e];
         }
     }
-    return n ?? t;
+    return i ?? t;
 }
 
 function applyTentative(e, t, n) {
     const i = e.pb ?? e.v;
-    const o = optimisticView(e, i);
-    const r = e.fam;
+    const r = optimisticView(e, i);
+    const o = e.fam;
     const s = Array.isArray(t);
-    if (Array.isArray(o) !== s) return;
+    if (Array.isArray(r) !== s) return;
  // kind change at root: flat overrides below
         const l = [];
     let u;
@@ -578,22 +587,22 @@ function applyTentative(e, t, n) {
         if (Array.isArray(e) !== Array.isArray(t)) return null;
         if (n) {
             const i = n(e);
-            const o = n(t);
+            const r = n(t);
             // SameValueZero (re-audit 3, P1-3): parity with the plain reconcile
             // channel — NaN keys are self-equal.
-                        if (i !== undefined && o !== undefined && !sameKey(i, o)) return null;
+                        if (i !== undefined && r !== undefined && !sameKey(i, r)) return null;
         }
-        return lookupTarget(unwrapValue(e), r) ?? null;
+        return lookupTarget(unwrapValue(e), o) ?? null;
     };
     if (s) {
-        const e = o;
+        const e = r;
         let i = null;
-        for (let o = 0; o < t.length; o++) {
-            const r = t[o];
-            if (!isWrappable(r)) continue;
+        for (let r = 0; r < t.length; r++) {
+            const o = t[r];
+            if (!isWrappable(o)) continue;
             let s;
             if (n) {
-                const t = n(r);
+                const t = n(o);
                 if (t !== undefined) {
                     if (i === null) {
                         // Occurrence-aware index queues (re-audit 3, P1-3): parity with
@@ -601,41 +610,41 @@ function applyTentative(e, t, n) {
                         // occurrence, each view row consumed once.
                         i = new Map;
                         for (let t = 0; t < e.length; t++) {
-                            const o = unwrapValue(e[t]);
-                            if (isWrappable(o)) {
-                                const e = n(o);
+                            const r = unwrapValue(e[t]);
+                            if (isWrappable(r)) {
+                                const e = n(r);
                                 if (e === undefined) continue;
-                                const r = i.get(e);
-                                if (r === undefined) i.set(e, t); else if (Array.isArray(r)) r.push(t); else i.set(e, [ r, t ]);
+                                const o = i.get(e);
+                                if (o === undefined) i.set(e, t); else if (Array.isArray(o)) o.push(t); else i.set(e, [ o, t ]);
                             }
                         }
                     }
-                    const o = i.get(t);
-                    if (o === undefined) s = undefined; else if (Array.isArray(o)) {
-                        s = unwrapValue(e[o.shift()]);
-                        if (o.length === 1) i.set(t, o[0]);
+                    const r = i.get(t);
+                    if (r === undefined) s = undefined; else if (Array.isArray(r)) {
+                        s = unwrapValue(e[r.shift()]);
+                        if (r.length === 1) i.set(t, r[0]);
                     } else {
-                        s = unwrapValue(e[o]);
+                        s = unwrapValue(e[r]);
                         i.delete(t);
                     }
-                } else s = unwrapValue(e[o]);
-            } else s = unwrapValue(e[o]);
-            const a = match(s, r);
+                } else s = unwrapValue(e[r]);
+            } else s = unwrapValue(e[r]);
+            const a = match(s, o);
             if (a !== null) {
                 // Keep the existing row in the slot (identity preserved); recurse.
-                u[o] = unwrapValue(s);
-                l.push([ a, r ]);
+                u[r] = unwrapValue(s);
+                l.push([ a, o ]);
             }
         }
     } else {
         for (const e of Reflect.ownKeys(t)) {
             if (e === $OWNER) continue;
-            const n = unwrapValue(o[e]);
+            const n = unwrapValue(r[e]);
             const i = t[e];
-            const r = match(n, i);
-            if (r !== null) {
+            const o = match(n, i);
+            if (o !== null) {
                 u[e] = n;
-                l.push([ r, i ]);
+                l.push([ o, i ]);
             }
         }
     }