@solidjs/signals
Version:
SolidJS' standalone reactivity implementation
2,043 lines • 87.3 kB
JavaScript
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 REACTIVE_NONE = 0;
const REACTIVE_CHECK = 1 << 0;
const REACTIVE_DIRTY = 1 << 1;
const REACTIVE_RECOMPUTING_DEPS = 1 << 2;
const REACTIVE_IN_HEAP = 1 << 3;
const REACTIVE_IN_HEAP_HEIGHT = 1 << 4;
const REACTIVE_ZOMBIE = 1 << 5;
const REACTIVE_DISPOSED = 1 << 6;
const REACTIVE_OPTIMISTIC_DIRTY = 1 << 7;
const REACTIVE_SNAPSHOT_STALE = 1 << 8;
const REACTIVE_LAZY = 1 << 9;
const STATUS_PENDING = 1 << 0;
const STATUS_ERROR = 1 << 1;
const STATUS_UNINITIALIZED = 1 << 2;
const EFFECT_RENDER = 1;
const EFFECT_USER = 2;
const EFFECT_TRACKED = 3;
const NOT_PENDING = {};
const NO_SNAPSHOT = {};
const STORE_SNAPSHOT_PROPS = "sp";
const SUPPORTS_PROXY = typeof Proxy === "function";
const defaultContext = {};
const $REFRESH = 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 i = e.o;
const r = t.l[i];
if (r === undefined) t.l[i] = e;
else {
const t = r.T;
t.S = e;
e.T = t;
r.T = e;
}
if (i > t.R) t.R = i;
}
function insertIntoHeap(e, t) {
let n = e.O;
if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS)) return;
if (n & REACTIVE_CHECK) {
e.O = (n & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
} else e.O = n | REACTIVE_IN_HEAP;
if (!(n & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(e, t);
}
function insertIntoHeapHeight(e, t) {
let n = e.O;
if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT)) return;
e.O = n | REACTIVE_IN_HEAP_HEIGHT;
actualInsertIntoHeap(e, t);
}
function deleteFromHeap(e, t) {
const n = e.O;
if (!(n & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
e.O = n & -25;
const i = e.o;
if (e.T === e) t.l[i] = undefined;
else {
const n = e.S;
const r = t.l[i];
const s = n ?? r;
if (e === r) t.l[i] = n;
else e.T.S = n;
s.T = e.T;
}
e.T = e;
e.S = undefined;
}
function markHeap(e) {
if (e._) return;
e._ = true;
for (let t = 0; t <= e.R; t++) {
for (let n = e.l[t]; n !== undefined; n = n.S) {
if (n.O & REACTIVE_IN_HEAP) markNode(n);
}
}
}
function markNode(e, t = REACTIVE_DIRTY) {
const n = e.O;
if ((n & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= t) return;
e.O = (n & -4) | t;
for (let t = e.I; t !== null; t = t.h) {
markNode(t.p, REACTIVE_CHECK);
}
if (e.A !== null) {
for (let t = e.A; t !== null; t = t.N) {
for (let e = t.I; e !== null; e = e.h) {
markNode(e.p, REACTIVE_CHECK);
}
}
}
}
function runHeap(e, t) {
e._ = false;
for (e.P = 0; e.P <= e.R; e.P++) {
let n = e.l[e.P];
while (n !== undefined) {
if (n.O & REACTIVE_IN_HEAP) t(n);
else adjustHeight(n, e);
n = e.l[e.P];
}
}
e.R = 0;
}
function adjustHeight(e, t) {
deleteFromHeap(e, t);
let n = e.o;
for (let t = e.C; t; t = t.D) {
const e = t.m;
const i = e.V || e;
if (i.L && i.o >= n) n = i.o + 1;
}
if (e.o !== n) {
e.o = n;
for (let n = e.I; n !== null; n = n.h) {
insertIntoHeapHeight(n.p, t);
}
}
}
const DEV$1 = undefined;
const transitions = new Set();
const dirtyQueue = { l: new Array(2e3).fill(undefined), _: false, P: 0, R: 0 };
const zombieQueue = { l: new Array(2e3).fill(undefined), _: false, P: 0, R: 0 };
let clock = 0;
let activeTransition = null;
let scheduled = false;
let projectionWriteActive = false;
let stashedOptimisticReads = null;
function enforceLoadingBoundary(e) {}
function shouldReadStashedOptimisticValue(e) {
return !!stashedOptimisticReads?.has(e);
}
function runLaneEffects(e) {
for (const t of activeLanes) {
if (t.U || t.k.size > 0) continue;
const n = t.G[e - 1];
if (n.length) {
t.G[e - 1] = [];
runQueue(n, e);
}
}
}
function queueStashedOptimisticEffects(e) {
for (let t = e.I; t !== null; t = t.h) {
const e = t.p;
if (!e.W) continue;
if (e.W === EFFECT_TRACKED) {
if (!e.H) {
e.H = true;
e.F.enqueue(EFFECT_USER, e.M);
}
continue;
}
const n = e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
if (n.P > e.o) n.P = e.o;
insertIntoHeap(e, n);
}
}
function setProjectionWriteActive(e) {
projectionWriteActive = e;
}
function mergeTransitionState(e, t) {
t.j = e;
e.$.push(...t.$);
for (const n of activeLanes) if (n.K === t) n.K = e;
e.Y.push(...t.Y);
for (const n of t.Z) e.Z.add(n);
for (const [n, i] of t.B) {
let t = e.B.get(n);
if (!t) e.B.set(n, (t = new Set()));
for (const e of i) t.add(e);
}
}
function resolveOptimisticNodes(e) {
for (let t = 0; t < e.length; t++) {
const n = e[t];
n.q = undefined;
if (n.X !== NOT_PENDING) {
n.J = n.X;
n.X = NOT_PENDING;
}
const i = n.ee;
n.ee = NOT_PENDING;
if (i !== NOT_PENDING && n.J !== i) insertSubs(n, true);
n.K = null;
}
e.length = 0;
}
function cleanupCompletedLanes(e) {
for (const t of activeLanes) {
const n = e ? t.K === e : !t.K;
if (!n) continue;
if (!t.U) {
if (t.G[0].length) runQueue(t.G[0], EFFECT_RENDER);
if (t.G[1].length) runQueue(t.G[1], EFFECT_USER);
}
if (t.te.q === t) t.te.q = undefined;
t.k.clear();
t.G[0].length = 0;
t.G[1].length = 0;
activeLanes.delete(t);
signalLanes.delete(t.te);
}
}
function schedule() {
if (scheduled) return;
scheduled = true;
if (!globalQueue.ne && !projectionWriteActive) queueMicrotask(flush);
}
class Queue {
i = null;
ie = [[], []];
re = [];
created = clock;
addChild(e) {
this.re.push(e);
e.i = this;
}
removeChild(e) {
const t = this.re.indexOf(e);
if (t >= 0) {
this.re.splice(t, 1);
e.i = null;
}
}
notify(e, t, n, i) {
if (this.i) return this.i.notify(e, t, n, i);
return false;
}
run(e) {
if (this.ie[e - 1].length) {
const t = this.ie[e - 1];
this.ie[e - 1] = [];
runQueue(t, e);
}
for (let t = 0; t < this.re.length; t++) this.re[t].run?.(e);
}
enqueue(e, t) {
if (e) {
if (currentOptimisticLane) {
const n = findLane(currentOptimisticLane);
n.G[e - 1].push(t);
} else {
this.ie[e - 1].push(t);
}
}
schedule();
}
stashQueues(e) {
e.ie[0].push(...this.ie[0]);
e.ie[1].push(...this.ie[1]);
this.ie = [[], []];
for (let t = 0; t < this.re.length; t++) {
let n = this.re[t];
let i = e.re[t];
if (!i) {
i = { ie: [[], []], re: [] };
e.re[t] = i;
}
n.stashQueues(i);
}
}
restoreQueues(e) {
this.ie[0].push(...e.ie[0]);
this.ie[1].push(...e.ie[1]);
for (let t = 0; t < e.re.length; t++) {
const n = e.re[t];
let i = this.re[t];
if (i) i.restoreQueues(n);
}
}
}
class GlobalQueue extends Queue {
ne = false;
se = [];
Y = [];
Z = new Set();
static oe;
static ue;
static ce = null;
flush() {
if (this.ne) return;
this.ne = true;
try {
runHeap(dirtyQueue, GlobalQueue.oe);
if (activeTransition) {
const e = transitionComplete(activeTransition);
if (!e) {
const e = activeTransition;
runHeap(zombieQueue, GlobalQueue.oe);
this.se = [];
this.Y = [];
this.Z = new Set();
runLaneEffects(EFFECT_RENDER);
runLaneEffects(EFFECT_USER);
this.stashQueues(e.ae);
clock++;
scheduled = dirtyQueue.R >= dirtyQueue.P;
reassignPendingTransition(e.se);
activeTransition = null;
if (!e.$.length && e.Y.length) {
stashedOptimisticReads = new Set();
for (let t = 0; t < e.Y.length; t++) {
const n = e.Y[t];
if (n.L || n.le) continue;
stashedOptimisticReads.add(n);
queueStashedOptimisticEffects(n);
}
}
try {
finalizePureQueue(null, true);
} finally {
stashedOptimisticReads = null;
}
return;
}
this.se !== activeTransition.se && this.se.push(...activeTransition.se);
this.restoreQueues(activeTransition.ae);
transitions.delete(activeTransition);
const t = activeTransition;
activeTransition = null;
reassignPendingTransition(this.se);
finalizePureQueue(t);
} else {
if (transitions.size) runHeap(zombieQueue, GlobalQueue.oe);
finalizePureQueue();
}
clock++;
scheduled = dirtyQueue.R >= dirtyQueue.P;
runLaneEffects(EFFECT_RENDER);
this.run(EFFECT_RENDER);
runLaneEffects(EFFECT_USER);
this.run(EFFECT_USER);
if (false);
} finally {
this.ne = false;
}
}
notify(e, t, n, i) {
if (t & STATUS_PENDING) {
if (n & STATUS_PENDING) {
const t = i !== undefined ? i : e.fe;
if (activeTransition && t) {
const n = t.source;
let i = activeTransition.B.get(n);
if (!i) activeTransition.B.set(n, (i = new Set()));
const r = i.size;
i.add(e);
if (i.size !== r) schedule();
}
}
return true;
}
return false;
}
initTransition(e) {
if (e) e = currentTransition(e);
if (e && e === activeTransition) return;
if (!e && activeTransition && activeTransition.Ee === clock) return;
if (!activeTransition) {
activeTransition = e ?? {
Ee: clock,
se: [],
B: new Map(),
Y: [],
Z: new Set(),
$: [],
ae: { ie: [[], []], re: [] },
j: false
};
} else if (e) {
const t = activeTransition;
mergeTransitionState(e, t);
transitions.delete(t);
activeTransition = e;
}
transitions.add(activeTransition);
activeTransition.Ee = clock;
if (this.se !== activeTransition.se) {
for (let e = 0; e < this.se.length; e++) {
const t = this.se[e];
t.K = activeTransition;
activeTransition.se.push(t);
}
this.se = activeTransition.se;
}
if (this.Y !== activeTransition.Y) {
for (let e = 0; e < this.Y.length; e++) {
const t = this.Y[e];
t.K = activeTransition;
activeTransition.Y.push(t);
}
this.Y = activeTransition.Y;
}
for (const e of activeLanes) {
if (!e.K) e.K = activeTransition;
}
if (this.Z !== activeTransition.Z) {
for (const e of this.Z) activeTransition.Z.add(e);
this.Z = activeTransition.Z;
}
}
}
function insertSubs(e, t = false) {
const n = e.q || currentOptimisticLane;
const i = e.de !== undefined;
for (let r = e.I; r !== null; r = r.h) {
if (i && r.p.Te) {
r.p.O |= REACTIVE_SNAPSHOT_STALE;
continue;
}
if (t && n) {
r.p.O |= REACTIVE_OPTIMISTIC_DIRTY;
assignOrMergeLane(r.p, n);
} else if (t) {
r.p.O |= REACTIVE_OPTIMISTIC_DIRTY;
r.p.q = undefined;
}
const e = r.p;
if (e.W === EFFECT_TRACKED) {
if (!e.H) {
e.H = true;
e.F.enqueue(EFFECT_USER, e.M);
}
continue;
}
const s = r.p.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
if (s.P > r.p.o) s.P = r.p.o;
insertIntoHeap(r.p, s);
}
}
function commitPendingNodes() {
const e = globalQueue.se;
for (let t = 0; t < e.length; t++) {
const n = e[t];
if (n.X !== NOT_PENDING) {
n.J = n.X;
n.X = NOT_PENDING;
if (n.W && n.W !== EFFECT_TRACKED) n.H = true;
}
if (!(n.Se & STATUS_PENDING)) n.Se &= ~STATUS_UNINITIALIZED;
if (n.L) GlobalQueue.ue(n, false, true);
}
e.length = 0;
}
function finalizePureQueue(e = null, t = false) {
const n = !t;
if (n) commitPendingNodes();
if (!t) checkBoundaryChildren(globalQueue);
if (dirtyQueue.R >= dirtyQueue.P) runHeap(dirtyQueue, GlobalQueue.oe);
if (n) {
commitPendingNodes();
resolveOptimisticNodes(e ? e.Y : globalQueue.Y);
const t = e ? e.Z : globalQueue.Z;
if (GlobalQueue.ce && t.size) {
for (const e of t) {
GlobalQueue.ce(e);
}
t.clear();
schedule();
}
cleanupCompletedLanes(e);
}
}
function checkBoundaryChildren(e) {
for (const t of e.re) {
t.checkSources?.();
checkBoundaryChildren(t);
}
}
function trackOptimisticStore(e) {
globalQueue.Z.add(e);
schedule();
}
function reassignPendingTransition(e) {
for (let t = 0; t < e.length; t++) {
e[t].K = activeTransition;
}
}
const globalQueue = new GlobalQueue();
function flush() {
if (globalQueue.ne) {
return;
}
while (scheduled || activeTransition) {
globalQueue.flush();
}
}
function runQueue(e, t) {
for (let n = 0; n < e.length; n++) e[n](t);
}
function reporterBlocksSource(e, t) {
if (e.O & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
if (e.Re === t || e.Oe?.has(t)) return true;
for (let n = e.C; n; n = n.D) {
let e = n.m;
while (e) {
if (e === t || e.V === t) return true;
e = e._e;
}
}
return !!(e.Se & STATUS_PENDING && e.fe instanceof NotReadyError && e.fe.source === t);
}
function transitionComplete(e) {
if (e.j) return true;
if (e.$.length) return false;
let t = true;
for (const [n, i] of e.B) {
let r = false;
for (const e of i) {
if (reporterBlocksSource(e, n)) {
r = true;
break;
}
i.delete(e);
}
if (!r) e.B.delete(n);
else if (n.Se & STATUS_PENDING && n.fe?.source === n) {
t = false;
break;
}
}
if (t) {
for (let n = 0; n < e.Y.length; n++) {
const i = e.Y[n];
if (
hasActiveOverride(i) &&
"Se" in i &&
i.Se & STATUS_PENDING &&
i.fe instanceof NotReadyError &&
i.fe.source !== i
) {
t = false;
break;
}
}
}
t && (e.j = true);
return t;
}
function currentTransition(e) {
while (e.j && typeof e.j === "object") e = e.j;
return e;
}
function setActiveTransition(e) {
activeTransition = e;
}
function runInTransition(e, t) {
const n = activeTransition;
try {
activeTransition = currentTransition(e);
return t();
} finally {
activeTransition = n;
}
}
const signalLanes = new WeakMap();
const activeLanes = new Set();
function getOrCreateLane(e) {
let t = signalLanes.get(e);
if (t) {
return findLane(t);
}
const n = e._e;
const i = n?.q ? findLane(n.q) : null;
t = { te: e, k: new Set(), G: [[], []], U: null, K: activeTransition, Ie: i };
signalLanes.set(e, t);
activeLanes.add(t);
e.he = false;
return t;
}
function findLane(e) {
while (e.U) e = e.U;
return e;
}
function mergeLanes(e, t) {
e = findLane(e);
t = findLane(t);
if (e === t) return e;
t.U = e;
for (const n of t.k) e.k.add(n);
e.G[0].push(...t.G[0]);
e.G[1].push(...t.G[1]);
return e;
}
function resolveLane(e) {
const t = e.q;
if (!t) return undefined;
const n = findLane(t);
if (activeLanes.has(n)) return n;
e.q = undefined;
return undefined;
}
function resolveTransition(e) {
return resolveLane(e)?.K ?? e.K;
}
function hasActiveOverride(e) {
return !!(e.ee !== undefined && e.ee !== NOT_PENDING);
}
function assignOrMergeLane(e, t) {
const n = findLane(t);
const i = e.q;
if (i) {
if (i.U) {
e.q = t;
return;
}
const r = findLane(i);
if (activeLanes.has(r)) {
if (r !== n && !hasActiveOverride(e)) {
if (n.Ie && findLane(n.Ie) === r) {
e.q = t;
} else if (r.Ie && findLane(r.Ie) === n);
else mergeLanes(n, r);
}
return;
}
}
e.q = t;
}
function unlinkSubs(e) {
const t = e.m;
const n = e.D;
const i = e.h;
const r = e.pe;
if (i !== null) i.pe = r;
else t.Ae = r;
if (r !== null) r.h = i;
else {
t.I = i;
if (i === null) {
t.Ne?.();
t.L && !t.Pe && !(t.O & REACTIVE_ZOMBIE) && unobserved(t);
}
}
return n;
}
function unobserved(e) {
deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
let t = e.C;
while (t !== null) {
t = unlinkSubs(t);
}
e.C = null;
disposeChildren(e, true);
}
function link(e, t) {
const n = t.ge;
if (n !== null && n.m === e) return;
let i = null;
const r = t.O & REACTIVE_RECOMPUTING_DEPS;
if (r) {
i = n !== null ? n.D : t.C;
if (i !== null && i.m === e) {
t.ge = i;
return;
}
}
const s = e.Ae;
if (s !== null && s.p === t && (!r || isValidLink(s, t))) return;
const o = (t.ge = e.Ae = { m: e, p: t, D: i, pe: s, h: null });
if (n !== null) n.D = o;
else t.C = o;
if (s !== null) s.h = o;
else e.I = o;
}
function isValidLink(e, t) {
const n = t.ge;
if (n !== null) {
let i = t.C;
do {
if (i === e) return true;
if (i === n) break;
i = i.D;
} while (i !== null);
}
return false;
}
const PENDING_OWNER = {};
function markDisposal(e) {
let t = e.Ce;
while (t) {
t.O |= REACTIVE_ZOMBIE;
if (t.O & REACTIVE_IN_HEAP) {
deleteFromHeap(t, dirtyQueue);
insertIntoHeap(t, zombieQueue);
}
markDisposal(t);
t = t.De;
}
}
function dispose(e) {
let t = e.C || null;
do {
t = unlinkSubs(t);
} while (t !== null);
e.C = null;
e.ge = null;
disposeChildren(e, true);
}
function disposeChildren(e, t = false, n) {
if (e.O & REACTIVE_DISPOSED) return;
if (t) e.O = REACTIVE_DISPOSED;
if (t && e.L) e.ye = null;
let i = n ? e.ve : e.Ce;
while (i) {
const e = i.De;
if (i.C) {
const e = i;
deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
let t = e.C;
do {
t = unlinkSubs(t);
} while (t !== null);
e.C = null;
e.ge = null;
}
disposeChildren(i, true);
i = e;
}
if (n) {
e.ve = null;
} else {
e.Ce = null;
e.me = 0;
}
runDisposal(e, n);
}
function runDisposal(e, t) {
let n = t ? e.we : e.Ve;
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.we = null) : (e.Ve = null);
}
function childId(e, t) {
let n = e;
while (n.be && n.i) n = n.i;
if (n.id != null) return formatId(n.id, t ? n.me++ : n.me);
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),
i = n.length - 1;
return e + (i ? String.fromCharCode(64 + i) : "") + n;
}
function getObserver() {
if (pendingCheckActive || latestReadActive) return PENDING_OWNER;
return tracking ? context : null;
}
function getOwner() {
return context;
}
function cleanup(e) {
if (!context) return e;
if (!context.Ve) context.Ve = e;
else if (Array.isArray(context.Ve)) context.Ve.push(e);
else context.Ve = [context.Ve, e];
return e;
}
function isDisposed(e) {
return !!(e.O & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
}
function createOwner(e) {
const t = context;
const n = e?.transparent ?? false;
const i = {
id: e?.id ?? (n ? t?.id : t?.id != null ? getNextChildId(t) : undefined),
be: n || undefined,
t: true,
u: t?.t ? t.u : t,
Ce: null,
De: null,
Ve: null,
F: t?.F ?? globalQueue,
Le: t?.Le || defaultContext,
me: 0,
we: null,
ve: null,
i: t,
dispose(e = true) {
disposeChildren(i, e);
}
};
if (t) {
const e = t.Ce;
if (e === null) {
t.Ce = i;
} else {
i.De = e;
t.Ce = i;
}
}
return i;
}
function createRoot(e, t) {
const n = createOwner(t);
return runWithOwner(n, () => e(n.dispose));
}
function addPendingSource(e, t) {
if (e.Re === t || e.Oe?.has(t)) return false;
if (!e.Re) {
e.Re = t;
return true;
}
if (!e.Oe) {
e.Oe = new Set([e.Re, t]);
} else {
e.Oe.add(t);
}
e.Re = undefined;
return true;
}
function removePendingSource(e, t) {
if (e.Re) {
if (e.Re !== t) return false;
e.Re = undefined;
return true;
}
if (!e.Oe?.delete(t)) return false;
if (e.Oe.size === 1) {
e.Re = e.Oe.values().next().value;
e.Oe = undefined;
} else if (e.Oe.size === 0) {
e.Oe = undefined;
}
return true;
}
function clearPendingSources(e) {
e.Re = undefined;
e.Oe?.clear();
e.Oe = undefined;
}
function setPendingError(e, t, n) {
if (!t) {
e.fe = null;
return;
}
if (n instanceof NotReadyError && n.source === t) {
e.fe = n;
return;
}
const i = e.fe;
if (!(i instanceof NotReadyError) || i.source !== t) {
e.fe = new NotReadyError(t);
}
}
function forEachDependent(e, t) {
for (let n = e.I; n !== null; n = n.h) t(n.p);
for (let n = e.A; n !== null; n = n.N) {
for (let e = n.I; e !== null; e = e.h) t(e.p);
}
}
function settlePendingSource(e) {
let t = false;
const n = new Set();
const settle = i => {
if (n.has(i) || !removePendingSource(i, e)) return;
n.add(i);
i.Ee = clock;
const r = i.Re ?? i.Oe?.values().next().value;
if (r) {
setPendingError(i, r);
updatePendingSignal(i);
} else {
i.Se &= ~STATUS_PENDING;
setPendingError(i);
updatePendingSignal(i);
if (i.Ue) {
if (i.W === EFFECT_TRACKED) {
const e = i;
if (!e.H) {
e.H = true;
e.F.enqueue(EFFECT_USER, e.M);
}
} else {
const e = i.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
if (e.P > i.o) e.P = i.o;
insertIntoHeap(i, e);
}
t = true;
}
i.Ue = false;
}
forEachDependent(i, settle);
};
forEachDependent(e, settle);
if (t) schedule();
}
function handleAsync(e, t, n) {
const i = typeof t === "object" && t !== null;
const r = i && untrack(() => t[Symbol.asyncIterator]);
const s = !r && i && untrack(() => typeof t.then === "function");
if (!s && !r) {
e.ye = null;
return t;
}
e.ye = t;
let o;
const handleError = n => {
if (e.ye !== t) return;
globalQueue.initTransition(resolveTransition(e));
notifyStatus(e, n instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, n);
e.Ee = clock;
};
const asyncWrite = (i, r) => {
if (e.ye !== t) return;
if (e.O & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
globalQueue.initTransition(resolveTransition(e));
const s = !!(e.Se & STATUS_UNINITIALIZED);
clearStatus(e);
const o = resolveLane(e);
if (o) o.k.delete(e);
if (n) n(i);
else if (e.ee !== undefined) {
if (e.ee !== undefined && e.ee !== NOT_PENDING) e.X = i;
else {
e.J = i;
insertSubs(e);
}
e.Ee = clock;
} else if (o) {
const t = e.W;
const n = e.J;
const r = e.ke;
if ((!t && s) || !r || !r(i, n)) {
e.J = i;
e.Ee = clock;
if (e.xe) {
setSignal(e.xe, i);
}
insertSubs(e, true);
}
} else {
setSignal(e, () => i);
}
settlePendingSource(e);
schedule();
flush();
r?.();
};
if (s) {
let n = false,
i = true;
t.then(
e => {
if (i) {
o = e;
n = true;
} else asyncWrite(e);
},
e => {
if (!i) handleError(e);
}
);
i = false;
if (!n) {
globalQueue.initTransition(resolveTransition(e));
throw new NotReadyError(context);
}
}
if (r) {
const n = t[Symbol.asyncIterator]();
let i = false;
let r = false;
cleanup(() => {
if (r) return;
r = true;
try {
const e = n.return?.();
if (e && typeof e.then === "function") {
e.then(undefined, () => {});
}
} catch {}
});
const iterate = () => {
let s,
u = false,
c = true;
n.next().then(
n => {
if (c) {
s = n;
u = true;
if (n.done) r = true;
} else if (e.ye !== t) {
return;
} else if (!n.done) asyncWrite(n.value, iterate);
else {
r = true;
schedule();
flush();
}
},
n => {
if (!c && e.ye === t) {
r = true;
handleError(n);
}
}
);
c = false;
if (u && !s.done) {
o = s.value;
i = true;
return iterate();
}
return u && s.done;
};
const s = iterate();
if (!i && !s) {
globalQueue.initTransition(resolveTransition(e));
throw new NotReadyError(context);
}
}
return o;
}
function clearStatus(e, t = false) {
clearPendingSources(e);
e.Ue = false;
e.Se = t ? 0 : e.Se & STATUS_UNINITIALIZED;
setPendingError(e);
updatePendingSignal(e);
e.Ge?.();
}
function notifyStatus(e, t, n, i, r) {
if (t === STATUS_ERROR && !(n instanceof StatusError) && !(n instanceof NotReadyError))
n = new StatusError(e, n);
const s = t === STATUS_PENDING && n instanceof NotReadyError ? n.source : undefined;
const o = s === e;
const u = t === STATUS_PENDING && e.ee !== undefined && !o;
const c = u && hasActiveOverride(e);
if (!i) {
if (t === STATUS_PENDING && s) {
addPendingSource(e, s);
e.Se = STATUS_PENDING | (e.Se & STATUS_UNINITIALIZED);
setPendingError(e, s, n);
} else {
clearPendingSources(e);
e.Se = t | (t !== STATUS_ERROR ? e.Se & STATUS_UNINITIALIZED : 0);
e.fe = n;
}
updatePendingSignal(e);
}
if (r && !i) {
assignOrMergeLane(e, r);
}
const a = i || c;
const l = i || u ? undefined : r;
if (e.Ge) {
if (i && t === STATUS_PENDING) {
return;
}
if (a) {
e.Ge(t, n);
} else {
e.Ge();
}
return;
}
forEachDependent(e, e => {
e.Ee = clock;
if (
(t === STATUS_PENDING && s && e.Re !== s && !e.Oe?.has(s)) ||
(t !== STATUS_PENDING && (e.fe !== n || e.Re || e.Oe))
) {
if (!a && !e.K) globalQueue.se.push(e);
notifyStatus(e, t, n, a, l);
}
});
}
let externalSourceConfig = null;
function enableExternalSource(e) {
const { factory: t, untrack: n = e => e() } = e;
if (externalSourceConfig) {
const { factory: e, untrack: i } = externalSourceConfig;
externalSourceConfig = {
factory: (n, i) => {
const r = e(n, i);
const s = t(e => r.track(e), i);
return {
track: e => s.track(e),
dispose() {
s.dispose();
r.dispose();
}
};
},
untrack: e => i(() => n(e))
};
} else {
externalSourceConfig = { factory: t, untrack: n };
}
}
GlobalQueue.oe = recompute;
GlobalQueue.ue = disposeChildren;
let tracking = false;
let stale = false;
let refreshing = false;
let pendingCheckActive = false;
let foundPending = false;
let latestReadActive = false;
let context = null;
let currentOptimisticLane = null;
let snapshotCaptureActive = false;
let snapshotSources = null;
function ownerInSnapshotScope(e) {
while (e) {
if (e.We) return true;
e = e.i;
}
return false;
}
function setSnapshotCapture(e) {
snapshotCaptureActive = e;
if (e && !snapshotSources) snapshotSources = new Set();
}
function markSnapshotScope(e) {
e.We = true;
}
function releaseSnapshotScope(e) {
e.We = false;
releaseSubtree(e);
schedule();
}
function releaseSubtree(e) {
let t = e.Ce;
while (t) {
if (t.We) {
t = t.De;
continue;
}
if (t.L) {
const e = t;
e.Te = false;
if (e.O & REACTIVE_SNAPSHOT_STALE) {
e.O &= ~REACTIVE_SNAPSHOT_STALE;
e.O |= REACTIVE_DIRTY;
if (dirtyQueue.P > e.o) dirtyQueue.P = e.o;
insertIntoHeap(e, dirtyQueue);
}
}
releaseSubtree(t);
t = t.De;
}
}
function clearSnapshots() {
if (snapshotSources) {
for (const e of snapshotSources) {
delete e.de;
delete e[STORE_SNAPSHOT_PROPS];
}
snapshotSources = null;
}
snapshotCaptureActive = false;
}
function recompute(e, t = false) {
const n = e.W;
if (!t) {
if (e.K && (!n || activeTransition) && activeTransition !== e.K)
globalQueue.initTransition(e.K);
deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
e.ye = null;
if (e.K || n === EFFECT_TRACKED) disposeChildren(e);
else {
markDisposal(e);
e.we = e.Ve;
e.ve = e.Ce;
e.Ve = null;
e.Ce = null;
e.me = 0;
}
}
const i = !!(e.O & REACTIVE_OPTIMISTIC_DIRTY);
const r = e.ee !== undefined && e.ee !== NOT_PENDING;
const s = !!(e.Se & STATUS_PENDING);
const o = !!(e.Se & STATUS_UNINITIALIZED);
const u = context;
context = e;
e.ge = null;
e.O = REACTIVE_RECOMPUTING_DEPS;
e.Ee = clock;
let c = e.X === NOT_PENDING ? e.J : e.X;
let a = e.o;
let l = tracking;
let f = currentOptimisticLane;
tracking = true;
if (i) {
const t = resolveLane(e);
if (t) currentOptimisticLane = t;
}
try {
c = handleAsync(e, e.L(c));
clearStatus(e, t);
const n = resolveLane(e);
if (n) {
n.k.delete(e);
updatePendingSignal(n.te);
}
} catch (t) {
if (t instanceof NotReadyError && currentOptimisticLane) {
const t = findLane(currentOptimisticLane);
if (t.te !== e) {
t.k.add(e);
e.q = t;
updatePendingSignal(t.te);
}
}
if (t instanceof NotReadyError) e.Ue = true;
notifyStatus(
e,
t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
t,
undefined,
t instanceof NotReadyError ? e.q : undefined
);
} finally {
tracking = l;
e.O = REACTIVE_NONE | (t ? e.O & REACTIVE_SNAPSHOT_STALE : 0);
context = u;
}
if (!e.fe) {
const u = e.ge;
let l = u !== null ? u.D : e.C;
if (l !== null) {
do {
l = unlinkSubs(l);
} while (l !== null);
if (u !== null) u.D = null;
else e.C = null;
}
const f = r ? e.ee : e.X === NOT_PENDING ? e.J : e.X;
const E = (!n && o) || !e.ke || !e.ke(f, c);
if (E) {
const o = r ? e.ee : undefined;
if (t || (n && activeTransition !== e.K) || i) {
e.J = c;
if (r && i) {
e.ee = c;
e.X = c;
}
} else e.X = c;
if (r && !i && s && !e.he) e.ee = c;
if (!r || i || e.ee !== o) insertSubs(e, i || r);
} else if (r) {
e.X = c;
} else if (e.o != a) {
for (let t = e.I; t !== null; t = t.h) {
insertIntoHeapHeight(t.p, t.p.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
}
}
}
currentOptimisticLane = f;
(!t || e.Se & STATUS_PENDING) && !e.K && !(activeTransition && r) && globalQueue.se.push(e);
e.K && n && activeTransition !== e.K && runInTransition(e.K, () => recompute(e));
}
function updateIfNecessary(e) {
if (e.O & REACTIVE_CHECK) {
for (let t = e.C; t; t = t.D) {
const n = t.m;
const i = n.V || n;
if (i.L) {
updateIfNecessary(i);
}
if (e.O & REACTIVE_DIRTY) {
break;
}
}
}
if (e.O & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (e.fe && e.Ee < clock && !e.ye)) {
recompute(e);
}
e.O = e.O & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
}
function computed(e, t, n) {
const i = n?.transparent ?? false;
const r = {
id: n?.id ?? (i ? context?.id : context?.id != null ? getNextChildId(context) : undefined),
be: i || undefined,
ke: n?.equals != null ? n.equals : isEqual,
le: !!n?.pureWrite,
Ne: n?.unobserved,
Ve: null,
F: context?.F ?? globalQueue,
Le: context?.Le ?? defaultContext,
me: 0,
L: e,
J: t,
o: 0,
A: null,
S: undefined,
T: null,
C: null,
ge: null,
I: null,
Ae: null,
i: context,
De: null,
Ce: null,
O: n?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
Se: STATUS_UNINITIALIZED,
Ee: clock,
X: NOT_PENDING,
we: null,
ve: null,
ye: null,
K: null
};
r.T = r;
const s = context?.t ? context.u : context;
if (context) {
const e = context.Ce;
if (e === null) {
context.Ce = r;
} else {
r.De = e;
context.Ce = r;
}
}
if (s) r.o = s.o + 1;
if (snapshotCaptureActive && ownerInSnapshotScope(context)) r.Te = true;
if (externalSourceConfig) {
const e = signal(undefined, { equals: false, pureWrite: true });
const t = externalSourceConfig.factory(r.L, () => {
setSignal(e, undefined);
});
cleanup(() => t.dispose());
r.L = n => {
read(e);
return t.track(n);
};
}
!n?.lazy && recompute(r, true);
if (snapshotCaptureActive && !n?.lazy) {
if (!(r.Se & STATUS_PENDING)) {
r.de = r.J === undefined ? NO_SNAPSHOT : r.J;
snapshotSources.add(r);
}
}
return r;
}
function signal(e, t, n = null) {
const i = {
ke: t?.equals != null ? t.equals : isEqual,
le: !!t?.pureWrite,
He: !!t?.He,
Ne: t?.unobserved,
J: e,
I: null,
Ae: null,
Ee: clock,
V: n,
N: n?.A || null,
X: NOT_PENDING
};
n && (n.A = i);
if (snapshotCaptureActive && !i.He && !((n?.Se ?? 0) & STATUS_PENDING)) {
i.de = e === undefined ? NO_SNAPSHOT : e;
snapshotSources.add(i);
}
return i;
}
function optimisticSignal(e, t) {
const n = signal(e, t);
n.ee = NOT_PENDING;
return n;
}
function optimisticComputed(e, t, n) {
const i = computed(e, t, n);
i.ee = NOT_PENDING;
return i;
}
function isEqual(e, t) {
return e === t;
}
function untrack(e, t) {
if (!externalSourceConfig && !tracking && true) return e();
const n = tracking;
tracking = false;
try {
if (externalSourceConfig) return externalSourceConfig.untrack(e);
return e();
} finally {
tracking = n;
}
}
function read(e) {
if (latestReadActive) {
const t = getLatestValueComputed(e);
const n = latestReadActive;
latestReadActive = false;
const i = e.ee !== undefined && e.ee !== NOT_PENDING ? e.ee : e.J;
let r;
try {
r = read(t);
} catch (e) {
if (!context && e instanceof NotReadyError) return i;
throw e;
} finally {
latestReadActive = n;
}
if (t.Se & STATUS_PENDING) return i;
if (stale && currentOptimisticLane && t.q) {
const e = findLane(t.q);
const n = findLane(currentOptimisticLane);
if (e !== n && e.k.size > 0) {
return i;
}
}
return r;
}
if (pendingCheckActive) {
const t = e.V;
const n = pendingCheckActive;
pendingCheckActive = false;
if (t && e.ee !== undefined) {
if (e.ee !== NOT_PENDING && (t.ye || !!(t.Se & STATUS_PENDING))) {
foundPending = true;
}
let n = context;
if (n?.t) n = n.u;
if (n && tracking) link(e, n);
read(getPendingSignal(e));
read(getPendingSignal(t));
} else {
if (read(getPendingSignal(e))) foundPending = true;
if (t && read(getPendingSignal(t))) foundPending = true;
}
pendingCheckActive = n;
return e.J;
}
let t = context;
if (t?.t) t = t.u;
if (refreshing && e.L) recompute(e);
if (e.O & REACTIVE_LAZY) {
e.O &= ~REACTIVE_LAZY;
recompute(e, true);
}
const n = e.V || e;
if (t && tracking) {
if (e.L && e.O & REACTIVE_DISPOSED) recompute(e);
link(e, t);
if (n.L) {
const i = e.O & REACTIVE_ZOMBIE;
if (n.o >= (i ? zombieQueue.P : dirtyQueue.P)) {
markNode(t);
markHeap(i ? zombieQueue : dirtyQueue);
updateIfNecessary(n);
}
const r = n.o;
if (r >= t.o && e.i !== t) {
t.o = r + 1;
}
}
}
if (n.Se & STATUS_PENDING) {
if (t && !(stale && n.K && activeTransition !== n.K)) {
if (currentOptimisticLane) {
const i = n.q;
const r = findLane(currentOptimisticLane);
if (i && findLane(i) === r && !hasActiveOverride(n)) {
if (!tracking && e !== t) link(e, t);
throw n.fe;
}
} else {
if (!tracking && e !== t) link(e, t);
throw n.fe;
}
} else if (t && n !== e && n.Se & STATUS_UNINITIALIZED) {
if (!tracking && e !== t) link(e, t);
throw n.fe;
} else if (!t && n.Se & STATUS_UNINITIALIZED) {
throw n.fe;
}
}
if (e.L && e.Se & STATUS_ERROR) {
if (e.Ee < clock) {
recompute(e);
return read(e);
} else throw e.fe;
}
if (snapshotCaptureActive && t && t.Te) {
const n = e.de;
if (n !== undefined) {
const i = n === NO_SNAPSHOT ? undefined : n;
const r = e.X !== NOT_PENDING ? e.X : e.J;
if (r !== i) t.O |= REACTIVE_SNAPSHOT_STALE;
return i;
}
}
if (e.ee !== undefined && e.ee !== NOT_PENDING) {
if (t && stale && shouldReadStashedOptimisticValue(e)) return e.J;
return e.ee;
}
return !t ||
(currentOptimisticLane !== null &&
(e.ee !== undefined || e.q || (n === e && stale) || !!(n.Se & STATUS_PENDING))) ||
e.X === NOT_PENDING ||
(stale && e.K && activeTransition !== e.K)
? e.J
: e.X;
}
function setSignal(e, t) {
if (e.K && activeTransition !== e.K) globalQueue.initTransition(e.K);
const n = e.ee !== undefined && !projectionWriteActive;
const i = e.ee !== undefined && e.ee !== NOT_PENDING;
const r = n ? (i ? e.ee : e.J) : e.X === NOT_PENDING ? e.J : e.X;
if (typeof t === "function") t = t(r);
const s = !e.ke || !e.ke(r, t) || !!(e.Se & STATUS_UNINITIALIZED);
if (!s) {
if (n && i && e.L) {
insertSubs(e, true);
schedule();
}
return t;
}
if (n) {
const n = e.ee === NOT_PENDING;
if (!n) globalQueue.initTransition(resolveTransition(e));
if (n) {
e.X = e.J;
globalQueue.Y.push(e);
}
e.he = true;
const i = getOrCreateLane(e);
e.q = i;
e.ee = t;
} else {
if (e.X === NOT_PENDING) globalQueue.se.push(e);
e.X = t;
}
updatePendingSignal(e);
if (e.xe) {
setSignal(e.xe, t);
}
e.Ee = clock;
insertSubs(e, n);
schedule();
return t;
}
function runWithOwner(e, t) {
const n = context;
const i = tracking;
context = e;
tracking = false;
try {
return t();
} finally {
context = n;
tracking = i;
}
}
function getPendingSignal(e) {
if (!e.Fe) {
e.Fe = optimisticSignal(false, { pureWrite: true });
if (e._e) {
e.Fe._e = e;
}
if (computePendingState(e)) setSignal(e.Fe, true);
}
return e.Fe;
}
function computePendingState(e) {
const t = e;
const n = e.V;
if (n && e.X !== NOT_PENDING) {
return !n.ye && !(n.Se & STATUS_PENDING);
}
if (e.ee !== undefined && e.ee !== NOT_PENDING) {
if (t.Se & STATUS_PENDING && !(t.Se & STATUS_UNINITIALIZED)) return true;
if (e._e) {
const t = e.q ? findLane(e.q) : null;
return !!(t && t.k.size > 0);
}
return true;
}
if (e.ee !== undefined && e.ee === NOT_PENDING && !e._e) {
return false;
}
if (e.X !== NOT_PENDING && !(t.Se & STATUS_UNINITIALIZED)) return true;
return !!(t.Se & STATUS_PENDING && !(t.Se & STATUS_UNINITIALIZED));
}
function updatePendingSignal(e) {
if (e.Fe) {
const t = computePendingState(e);
const n = e.Fe;
setSignal(n, t);
if (!t && n.q) {
const t = resolveLane(e);
if (t && t.k.size > 0) {
const e = findLane(n.q);
if (e !== t) {
mergeLanes(t, e);
}
}
signalLanes.delete(n);
n.q = undefined;
}
}
}
function getLatestValueComputed(e) {
if (!e.xe) {
const t = latestReadActive;
latestReadActive = false;
const n = pendingCheckActive;
pendingCheckActive = false;
const i = context;
context = null;
e.xe = optimisticComputed(() => read(e));
e.xe._e = e;
context = i;
pendingCheckActive = n;
latestReadActive = t;
}
return e.xe;
}
function staleValues(e, t = true) {
const n = stale;
stale = t;
try {
return e();
} finally {
stale = n;
}
}
function latest(e) {
const t = latestReadActive;
latestReadActive = true;
try {
return e();
} finally {
latestReadActive = t;
}
}
function isPending(e) {
const t = pendingCheckActive;
const n = foundPending;
pendingCheckActive = true;
foundPending = false;
try {
e();
return foundPending;
} catch {
return foundPending;
} finally {
pendingCheckActive = t;
foundPending = n;
}
}
function refresh(e) {
let t = refreshing;
refreshing = true;
try {
if (typeof e !== "function") {
recompute(e[$REFRESH]);
return e;
}
return untrack(e);
} finally {
refreshing = t;
if (!t) {
schedule();
}
}
}
function isRefreshing() {
return refreshing;
}
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, i, r) {
let s = false;
const o = computed(r?.render ? t => staleValues(() => e(t)) : e, i, {
...r,
equals: () => {
o.H = !o.fe;
if (s) o.F.enqueue(o.W, runEffect.bind(o));
return false;
},
lazy: true
});
o.Qe = i;
o.Me = t;
o.je = n;
o.$e = undefined;
o.W = r?.render ? EFFECT_RENDER : EFFECT_USER;
o.Ge = (e, t) => {
const n = e !== undefined ? e : o.Se;
const i = t !== undefined ? t : o.fe;
if (n & STATUS_ERROR) {
let e = i;
o.F.notify(o, STATUS_PENDING, 0);
if (o.W === EFFECT_USER) {
try {
return o.je
? o.je(e, () => {
o.$e?.();
o.$e = undefined;
})
: console.error(e);
} catch (t) {
e = t;
}
}
if (!o.F.notify(o, STATUS_ERROR, STATUS_ERROR)) throw e;
} else if (o.W === EFFECT_RENDER) {
o.F.notify(o, STATUS_PENDING | STATUS_ERROR, n, i);
}
};
recompute(o, true);
!r?.defer && (o.W === EFFECT_USER ? o.F.enqueue(o.W, runEffect.bind(o)) : runEffect.call(o));
s = true;
cleanup(() => o.$e?.());
}
function runEffect() {
if (!this.H || this.O & REACTIVE_DISPOSED) return;
this.$e?.();
this.$e = undefined;
try {
const e = this.Me(this.J, this.Qe);
if (false && e !== undefined && typeof e !== "function");
this.$e = e;
} catch (e) {
this.fe = new StatusError(this, e);
this.Se |= STATUS_ERROR;
if (!this.F.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
} finally {
this.Qe = this.J;
this.H = false;
}
}
function trackedEffect(e, t) {
const run = () => {
if (!n.H || n.O & REACTIVE_DISPOSED) return;
try {
n.H = false;
recompute(n);
} finally {
}
};
const n = computed(
() => {
n.$e?.();
n.$e = undefined;
const t = staleValues(e);
n.$e = t;
},
undefined,
{ ...t, lazy: true }
);
n.$e = undefined;
n.Ke = true;
n.H = true;
n.W = EFFECT_TRACKED;
n.Ge = (e, t) => {
const i = e !== undefined ? e : n.Se;
if (i & STATUS_ERROR) {
n.F.notify(n, STATUS_PENDING, 0);
const e = t !== undefined ? t : n.fe;
if (!n.F.notify(n, STATUS_ERROR, STATUS_ERROR)) throw e;
}
};
n.M = run;
n.F.enqueue(EFFECT_USER, run);
cleanup(() => n.$e?.());
}
function restoreTransition(e, t) {
globalQueue.initTransition(e);
const n = t();
flush();
return n;
}
function action(e) {
return (...t) =>
new Promise((n, i) => {
const r = e(...t);
globalQueue.initTransition();
let s = activeTransition;
s.$.push(r);
const done = (e, t) => {
s = currentTransition(s);
const o = s.$.indexOf(r);
if (o >= 0) s.$.splice(o, 1);
setActiveTransition(s);
schedule();
t ? i(t) : n(e);
};
const step = (e, t) => {
let n;
try {
n = t ? r.throw(e) : r.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 i = computed(e, t, n);
return [accessor(i), setSignal.bind(null, i)];
}
const i = signal(e, t);
return [accessor(i), setSignal.bind(null, i)];
}
function createMemo(e, t, n) {
let i = computed(e, t, n);
return accessor(i);
}
function createEffect(e, t, n, i) {
effect(e, t.effect || t, t.error, n, i);
}
function createRenderEffect(e, t, n, i) {
effect(e, t, undefined, n, { render: true, ...i });
}
function createTrackedEffect(e, t) {
trackedEffect(e, t);
}
function createReaction(e, t) {
let n = undefined;
cleanup(() => n?.());
const i = getOwner();
return r => {
runWithOwner(i, () => {
effect(
() => (r(), getOwner()),
t => {
n?.();
const i = (e.effect || e)?.();
if (false && i !== undefined && typeof i !== "function");
n = i;
dispose(t);
},
e.error,
undefined,
{ defer: true, ...(false ? { ...t, name: t?.name ?? "effect" } : t) }
);
});
};
}
function resolve(e) {
return new Promise((t, n) => {
createRoot(i => {
computed(() => {
try {
t(e());
} catch (e) {
if (e instanceof NotReadyError) throw e;
n(e);
}
i();
});
});
});
}
function createOptimistic(e, t, n) {
if (typeof e === "function") {
const i = optimisticComputed(e, t, n);
return [accessor(i), setSignal.bind(null, i)];
}
const i = optimisticSignal(e, t);
return [accessor(i), setSignal.bind(null, i)];
}
function onSettled(e) {
const t = getOwner();
t && !t.Ke
? createTrackedEffect(() => untrack(e), undefined)
: globalQueue.enqueue(EFFECT_USER, () => {
const t = e();
t?.();
});
}
function unwrap(e) {
return e?.[$TARGET]?.[STORE_NODE] ?? e;
}
function getOverrideValue(e, t, n, i, r) {
if (r && i in r) return r[i];
return t && i in t ? t[i] : e[i];
}
function getAllKeys(e, t, n) {
const i = getKeys(e, t);
const r = Object.keys(n);
return Array.from(new Set([...i, ...r]));
}
function applyState(e, t, n) {
const i = t?.[$TARGET];
if (!i) return;
const r = i[STORE_VALUE];
const s = i[STORE_OVERRIDE];
const o = i[STORE_OPTIMISTIC_OVERRIDE];
let u = i[STORE_NODE];
if (e === r && !s && !o) return;
(i[STORE_LOOKUP] || storeLookup).set(e, i[$PROXY]);
i[STORE_VALUE] = e;
i[STORE_OVERRIDE] = undefined;
if (Array.isArray(r)) {
let t = false;
const c = getOverrideValue(r, s, u, "length", o);
if (e.length && c && e[0] && n(e[0]) != null) {
let a, l, f, E, d, T, S, R;
for (
f = 0, E = Math.min(c, e.length);
f < E &&
((T = getOverrideValue(r, s, u, f, o)) === e[f] || (T && e[f] && n(T) === n(e[f])));
f++
) {
applyState(e[f], wrap(T, i), n);
}
const O = new Array(e.length),
_ = new Map();
for (
E = c - 1, d = e.length - 1;
E >= f &&
d >= f &&
((T = getOverrideValue(r, s, u, E, o)) === e[d] || (T && e[d] && n(T) === n(e[d])));
E--, d--
) {
O[d] = T;
}
if (f > d || f > E) {
for (l = f; l <= d; l++) {
t = true;
i[STORE_NODE][l] && setSignal(i[STORE_NODE][l], wrap(e[l], i));
}
for (; l < e.length; l++) {
t = true;
const r = wrap(O[l], i);
i[STORE_NODE][l] && setSignal(i[STORE_NODE][l], r);
applyState(e[l], r, n);
}
t && i[STORE_NODE][$TRACK] && setSignal(i[STORE_NODE][$TRACK], void 0);
c !== e.length && i[STORE_NODE].length && setSignal(i[STORE_NODE].length, e.length);
return;
}
S = new Array(d + 1);
for (l = d; l >= f; l--) {
T = e[l];
R = T ? n(T) : T;
a = _.get(R);
S[l] = a === undefined ? -1 : a;
_.set(R, l);
}
for (a = f; a <= E; a++) {
T = getOverrideValue(r, s, u, a, o);
R = T ? n(T) : T;
l = _.get(R);
if (l !== undefined && l !== -1) {
O[l] = T;
l = S[l];
_.set(R, l);
}
}
for (l = f; l < e.length; l++) {
if (l in O) {
const t = wrap(O[l], i);
i[STORE_NODE][l] && setSignal(i[STORE_NODE][l], t);
applyState(e[l], t, n);
} else i[STORE_NODE][l] && setSignal(i[STORE_NODE][l], wrap(e[l], i));
}
if (f < e.length) t = true;
} else if (e.length) {
for (let t = 0, c = e.length; t < c; t++) {
const c = getOverrideValue(r, s,