@solidjs/signals
Version:
SolidJS' standalone reactivity implementation
2,322 lines • 78.3 kB
JavaScript
"use strict";
class NotReadyError extends Error {
source;
constructor(e) {
super();
this.source = e;
}
}
class StatusError extends Error {
source;
constructor(e, t) {
super(t instanceof Error ? t.message : String(t), { cause: t });
this.source = e;
}
}
class NoOwnerError extends Error {
constructor() {
super("");
}
}
class ContextNotFoundError extends Error {
constructor() {
super("");
}
}
const e = 0;
const t = 1 << 0;
const n = 1 << 1;
const r = 1 << 2;
const i = 1 << 3;
const s = 1 << 4;
const o = 1 << 5;
const u = 1 << 6;
const f = 1 << 7;
const l = 1 << 8;
const c = 1 << 9;
const a = 1 << 0;
const d = 1 << 1;
const h = 1 << 2;
const p = 1;
const y = 2;
const g = 3;
const S = {};
const w = {};
const m = "sp";
const b = typeof Proxy === "function";
const _ = {};
const O = Symbol("refresh");
function actualInsertIntoHeap(e, t) {
const n = (e.i?.t ? e.i.u?.o : e.i?.o) ?? -1;
if (n >= e.o) e.o = n + 1;
const r = e.o;
const i = t.l[r];
if (i === undefined) t.l[r] = e;
else {
const t = i.h;
t.p = e;
e.h = t;
i.h = e;
}
if (r > t.S) t.S = r;
}
function insertIntoHeap(e, o) {
let u = e.m;
if (u & (i | r)) return;
if (u & t) {
e.m = (u & -4) | n | i;
} else e.m = u | i;
if (!(u & s)) actualInsertIntoHeap(e, o);
}
function insertIntoHeapHeight(e, t) {
let n = e.m;
if (n & (i | r | s)) return;
e.m = n | s;
actualInsertIntoHeap(e, t);
}
function deleteFromHeap(e, t) {
const n = e.m;
if (!(n & (i | s))) return;
e.m = n & -25;
const r = e.o;
if (e.h === e) t.l[r] = undefined;
else {
const n = e.p;
const i = t.l[r];
const s = n ?? i;
if (e === i) t.l[r] = n;
else e.h.p = n;
s.h = e.h;
}
e.h = e;
e.p = undefined;
}
function markHeap(e) {
if (e._) return;
e._ = true;
for (let t = 0; t <= e.S; t++) {
for (let n = e.l[t]; n !== undefined; n = n.p) {
if (n.m & i) markNode(n);
}
}
}
function markNode(e, r = n) {
const i = e.m;
if ((i & (t | n)) >= r) return;
e.m = (i & -4) | r;
for (let n = e.O; n !== null; n = n.P) {
markNode(n.k, t);
}
if (e.C !== null) {
for (let n = e.C; n !== null; n = n.W) {
for (let e = n.O; e !== null; e = e.P) {
markNode(e.k, t);
}
}
}
}
function runHeap(e, t) {
e._ = false;
for (e.j = 0; e.j <= e.S; e.j++) {
let n = e.l[e.j];
while (n !== undefined) {
if (n.m & i) t(n);
else adjustHeight(n, e);
n = e.l[e.j];
}
}
e.S = 0;
}
function adjustHeight(e, t) {
deleteFromHeap(e, t);
let n = e.o;
for (let t = e.A; t; t = t.N) {
const e = t.R;
const r = e.L || e;
if (r.I && r.o >= n) n = r.o + 1;
}
if (e.o !== n) {
e.o = n;
for (let n = e.O; n !== null; n = n.P) {
insertIntoHeapHeight(n.k, t);
}
}
}
const x = undefined;
const v = new Set();
const P = { l: new Array(2e3).fill(undefined), _: false, j: 0, S: 0 };
const k = { l: new Array(2e3).fill(undefined), _: false, j: 0, S: 0 };
let E = 0;
let C = null;
let W = false;
let j = false;
let A = null;
function enforceLoadingBoundary(e) {}
function shouldReadStashedOptimisticValue(e) {
return !!A?.has(e);
}
function runLaneEffects(e) {
for (const t of L) {
if (t.T || t.H.size > 0) continue;
const n = t.q[e - 1];
if (n.length) {
t.q[e - 1] = [];
runQueue(n, e);
}
}
}
function queueStashedOptimisticEffects(e) {
for (let t = e.O; t !== null; t = t.P) {
const e = t.k;
if (!e.D) continue;
if (e.D === g) {
if (!e.F) {
e.F = true;
e.M.enqueue(y, e.V);
}
continue;
}
const n = e.m & o ? k : P;
if (n.j > e.o) n.j = e.o;
insertIntoHeap(e, n);
}
}
function setProjectionWriteActive(e) {
j = e;
}
function mergeTransitionState(e, t) {
t.B = e;
e.K.push(...t.K);
for (const n of L) if (n.G === t) n.G = e;
e.U.push(...t.U);
for (const n of t.J) e.J.add(n);
for (const [n, r] of t.X) {
let t = e.X.get(n);
if (!t) e.X.set(n, (t = new Set()));
for (const e of r) t.add(e);
}
}
function resolveOptimisticNodes(e) {
for (let t = 0; t < e.length; t++) {
const n = e[t];
n.Y = undefined;
if (n.Z !== S) {
n.$ = n.Z;
n.Z = S;
}
const r = n.ee;
n.ee = S;
if (r !== S && n.$ !== r) insertSubs(n, true);
n.G = null;
}
e.length = 0;
}
function cleanupCompletedLanes(e) {
for (const t of L) {
const n = e ? t.G === e : !t.G;
if (!n) continue;
if (!t.T) {
if (t.q[0].length) runQueue(t.q[0], p);
if (t.q[1].length) runQueue(t.q[1], y);
}
if (t.te.Y === t) t.te.Y = undefined;
t.H.clear();
t.q[0].length = 0;
t.q[1].length = 0;
L.delete(t);
R.delete(t.te);
}
}
function schedule() {
if (W) return;
W = true;
if (!N.ne && !j) queueMicrotask(flush);
}
class Queue {
i = null;
re = [[], []];
ie = [];
created = E;
addChild(e) {
this.ie.push(e);
e.i = this;
}
removeChild(e) {
const t = this.ie.indexOf(e);
if (t >= 0) {
this.ie.splice(t, 1);
e.i = null;
}
}
notify(e, t, n, r) {
if (this.i) return this.i.notify(e, t, n, r);
return false;
}
run(e) {
if (this.re[e - 1].length) {
const t = this.re[e - 1];
this.re[e - 1] = [];
runQueue(t, e);
}
for (let t = 0; t < this.ie.length; t++) this.ie[t].run?.(e);
}
enqueue(e, t) {
if (e) {
if (B) {
const n = findLane(B);
n.q[e - 1].push(t);
} else {
this.re[e - 1].push(t);
}
}
schedule();
}
stashQueues(e) {
e.re[0].push(...this.re[0]);
e.re[1].push(...this.re[1]);
this.re = [[], []];
for (let t = 0; t < this.ie.length; t++) {
let n = this.ie[t];
let r = e.ie[t];
if (!r) {
r = { re: [[], []], ie: [] };
e.ie[t] = r;
}
n.stashQueues(r);
}
}
restoreQueues(e) {
this.re[0].push(...e.re[0]);
this.re[1].push(...e.re[1]);
for (let t = 0; t < e.ie.length; t++) {
const n = e.ie[t];
let r = this.ie[t];
if (r) r.restoreQueues(n);
}
}
}
class GlobalQueue extends Queue {
ne = false;
se = [];
U = [];
J = new Set();
static oe;
static ue;
static fe = null;
flush() {
if (this.ne) return;
this.ne = true;
try {
runHeap(P, GlobalQueue.oe);
if (C) {
const e = transitionComplete(C);
if (!e) {
const e = C;
runHeap(k, GlobalQueue.oe);
this.se = [];
this.U = [];
this.J = new Set();
runLaneEffects(p);
runLaneEffects(y);
this.stashQueues(e.le);
E++;
W = P.S >= P.j;
reassignPendingTransition(e.se);
C = null;
if (!e.K.length && e.U.length) {
A = new Set();
for (let t = 0; t < e.U.length; t++) {
const n = e.U[t];
if (n.I || n.ce) continue;
A.add(n);
queueStashedOptimisticEffects(n);
}
}
try {
finalizePureQueue(null, true);
} finally {
A = null;
}
return;
}
this.se !== C.se && this.se.push(...C.se);
this.restoreQueues(C.le);
v.delete(C);
const t = C;
C = null;
reassignPendingTransition(this.se);
finalizePureQueue(t);
} else {
if (v.size) runHeap(k, GlobalQueue.oe);
finalizePureQueue();
}
E++;
W = P.S >= P.j;
runLaneEffects(p);
this.run(p);
runLaneEffects(y);
this.run(y);
if (false);
} finally {
this.ne = false;
}
}
notify(e, t, n, r) {
if (t & a) {
if (n & a) {
const t = r !== undefined ? r : e.ae;
if (C && t) {
const n = t.source;
let r = C.X.get(n);
if (!r) C.X.set(n, (r = new Set()));
const i = r.size;
r.add(e);
if (r.size !== i) schedule();
}
}
return true;
}
return false;
}
initTransition(e) {
if (e) e = currentTransition(e);
if (e && e === C) return;
if (!e && C && C.de === E) return;
if (!C) {
C = e ?? {
de: E,
se: [],
X: new Map(),
U: [],
J: new Set(),
K: [],
le: { re: [[], []], ie: [] },
B: false
};
} else if (e) {
const t = C;
mergeTransitionState(e, t);
v.delete(t);
C = e;
}
v.add(C);
C.de = E;
if (this.se !== C.se) {
for (let e = 0; e < this.se.length; e++) {
const t = this.se[e];
t.G = C;
C.se.push(t);
}
this.se = C.se;
}
if (this.U !== C.U) {
for (let e = 0; e < this.U.length; e++) {
const t = this.U[e];
t.G = C;
C.U.push(t);
}
this.U = C.U;
}
for (const e of L) {
if (!e.G) e.G = C;
}
if (this.J !== C.J) {
for (const e of this.J) C.J.add(e);
this.J = C.J;
}
}
}
function insertSubs(e, t = false) {
const n = e.Y || B;
const r = e.he !== undefined;
for (let i = e.O; i !== null; i = i.P) {
if (r && i.k.pe) {
i.k.m |= l;
continue;
}
if (t && n) {
i.k.m |= f;
assignOrMergeLane(i.k, n);
} else if (t) {
i.k.m |= f;
i.k.Y = undefined;
}
const e = i.k;
if (e.D === g) {
if (!e.F) {
e.F = true;
e.M.enqueue(y, e.V);
}
continue;
}
const s = i.k.m & o ? k : P;
if (s.j > i.k.o) s.j = i.k.o;
insertIntoHeap(i.k, s);
}
}
function commitPendingNodes() {
const e = N.se;
for (let t = 0; t < e.length; t++) {
const n = e[t];
if (n.Z !== S) {
n.$ = n.Z;
n.Z = S;
if (n.D && n.D !== g) n.F = true;
}
if (!(n.ye & a)) n.ye &= ~h;
if (n.I) GlobalQueue.ue(n, false, true);
}
e.length = 0;
}
function finalizePureQueue(e = null, t = false) {
const n = !t;
if (n) commitPendingNodes();
if (!t) checkBoundaryChildren(N);
if (P.S >= P.j) runHeap(P, GlobalQueue.oe);
if (n) {
commitPendingNodes();
resolveOptimisticNodes(e ? e.U : N.U);
const t = e ? e.J : N.J;
if (GlobalQueue.fe && t.size) {
for (const e of t) {
GlobalQueue.fe(e);
}
t.clear();
schedule();
}
cleanupCompletedLanes(e);
}
}
function checkBoundaryChildren(e) {
for (const t of e.ie) {
t.checkSources?.();
checkBoundaryChildren(t);
}
}
function trackOptimisticStore(e) {
N.J.add(e);
schedule();
}
function reassignPendingTransition(e) {
for (let t = 0; t < e.length; t++) {
e[t].G = C;
}
}
const N = new GlobalQueue();
function flush() {
if (N.ne) {
return;
}
while (W || C) {
N.flush();
}
}
function runQueue(e, t) {
for (let n = 0; n < e.length; n++) e[n](t);
}
function reporterBlocksSource(e, t) {
if (e.m & (o | u)) return false;
if (e.ge === t || e.Se?.has(t)) return true;
for (let n = e.A; n; n = n.N) {
let e = n.R;
while (e) {
if (e === t || e.L === t) return true;
e = e.we;
}
}
return !!(e.ye & a && e.ae instanceof NotReadyError && e.ae.source === t);
}
function transitionComplete(e) {
if (e.B) return true;
if (e.K.length) return false;
let t = true;
for (const [n, r] of e.X) {
let i = false;
for (const e of r) {
if (reporterBlocksSource(e, n)) {
i = true;
break;
}
r.delete(e);
}
if (!i) e.X.delete(n);
else if (n.ye & a && n.ae?.source === n) {
t = false;
break;
}
}
if (t) {
for (let n = 0; n < e.U.length; n++) {
const r = e.U[n];
if (
hasActiveOverride(r) &&
"ye" in r &&
r.ye & a &&
r.ae instanceof NotReadyError &&
r.ae.source !== r
) {
t = false;
break;
}
}
}
t && (e.B = true);
return t;
}
function currentTransition(e) {
while (e.B && typeof e.B === "object") e = e.B;
return e;
}
function setActiveTransition(e) {
C = e;
}
function runInTransition(e, t) {
const n = C;
try {
C = currentTransition(e);
return t();
} finally {
C = n;
}
}
const R = new WeakMap();
const L = new Set();
function getOrCreateLane(e) {
let t = R.get(e);
if (t) {
return findLane(t);
}
const n = e.we;
const r = n?.Y ? findLane(n.Y) : null;
t = { te: e, H: new Set(), q: [[], []], T: null, G: C, me: r };
R.set(e, t);
L.add(t);
e.be = false;
return t;
}
function findLane(e) {
while (e.T) e = e.T;
return e;
}
function mergeLanes(e, t) {
e = findLane(e);
t = findLane(t);
if (e === t) return e;
t.T = e;
for (const n of t.H) e.H.add(n);
e.q[0].push(...t.q[0]);
e.q[1].push(...t.q[1]);
return e;
}
function resolveLane(e) {
const t = e.Y;
if (!t) return undefined;
const n = findLane(t);
if (L.has(n)) return n;
e.Y = undefined;
return undefined;
}
function resolveTransition(e) {
return resolveLane(e)?.G ?? e.G;
}
function hasActiveOverride(e) {
return !!(e.ee !== undefined && e.ee !== S);
}
function assignOrMergeLane(e, t) {
const n = findLane(t);
const r = e.Y;
if (r) {
if (r.T) {
e.Y = t;
return;
}
const i = findLane(r);
if (L.has(i)) {
if (i !== n && !hasActiveOverride(e)) {
if (n.me && findLane(n.me) === i) {
e.Y = t;
} else if (i.me && findLane(i.me) === n);
else mergeLanes(n, i);
}
return;
}
}
e.Y = t;
}
function unlinkSubs(e) {
const t = e.R;
const n = e.N;
const r = e.P;
const i = e._e;
if (r !== null) r._e = i;
else t.Oe = i;
if (i !== null) i.P = r;
else {
t.O = r;
if (r === null) {
t.xe?.();
t.I && !t.ve && !(t.m & o) && unobserved(t);
}
}
return n;
}
function unobserved(e) {
deleteFromHeap(e, e.m & o ? k : P);
let t = e.A;
while (t !== null) {
t = unlinkSubs(t);
}
e.A = null;
disposeChildren(e, true);
}
function link(e, t) {
const n = t.Pe;
if (n !== null && n.R === e) return;
let i = null;
const s = t.m & r;
if (s) {
i = n !== null ? n.N : t.A;
if (i !== null && i.R === e) {
t.Pe = i;
return;
}
}
const o = e.Oe;
if (o !== null && o.k === t && (!s || isValidLink(o, t))) return;
const u = (t.Pe = e.Oe = { R: e, k: t, N: i, _e: o, P: null });
if (n !== null) n.N = u;
else t.A = u;
if (o !== null) o.P = u;
else e.O = u;
}
function isValidLink(e, t) {
const n = t.Pe;
if (n !== null) {
let r = t.A;
do {
if (r === e) return true;
if (r === n) break;
r = r.N;
} while (r !== null);
}
return false;
}
const I = {};
function markDisposal(e) {
let t = e.ke;
while (t) {
t.m |= o;
if (t.m & i) {
deleteFromHeap(t, P);
insertIntoHeap(t, k);
}
markDisposal(t);
t = t.Ee;
}
}
function dispose(e) {
let t = e.A || null;
do {
t = unlinkSubs(t);
} while (t !== null);
e.A = null;
e.Pe = null;
disposeChildren(e, true);
}
function disposeChildren(e, t = false, n) {
if (e.m & u) return;
if (t) e.m = u;
if (t && e.I) e.Ce = null;
let r = n ? e.We : e.ke;
while (r) {
const e = r.Ee;
if (r.A) {
const e = r;
deleteFromHeap(e, e.m & o ? k : P);
let t = e.A;
do {
t = unlinkSubs(t);
} while (t !== null);
e.A = null;
e.Pe = null;
}
disposeChildren(r, true);
r = e;
}
if (n) {
e.We = null;
} else {
e.ke = null;
e.je = 0;
}
runDisposal(e, n);
}
function runDisposal(e, t) {
let n = t ? e.Ae : e.Ne;
if (!n) return;
if (Array.isArray(n)) {
for (let e = 0; e < n.length; e++) {
const t = n[e];
t.call(t);
}
} else {
n.call(n);
}
t ? (e.Ae = null) : (e.Ne = null);
}
function childId(e, t) {
let n = e;
while (n.Re && n.i) n = n.i;
if (n.id != null) return formatId(n.id, t ? n.je++ : n.je);
throw new Error("Cannot get child id from owner without an id");
}
function getNextChildId(e) {
return childId(e, true);
}
function peekNextChildId(e) {
return childId(e, false);
}
function formatId(e, t) {
const n = t.toString(36),
r = n.length - 1;
return e + (r ? String.fromCharCode(64 + r) : "") + n;
}
function getObserver() {
if (D || M) return I;
return H ? V : null;
}
function getOwner() {
return V;
}
function cleanup(e) {
if (!V) return e;
if (!V.Ne) V.Ne = e;
else if (Array.isArray(V.Ne)) V.Ne.push(e);
else V.Ne = [V.Ne, e];
return e;
}
function isDisposed(e) {
return !!(e.m & (u | o));
}
function createOwner(e) {
const t = V;
const n = e?.transparent ?? false;
const r = {
id: e?.id ?? (n ? t?.id : t?.id != null ? getNextChildId(t) : undefined),
Re: n || undefined,
t: true,
u: t?.t ? t.u : t,
ke: null,
Ee: null,
Ne: null,
M: t?.M ?? N,
Le: t?.Le || _,
je: 0,
Ae: null,
We: null,
i: t,
dispose(e = true) {
disposeChildren(r, e);
}
};
if (t) {
const e = t.ke;
if (e === null) {
t.ke = r;
} else {
r.Ee = e;
t.ke = r;
}
}
return r;
}
function createRoot(e, t) {
const n = createOwner(t);
return runWithOwner(n, () => e(n.dispose));
}
function addPendingSource(e, t) {
if (e.ge === t || e.Se?.has(t)) return false;
if (!e.ge) {
e.ge = t;
return true;
}
if (!e.Se) {
e.Se = new Set([e.ge, t]);
} else {
e.Se.add(t);
}
e.ge = undefined;
return true;
}
function removePendingSource(e, t) {
if (e.ge) {
if (e.ge !== t) return false;
e.ge = undefined;
return true;
}
if (!e.Se?.delete(t)) return false;
if (e.Se.size === 1) {
e.ge = e.Se.values().next().value;
e.Se = undefined;
} else if (e.Se.size === 0) {
e.Se = undefined;
}
return true;
}
function clearPendingSources(e) {
e.ge = undefined;
e.Se?.clear();
e.Se = undefined;
}
function setPendingError(e, t, n) {
if (!t) {
e.ae = null;
return;
}
if (n instanceof NotReadyError && n.source === t) {
e.ae = n;
return;
}
const r = e.ae;
if (!(r instanceof NotReadyError) || r.source !== t) {
e.ae = new NotReadyError(t);
}
}
function forEachDependent(e, t) {
for (let n = e.O; n !== null; n = n.P) t(n.k);
for (let n = e.C; n !== null; n = n.W) {
for (let e = n.O; e !== null; e = e.P) t(e.k);
}
}
function settlePendingSource(e) {
let t = false;
const n = new Set();
const settle = r => {
if (n.has(r) || !removePendingSource(r, e)) return;
n.add(r);
r.de = E;
const i = r.ge ?? r.Se?.values().next().value;
if (i) {
setPendingError(r, i);
updatePendingSignal(r);
} else {
r.ye &= ~a;
setPendingError(r);
updatePendingSignal(r);
if (r.Ie) {
if (r.D === g) {
const e = r;
if (!e.F) {
e.F = true;
e.M.enqueue(y, e.V);
}
} else {
const e = r.m & o ? k : P;
if (e.j > r.o) e.j = r.o;
insertIntoHeap(r, e);
}
t = true;
}
r.Ie = false;
}
forEachDependent(r, settle);
};
forEachDependent(e, settle);
if (t) schedule();
}
function handleAsync(e, t, r) {
const i = typeof t === "object" && t !== null;
const s = i && untrack(() => t[Symbol.asyncIterator]);
const o = !s && i && untrack(() => typeof t.then === "function");
if (!o && !s) {
e.Ce = null;
return t;
}
e.Ce = t;
let u;
const handleError = n => {
if (e.Ce !== t) return;
N.initTransition(resolveTransition(e));
notifyStatus(e, n instanceof NotReadyError ? a : d, n);
e.de = E;
};
const asyncWrite = (i, s) => {
if (e.Ce !== t) return;
if (e.m & (n | f)) return;
N.initTransition(resolveTransition(e));
const o = !!(e.ye & h);
clearStatus(e);
const u = resolveLane(e);
if (u) u.H.delete(e);
if (r) r(i);
else if (e.ee !== undefined) {
if (e.ee !== undefined && e.ee !== S) e.Z = i;
else {
e.$ = i;
insertSubs(e);
}
e.de = E;
} else if (u) {
const t = e.D;
const n = e.$;
const r = e.Te;
if ((!t && o) || !r || !r(i, n)) {
e.$ = i;
e.de = E;
if (e.He) {
setSignal(e.He, i);
}
insertSubs(e, true);
}
} else {
setSignal(e, () => i);
}
settlePendingSource(e);
schedule();
flush();
s?.();
};
if (o) {
let n = false,
r = true;
t.then(
e => {
if (r) {
u = e;
n = true;
} else asyncWrite(e);
},
e => {
if (!r) handleError(e);
}
);
r = false;
if (!n) {
N.initTransition(resolveTransition(e));
throw new NotReadyError(V);
}
}
if (s) {
const n = t[Symbol.asyncIterator]();
let r = false;
let i = false;
cleanup(() => {
if (i) return;
i = true;
try {
const e = n.return?.();
if (e && typeof e.then === "function") {
e.then(undefined, () => {});
}
} catch {}
});
const iterate = () => {
let s,
o = false,
f = true;
n.next().then(
n => {
if (f) {
s = n;
o = true;
if (n.done) i = true;
} else if (e.Ce !== t) {
return;
} else if (!n.done) asyncWrite(n.value, iterate);
else {
i = true;
schedule();
flush();
}
},
n => {
if (!f && e.Ce === t) {
i = true;
handleError(n);
}
}
);
f = false;
if (o && !s.done) {
u = s.value;
r = true;
return iterate();
}
return o && s.done;
};
const s = iterate();
if (!r && !s) {
N.initTransition(resolveTransition(e));
throw new NotReadyError(V);
}
}
return u;
}
function clearStatus(e, t = false) {
clearPendingSources(e);
e.Ie = false;
e.ye = t ? 0 : e.ye & h;
setPendingError(e);
updatePendingSignal(e);
e.Qe?.();
}
function notifyStatus(e, t, n, r, i) {
if (t === d && !(n instanceof StatusError) && !(n instanceof NotReadyError))
n = new StatusError(e, n);
const s = t === a && n instanceof NotReadyError ? n.source : undefined;
const o = s === e;
const u = t === a && e.ee !== undefined && !o;
const f = u && hasActiveOverride(e);
if (!r) {
if (t === a && s) {
addPendingSource(e, s);
e.ye = a | (e.ye & h);
setPendingError(e, s, n);
} else {
clearPendingSources(e);
e.ye = t | (t !== d ? e.ye & h : 0);
e.ae = n;
}
updatePendingSignal(e);
}
if (i && !r) {
assignOrMergeLane(e, i);
}
const l = r || f;
const c = r || u ? undefined : i;
if (e.Qe) {
if (r && t === a) {
return;
}
if (l) {
e.Qe(t, n);
} else {
e.Qe();
}
return;
}
forEachDependent(e, e => {
e.de = E;
if (
(t === a && s && e.ge !== s && !e.Se?.has(s)) ||
(t !== a && (e.ae !== n || e.ge || e.Se))
) {
if (!l && !e.G) N.se.push(e);
notifyStatus(e, t, n, l, c);
}
});
}
let T = null;
function enableExternalSource(e) {
const { factory: t, untrack: n = e => e() } = e;
if (T) {
const { factory: e, untrack: r } = T;
T = {
factory: (n, r) => {
const i = e(n, r);
const s = t(e => i.track(e), r);
return {
track: e => s.track(e),
dispose() {
s.dispose();
i.dispose();
}
};
},
untrack: e => r(() => n(e))
};
} else {
T = { factory: t, untrack: n };
}
}
GlobalQueue.oe = recompute;
GlobalQueue.ue = disposeChildren;
let H = false;
let Q = false;
let q = false;
let D = false;
let F = false;
let M = false;
let V = null;
let B = null;
let K = false;
let G = null;
function ownerInSnapshotScope(e) {
while (e) {
if (e.qe) return true;
e = e.i;
}
return false;
}
function setSnapshotCapture(e) {
K = e;
if (e && !G) G = new Set();
}
function markSnapshotScope(e) {
e.qe = true;
}
function releaseSnapshotScope(e) {
e.qe = false;
releaseSubtree(e);
schedule();
}
function releaseSubtree(e) {
let t = e.ke;
while (t) {
if (t.qe) {
t = t.Ee;
continue;
}
if (t.I) {
const e = t;
e.pe = false;
if (e.m & l) {
e.m &= ~l;
e.m |= n;
if (P.j > e.o) P.j = e.o;
insertIntoHeap(e, P);
}
}
releaseSubtree(t);
t = t.Ee;
}
}
function clearSnapshots() {
if (G) {
for (const e of G) {
delete e.he;
delete e[m];
}
G = null;
}
K = false;
}
function recompute(t, n = false) {
const i = t.D;
if (!n) {
if (t.G && (!i || C) && C !== t.G) N.initTransition(t.G);
deleteFromHeap(t, t.m & o ? k : P);
t.Ce = null;
if (t.G || i === g) disposeChildren(t);
else {
markDisposal(t);
t.Ae = t.Ne;
t.We = t.ke;
t.Ne = null;
t.ke = null;
t.je = 0;
}
}
const s = !!(t.m & f);
const u = t.ee !== undefined && t.ee !== S;
const c = !!(t.ye & a);
const p = !!(t.ye & h);
const y = V;
V = t;
t.Pe = null;
t.m = r;
t.de = E;
let w = t.Z === S ? t.$ : t.Z;
let m = t.o;
let b = H;
let _ = B;
H = true;
if (s) {
const e = resolveLane(t);
if (e) B = e;
}
try {
w = handleAsync(t, t.I(w));
clearStatus(t, n);
const e = resolveLane(t);
if (e) {
e.H.delete(t);
updatePendingSignal(e.te);
}
} catch (e) {
if (e instanceof NotReadyError && B) {
const e = findLane(B);
if (e.te !== t) {
e.H.add(t);
t.Y = e;
updatePendingSignal(e.te);
}
}
if (e instanceof NotReadyError) t.Ie = true;
notifyStatus(
t,
e instanceof NotReadyError ? a : d,
e,
undefined,
e instanceof NotReadyError ? t.Y : undefined
);
} finally {
H = b;
t.m = e | (n ? t.m & l : 0);
V = y;
}
if (!t.ae) {
const e = t.Pe;
let r = e !== null ? e.N : t.A;
if (r !== null) {
do {
r = unlinkSubs(r);
} while (r !== null);
if (e !== null) e.N = null;
else t.A = null;
}
const f = u ? t.ee : t.Z === S ? t.$ : t.Z;
const l = (!i && p) || !t.Te || !t.Te(f, w);
if (l) {
const e = u ? t.ee : undefined;
if (n || (i && C !== t.G) || s) {
t.$ = w;
if (u && s) {
t.ee = w;
t.Z = w;
}
} else t.Z = w;
if (u && !s && c && !t.be) t.ee = w;
if (!u || s || t.ee !== e) insertSubs(t, s || u);
} else if (u) {
t.Z = w;
} else if (t.o != m) {
for (let e = t.O; e !== null; e = e.P) {
insertIntoHeapHeight(e.k, e.k.m & o ? k : P);
}
}
}
B = _;
(!n || t.ye & a) && !t.G && !(C && u) && N.se.push(t);
t.G && i && C !== t.G && runInTransition(t.G, () => recompute(t));
}
function updateIfNecessary(e) {
if (e.m & t) {
for (let t = e.A; t; t = t.N) {
const r = t.R;
const i = r.L || r;
if (i.I) {
updateIfNecessary(i);
}
if (e.m & n) {
break;
}
}
}
if (e.m & (n | f) || (e.ae && e.de < E && !e.Ce)) {
recompute(e);
}
e.m = e.m & (l | i | s);
}
function computed(t, n, r) {
const i = r?.transparent ?? false;
const s = {
id: r?.id ?? (i ? V?.id : V?.id != null ? getNextChildId(V) : undefined),
Re: i || undefined,
Te: r?.equals != null ? r.equals : isEqual,
ce: !!r?.pureWrite,
xe: r?.unobserved,
Ne: null,
M: V?.M ?? N,
Le: V?.Le ?? _,
je: 0,
I: t,
$: n,
o: 0,
C: null,
p: undefined,
h: null,
A: null,
Pe: null,
O: null,
Oe: null,
i: V,
Ee: null,
ke: null,
m: r?.lazy ? c : e,
ye: h,
de: E,
Z: S,
Ae: null,
We: null,
Ce: null,
G: null
};
s.h = s;
const o = V?.t ? V.u : V;
if (V) {
const e = V.ke;
if (e === null) {
V.ke = s;
} else {
s.Ee = e;
V.ke = s;
}
}
if (o) s.o = o.o + 1;
if (K && ownerInSnapshotScope(V)) s.pe = true;
if (T) {
const e = signal(undefined, { equals: false, pureWrite: true });
const t = T.factory(s.I, () => {
setSignal(e, undefined);
});
cleanup(() => t.dispose());
s.I = n => {
read(e);
return t.track(n);
};
}
!r?.lazy && recompute(s, true);
if (K && !r?.lazy) {
if (!(s.ye & a)) {
s.he = s.$ === undefined ? w : s.$;
G.add(s);
}
}
return s;
}
function signal(e, t, n = null) {
const r = {
Te: t?.equals != null ? t.equals : isEqual,
ce: !!t?.pureWrite,
De: !!t?.De,
xe: t?.unobserved,
$: e,
O: null,
Oe: null,
de: E,
L: n,
W: n?.C || null,
Z: S
};
n && (n.C = r);
if (K && !r.De && !((n?.ye ?? 0) & a)) {
r.he = e === undefined ? w : e;
G.add(r);
}
return r;
}
function optimisticSignal(e, t) {
const n = signal(e, t);
n.ee = S;
return n;
}
function optimisticComputed(e, t, n) {
const r = computed(e, t, n);
r.ee = S;
return r;
}
function isEqual(e, t) {
return e === t;
}
function untrack(e, t) {
if (!T && !H && true) return e();
const n = H;
H = false;
try {
if (T) return T.untrack(e);
return e();
} finally {
H = n;
}
}
function read(e) {
if (M) {
const t = getLatestValueComputed(e);
const n = M;
M = false;
const r = e.ee !== undefined && e.ee !== S ? e.ee : e.$;
let i;
try {
i = read(t);
} catch (e) {
if (!V && e instanceof NotReadyError) return r;
throw e;
} finally {
M = n;
}
if (t.ye & a) return r;
if (Q && B && t.Y) {
const e = findLane(t.Y);
const n = findLane(B);
if (e !== n && e.H.size > 0) {
return r;
}
}
return i;
}
if (D) {
const t = e.L;
const n = D;
D = false;
if (t && e.ee !== undefined) {
if (e.ee !== S && (t.Ce || !!(t.ye & a))) {
F = true;
}
let n = V;
if (n?.t) n = n.u;
if (n && H) link(e, n);
read(getPendingSignal(e));
read(getPendingSignal(t));
} else {
if (read(getPendingSignal(e))) F = true;
if (t && read(getPendingSignal(t))) F = true;
}
D = n;
return e.$;
}
let t = V;
if (t?.t) t = t.u;
if (q && e.I) recompute(e);
if (e.m & c) {
e.m &= ~c;
recompute(e, true);
}
const n = e.L || e;
if (t && H) {
if (e.I && e.m & u) recompute(e);
link(e, t);
if (n.I) {
const r = e.m & o;
if (n.o >= (r ? k.j : P.j)) {
markNode(t);
markHeap(r ? k : P);
updateIfNecessary(n);
}
const i = n.o;
if (i >= t.o && e.i !== t) {
t.o = i + 1;
}
}
}
if (n.ye & a) {
if (t && !(Q && n.G && C !== n.G)) {
if (B) {
const r = n.Y;
const i = findLane(B);
if (r && findLane(r) === i && !hasActiveOverride(n)) {
if (!H && e !== t) link(e, t);
throw n.ae;
}
} else {
if (!H && e !== t) link(e, t);
throw n.ae;
}
} else if (t && n !== e && n.ye & h) {
if (!H && e !== t) link(e, t);
throw n.ae;
} else if (!t && n.ye & h) {
throw n.ae;
}
}
if (e.I && e.ye & d) {
if (e.de < E) {
recompute(e);
return read(e);
} else throw e.ae;
}
if (K && t && t.pe) {
const n = e.he;
if (n !== undefined) {
const r = n === w ? undefined : n;
const i = e.Z !== S ? e.Z : e.$;
if (i !== r) t.m |= l;
return r;
}
}
if (e.ee !== undefined && e.ee !== S) {
if (t && Q && shouldReadStashedOptimisticValue(e)) return e.$;
return e.ee;
}
return !t ||
(B !== null && (e.ee !== undefined || e.Y || (n === e && Q) || !!(n.ye & a))) ||
e.Z === S ||
(Q && e.G && C !== e.G)
? e.$
: e.Z;
}
function setSignal(e, t) {
if (e.G && C !== e.G) N.initTransition(e.G);
const n = e.ee !== undefined && !j;
const r = e.ee !== undefined && e.ee !== S;
const i = n ? (r ? e.ee : e.$) : e.Z === S ? e.$ : e.Z;
if (typeof t === "function") t = t(i);
const s = !e.Te || !e.Te(i, t) || !!(e.ye & h);
if (!s) {
if (n && r && e.I) {
insertSubs(e, true);
schedule();
}
return t;
}
if (n) {
const n = e.ee === S;
if (!n) N.initTransition(resolveTransition(e));
if (n) {
e.Z = e.$;
N.U.push(e);
}
e.be = true;
const r = getOrCreateLane(e);
e.Y = r;
e.ee = t;
} else {
if (e.Z === S) N.se.push(e);
e.Z = t;
}
updatePendingSignal(e);
if (e.He) {
setSignal(e.He, t);
}
e.de = E;
insertSubs(e, n);
schedule();
return t;
}
function runWithOwner(e, t) {
const n = V;
const r = H;
V = e;
H = false;
try {
return t();
} finally {
V = n;
H = r;
}
}
function getPendingSignal(e) {
if (!e.Fe) {
e.Fe = optimisticSignal(false, { pureWrite: true });
if (e.we) {
e.Fe.we = e;
}
if (computePendingState(e)) setSignal(e.Fe, true);
}
return e.Fe;
}
function computePendingState(e) {
const t = e;
const n = e.L;
if (n && e.Z !== S) {
return !n.Ce && !(n.ye & a);
}
if (e.ee !== undefined && e.ee !== S) {
if (t.ye & a && !(t.ye & h)) return true;
if (e.we) {
const t = e.Y ? findLane(e.Y) : null;
return !!(t && t.H.size > 0);
}
return true;
}
if (e.ee !== undefined && e.ee === S && !e.we) {
return false;
}
if (e.Z !== S && !(t.ye & h)) return true;
return !!(t.ye & a && !(t.ye & h));
}
function updatePendingSignal(e) {
if (e.Fe) {
const t = computePendingState(e);
const n = e.Fe;
setSignal(n, t);
if (!t && n.Y) {
const t = resolveLane(e);
if (t && t.H.size > 0) {
const e = findLane(n.Y);
if (e !== t) {
mergeLanes(t, e);
}
}
R.delete(n);
n.Y = undefined;
}
}
}
function getLatestValueComputed(e) {
if (!e.He) {
const t = M;
M = false;
const n = D;
D = false;
const r = V;
V = null;
e.He = optimisticComputed(() => read(e));
e.He.we = e;
V = r;
D = n;
M = t;
}
return e.He;
}
function staleValues(e, t = true) {
const n = Q;
Q = t;
try {
return e();
} finally {
Q = n;
}
}
function latest(e) {
const t = M;
M = true;
try {
return e();
} finally {
M = t;
}
}
function isPending(e) {
const t = D;
const n = F;
D = true;
F = false;
try {
e();
return F;
} catch {
return F;
} finally {
D = t;
F = n;
}
}
function refresh(e) {
let t = q;
q = true;
try {
if (typeof e !== "function") {
recompute(e[O]);
return e;
}
return untrack(e);
} finally {
q = t;
if (!t) {
schedule();
}
}
}
function isRefreshing() {
return q;
}
function createContext(e, t) {
return { id: Symbol(t), defaultValue: e };
}
function getContext(e, t = getOwner()) {
if (!t) {
throw new NoOwnerError();
}
const n = hasContext(e, t) ? t.Le[e.id] : e.defaultValue;
if (isUndefined(n)) {
throw new ContextNotFoundError();
}
return n;
}
function setContext(e, t, n = getOwner()) {
if (!n) {
throw new NoOwnerError();
}
n.Le = { ...n.Le, [e.id]: isUndefined(t) ? e.defaultValue : t };
}
function hasContext(e, t) {
return !isUndefined(t?.Le[e.id]);
}
function isUndefined(e) {
return typeof e === "undefined";
}
function effect(e, t, n, r, i) {
let s = false;
const o = computed(i?.render ? t => staleValues(() => e(t)) : e, r, {
...i,
equals: () => {
o.F = !o.ae;
if (s) o.M.enqueue(o.D, runEffect.bind(o));
return false;
},
lazy: true
});
o.Me = r;
o.Ve = t;
o.Be = n;
o.Ke = undefined;
o.D = i?.render ? p : y;
o.Qe = (e, t) => {
const n = e !== undefined ? e : o.ye;
const r = t !== undefined ? t : o.ae;
if (n & d) {
let e = r;
o.M.notify(o, a, 0);
if (o.D === y) {
try {
return o.Be
? o.Be(e, () => {
o.Ke?.();
o.Ke = undefined;
})
: console.error(e);
} catch (t) {
e = t;
}
}
if (!o.M.notify(o, d, d)) throw e;
} else if (o.D === p) {
o.M.notify(o, a | d, n, r);
}
};
recompute(o, true);
!i?.defer && (o.D === y ? o.M.enqueue(o.D, runEffect.bind(o)) : runEffect.call(o));
s = true;
cleanup(() => o.Ke?.());
}
function runEffect() {
if (!this.F || this.m & u) return;
this.Ke?.();
this.Ke = undefined;
try {
const e = this.Ve(this.$, this.Me);
if (false && e !== undefined && typeof e !== "function");
this.Ke = e;
} catch (e) {
this.ae = new StatusError(this, e);
this.ye |= d;
if (!this.M.notify(this, d, d)) throw e;
} finally {
this.Me = this.$;
this.F = false;
}
}
function trackedEffect(e, t) {
const run = () => {
if (!n.F || n.m & u) return;
try {
n.F = false;
recompute(n);
} finally {
}
};
const n = computed(
() => {
n.Ke?.();
n.Ke = undefined;
const t = staleValues(e);
n.Ke = t;
},
undefined,
{ ...t, lazy: true }
);
n.Ke = undefined;
n.Ge = true;
n.F = true;
n.D = g;
n.Qe = (e, t) => {
const r = e !== undefined ? e : n.ye;
if (r & d) {
n.M.notify(n, a, 0);
const e = t !== undefined ? t : n.ae;
if (!n.M.notify(n, d, d)) throw e;
}
};
n.V = run;
n.M.enqueue(y, run);
cleanup(() => n.Ke?.());
}
function restoreTransition(e, t) {
N.initTransition(e);
const n = t();
flush();
return n;
}
function action(e) {
return (...t) =>
new Promise((n, r) => {
const i = e(...t);
N.initTransition();
let s = C;
s.K.push(i);
const done = (e, t) => {
s = currentTransition(s);
const o = s.K.indexOf(i);
if (o >= 0) s.K.splice(o, 1);
setActiveTransition(s);
schedule();
t ? r(t) : n(e);
};
const step = (e, t) => {
let n;
try {
n = t ? i.throw(e) : i.next(e);
} catch (e) {
return done(undefined, e);
}
if (n instanceof Promise)
return void n.then(run, e => restoreTransition(s, () => step(e, true)));
run(n);
};
const run = e => {
if (e.done) return done(e.value);
if (e.value instanceof Promise)
return void e.value.then(
e => restoreTransition(s, () => step(e)),
e => restoreTransition(s, () => step(e, true))
);
restoreTransition(s, () => step(e.value));
};
step();
});
}
function onCleanup(e) {
return cleanup(e);
}
function accessor(e) {
const t = read.bind(null, e);
t.$r = true;
return t;
}
function createSignal(e, t, n) {
if (typeof e === "function") {
const r = computed(e, t, n);
return [accessor(r), setSignal.bind(null, r)];
}
const r = signal(e, t);
return [accessor(r), setSignal.bind(null, r)];
}
function createMemo(e, t, n) {
let r = computed(e, t, n);
return accessor(r);
}
function createEffect(e, t, n, r) {
effect(e, t.effect || t, t.error, n, r);
}
function createRenderEffect(e, t, n, r) {
effect(e, t, undefined, n, { render: true, ...r });
}
function createTrackedEffect(e, t) {
trackedEffect(e, t);
}
function createReaction(e, t) {
let n = undefined;
cleanup(() => n?.());
const r = getOwner();
return i => {
runWithOwner(r, () => {
effect(
() => (i(), getOwner()),
t => {
n?.();
const r = (e.effect || e)?.();
if (false && r !== undefined && typeof r !== "function");
n = r;
dispose(t);
},
e.error,
undefined,
{ defer: true, ...(false ? { ...t, name: t?.name ?? "effect" } : t) }
);
});
};
}
function resolve(e) {
return new Promise((t, n) => {
createRoot(r => {
computed(() => {
try {
t(e());
} catch (e) {
if (e instanceof NotReadyError) throw e;
n(e);
}
r();
});
});
});
}
function createOptimistic(e, t, n) {
if (typeof e === "function") {
const r = optimisticComputed(e, t, n);
return [accessor(r), setSignal.bind(null, r)];
}
const r = optimisticSignal(e, t);
return [accessor(r), setSignal.bind(null, r)];
}
function onSettled(e) {
const t = getOwner();
t && !t.Ge
? createTrackedEffect(() => untrack(e), undefined)
: N.enqueue(y, () => {
const t = e();
t?.();
});
}
function unwrap(e) {
return e?.[U]?.[ee] ?? e;
}
function getOverrideValue(e, t, n, r, i) {
if (i && r in i) return i[r];
return t && r in t ? t[r] : e[r];
}
function getAllKeys(e, t, n) {
const r = getKeys(e, t);
const i = Object.keys(n);
return Array.from(new Set([...r, ...i]));
}
function applyState(e, t, n) {
const r = t?.[U];
if (!r) return;
const i = r[Y];
const s = r[Z];
const o = r[$];
let u = r[ee];
if (e === i && !s && !o) return;
(r[re] || oe).set(e, r[J]);
r[Y] = e;
r[Z] = undefined;
if (Array.isArray(i)) {
let t = false;
const f = getOverrideValue(i, s, u, "length", o);
if (e.length && f && e[0] && n(e[0]) != null) {
let l, c, a, d, h, p, y, g;
for (
a = 0, d = Math.min(f, e.length);
a < d &&
((p = getOverrideValue(i, s, u, a, o)) === e[a] || (p && e[a] && n(p) === n(e[a])));
a++
) {
applyState(e[a], wrap(p, r), n);
}
const S = new Array(e.length),
w = new Map();
for (
d = f - 1, h = e.length - 1;
d >= a &&
h >= a &&
((p = getOverrideValue(i, s, u, d, o)) === e[h] || (p && e[h] && n(p) === n(e[h])));
d--, h--
) {
S[h] = p;
}
if (a > h || a > d) {
for (c = a; c <= h; c++) {
t = true;
r[ee][c] && setSignal(r[ee][c], wrap(e[c], r));
}
for (; c < e.length; c++) {
t = true;
const i = wrap(S[c], r);
r[ee][c] && setSignal(r[ee][c], i);
applyState(e[c], i, n);
}
t && r[ee][z] && setSignal(r[ee][z], void 0);
f !== e.length && r[ee].length && setSignal(r[ee].length, e.length);
return;
}
y = new Array(h + 1);
for (c = h; c >= a; c--) {
p = e[c];
g = p ? n(p) : p;
l = w.get(g);
y[c] = l === undefined ? -1 : l;
w.set(g, c);
}
for (l = a; l <= d; l++) {
p = getOverrideValue(i, s, u, l, o);
g = p ? n(p) : p;
c = w.get(g);
if (c !== undefined && c !== -1) {
S[c] = p;
c = y[c];
w.set(g, c);
}
}
for (c = a; c < e.length; c++) {
if (c in S) {
const t = wrap(S[c], r);
r[ee][c] && setSignal(r[ee][c], t);
applyState(e[c], t, n);
} else r[ee][c] && setSignal(r[ee][c], wrap(e[c], r));
}
if (a < e.length) t = true;
} else if (e.length) {
for (let t = 0, f = e.length; t < f; t++) {
const f = getOverrideValue(i, s, u, t, o);
isWrappable(f) ? applyState(e[t], wrap(f, r), n) : r[ee][t] && setSignal(r[ee][t], e[t]);
}
}
if (f !== e.length) {
t = true;
r[ee].length && setSignal(r[ee].length, e.length);
}
t && r[ee][z] && setSignal(r[ee][z], void 0);
return;
}
if (u) {
const t = u[z];
const f = t ? getAllKeys(i, s, e) : Object.keys(u);
for (let l = 0, c = f.length; l < c; l++) {
const c = f[l];
const a = u[c];
const d = unwrap(getOverrideValue(i, s, u, c, o));
let h = unwrap(e[c]);
if (d === h) continue;
if (!d || !isWrappable(d) || !isWrappable(h) || (n(d) != null && n(d) !== n(h))) {
t && setSignal(t, void 0);
a && setSignal(a, isWrappable(h) ? wrap(h, r) : h);
} else applyState(h, wrap(d, r), n);
}
}
if ((u = r[te])) {
const t = Object.keys(u);
for (let n = 0, r = t.length; n < r; n++) {
const r = t[n];
setSignal(u[r], r in e);
}
}
}
function reconcile(e, t) {
return n => {
if (n == null) throw new Error("Cannot reconcile null or undefined state");
const r = typeof t === "string" ? e => e[t] : t;
const i = r(n);
if (i !== undefined && r(e) !== r(n))
throw new Error("Cannot reconcile states with different identity");
applyState(e, n, r);
};
}
function createProjectionInternal(e, t = {}, n) {
let r;
const i = new WeakMap();
const wrapper = e => {
e[ne] = wrapProjection;
e[re] = i;
Object.defineProperty(e, ie, {
get() {
return r;
},
configurable: true
});
};
const wrapProjection = e => {
if (i.has(e)) return i.get(e);
if (e[U]?.[ne] === wrapProjection) return e;
const t = createStoreProxy(e, le, wrapper);
i.set(e, t);
return t;
};
const s = wrapProjection(t);
r = computed(() => {
const t = getOwner();
let r = false;
let i;
const o = new Proxy(
s,
createWriteTraps(() => !r || t.Ce === i)
);
storeSetter(o, o => {
i = e(o);
r = true;
const u = handleAsync(t, i, e => {
e !== o && e !== undefined && storeSetter(s, reconcile(e, n?.key || "id"));
});
u !== o && u !== undefined && reconcile(u, n?.key || "id")(s);
});
});
r.ve = true;
return { store: s, node: r };
}
function createProjection(e, t = {}, n) {
return createProjectionInternal(e, t, n).store;
}
function createWriteTraps(e) {
const t = {
get(e, n) {
let r;
setWriteOverride(true);
setProjectionWriteActive(true);
try {
r = e[n];
} finally {
setWriteOverride(false);
setProjectionWriteActive(false);
}
return typeof r === "object" && r !== null ? new Proxy(r, t) : r;
},
has(e, t) {
let n;
setWriteOverride(true);
setProjectionWriteActive(true);
try {
n = t in e;
} finally {
setWriteOverride(false);
setProjectionWriteActive(false);
}
return n;
},
set(t, n, r) {
if (e && !e()) return true;
setWriteOverride(true);
setProjectionWriteActive(true);
try {
t[n] = r;
} finally {
setWriteOverride(false);
setProjectionWriteActive(false);
}
return true;
},
deleteProperty(t, n) {
if (e && !e()) return true;
setWriteOverride(true);
setProjectionWriteActive(true);
try {
delete t[n];
} finally {
setWriteOverride(false);
setProjectionWriteActive(false);
}
return true;
}
};
return t;
}
const z = Symbol(0),
U = Symbol(0),
J = Symbol(0),
X = Symbol(0);
const Y = "v",
Z = "o",
$ = "x",
ee = "n",
te = "h",
ne = "w",
re = "l",
ie = "f",
se = "p";
function createStoreProxy(e, t = le, n) {
let r;
if (Array.isArray(e)) {
r = [];
r.v = e;
} else r = { v: e };
n && n(r);
return (r[J] = new Proxy(r, t));
}
const oe = new WeakMap();
function wrap(e, t) {
if (t?.[ne]) return t[ne](e, t);
let n = e[J] || oe.get(e);
if (!n) oe.set(e, (n = createStoreProxy(e)));
return n;
}
function isWrappable(e) {
return (
e != null &&
typeof e === "object" &&
!Object.isFrozen(e) &&
!(typeof Node !== "undefined" && e instanceof Node)
);
}
let ue = false;
function setWriteOverride(e) {
ue = e;
}
function writeOnly(e) {
return ue || !!fe?.has(e);
}
function getNodes(e, t) {
let n = e[t];
if (!n) e[t] = n = Object.create(null);
return n;
}
function getNode(e, t, n, r, i = isEqual, s, o) {
if (e[t]) return e[t];
const u = signal(
n,
{
equals: i,
unobserved() {
delete e[t];
}
},
r
);
if (s) {
u.ee = S;
}
if (o && t in o) {
const e = o[t];
u.he = e === undefined ? w : e;
G?.add(u);
}
return (e[t] = u);
}
function trackSelf(e, t = z) {
getObserver() && read(getNode(getNodes(e, ee), t, undefined, e[ie], false, e[se]));
}
function getKeys(e, t, n = true) {
const r = untrack(() => (n ? Object.keys(e) : Reflect.ownKeys(e)));
if (!t) return r;
const i = new Set(r);
const s = Reflect.ownKeys(t);
for (const e of s) {
if (t[e] !== X) i.add(e);
else i.delete(e);
}
return Array.from(i);
}
function getPropertyDescriptor(e, t, n) {
if (t && n in t) {
if (t[n] === X) return void 0;
const r = Reflect.getOwnPropertyDescriptor(t, n);
if (r?.get || r?.set || !(n in e)) return r;
}
return Reflect.getOwnPropertyDescriptor(e, n);
}
function prepareStoreWrite(e, t, n) {
if (e[se]) {
const t = e[ie];
if (t?.G) {
N.initTransition(t.G);
}
}
const r = e[Y];
const i = r[n];
if (K && typeof n !== "symbol" && !((e[ie]?.ye ?? 0) & a)) {
if (!e[m]) {
e[m] = Object.create(null);
G?.add(e);
}
if (!(n in e[m])) {
e[m][n] = i;
}
}
const s = e[se] && !j;
const o = s ? $ : Z;
if (s) trackOptimisticStore(t);
return { base: i, overrideKey: o, state: r };
}
function notifyStoreProperty(e, t, n, r) {
if (e[te]?.[t]) setSignal(e[te][t], n !== "delete");
const i = getNodes(e, ee);
if (n === "set") {
i[t] && setSignal(i[t], () => (isWrappable(r) ? wrap(r, e) : r));
} else if (n === "invalidate") {
if (i[t]) {
setSignal(i[t], {});
delete i[t];
}
} else {
i[t] && setSignal(i[t], undefined);
}
i[z] && setSignal(i[z], undefined);
}
let fe = null;
const le = {
get(e, t, n) {
if (t === U) return e;
if (t === J) return n;
if (t === O) return e[ie];
if (t === z) {
trackSelf(e);
ret