signalium 2.2.2 → 2.3.0

package/dist/esm/production/{contexts-Dj9Y86xW.js → contexts-X0gSj6rQ.js}

@@ -1,5 +1,6 @@
 import { s as scheduleFlush$1, r as runBatch } from "./config-CPQL7hX-.js";
 class WeakRefPolyfill {
+  value;
   constructor(value) {
     this.value = value;
   }
@@ -15,7 +16,14 @@ const setCurrentConsumer = (consumer) => {
 const getCurrentConsumer = () => {
   return CURRENT_CONSUMER;
 };
-let STATE_ID = 0;
+const DEFAULT_EQUALS = (a, b) => a === b;
+const FALSE_EQUALS = () => false;
+const equalsFrom = (equals) => {
+  if (equals === false) {
+    return FALSE_EQUALS;
+  }
+  return equals ?? DEFAULT_EQUALS;
+};
 class StateSignal {
   _value;
   _equals;
@@ -26,8 +34,6 @@ class StateSignal {
   constructor(value, equals = (a, b) => a === b, desc = "signal") {
     this._value = value;
     this._equals = equals;
-    this._id = STATE_ID++;
-    this._desc = desc;
   }
   get value() {
     this.consume();
@@ -58,7 +64,7 @@ class StateSignal {
       }
       dirtySignal(sub);
     }
-    this._subs = /* @__PURE__ */ new Map();
+    this._subs.clear();
     scheduleListeners(this);
   }
   addListener(listener) {
@@ -79,13 +85,12 @@ function runListeners$1(signal2) {
     listener();
   }
 }
-const FALSE_EQUALS$1 = () => false;
 function signal(initialValue, opts) {
-  const equals = opts?.equals === false ? FALSE_EQUALS$1 : opts?.equals ?? ((a, b) => a === b);
+  const equals = opts?.equals === false ? FALSE_EQUALS : opts?.equals ?? ((a, b) => a === b);
   return new StateSignal(initialValue, equals, opts?.desc);
 }
 const notifier = (opts) => {
-  return new StateSignal(void 0, FALSE_EQUALS$1, opts?.desc);
+  return new StateSignal(void 0, FALSE_EQUALS, opts?.desc);
 };
 function watchSignal(signal2, parentIsSuspended) {
   if (parentIsSuspended) {
@@ -208,7 +213,8 @@ let PENDING_GC = /* @__PURE__ */ new Set();
 const microtask = () => Promise.resolve();
 let currentFlush = null;
 const scheduleFlush = (fn) => {
-  if (currentFlush) return;
+  if (currentFlush)
+    return;
   let resolve;
   const promise = new Promise((r) => resolve = r);
   currentFlush = { promise, resolve };
@@ -241,7 +247,8 @@ const scheduleTracer = (tracer) => {
 };
 const scheduleGcSweep = (scope) => {
   PENDING_GC.add(scope);
-  if (PENDING_GC.size > 1) return;
+  if (PENDING_GC.size > 1)
+    return;
   scheduleIdleCallback(() => {
     for (const scope2 of PENDING_GC) {
       scope2.sweepGc();
@@ -251,6 +258,8 @@ const scheduleGcSweep = (scope) => {
 };
 const flushWatchers = async () => {
   const flush = currentFlush;
+  if (!flush)
+    return;
   while (PENDING_ASYNC_PULLS.length > 0 || PENDING_PULLS.size > 0) {
     const asyncPulls = PENDING_ASYNC_PULLS;
     PENDING_ASYNC_PULLS = [];
@@ -288,19 +297,17 @@ const settled = async () => {
 };
 function dirtySignal(signal2) {
   const prevState = signal2._state;
-  if (prevState === ReactiveFnState.Dirty) {
+  if (prevState === 2) {
     return;
   }
-  signal2._state = ReactiveFnState.Dirty;
-  if (prevState < ReactiveFnState.MaybeDirty) {
+  signal2._state = 2;
+  if (prevState < 3) {
     propagateDirty(signal2);
   }
 }
 function propagateDirty(signal2) {
   if (getCurrentConsumer() === signal2) {
-    throw new Error(
-      "A signal was dirtied after it was consumed by the current function. This can cause race conditions and infinite rerenders and is not allowed."
-    );
+    throw new Error("A signal was dirtied after it was consumed by the current function. This can cause race conditions and infinite rerenders and is not allowed.");
   }
   if (isRelay(signal2)) {
     if (signal2.watchCount > 0) {
@@ -311,31 +318,32 @@ function propagateDirty(signal2) {
       schedulePull(signal2);
     }
     dirtySignalConsumers(signal2.subs);
-    signal2.subs = /* @__PURE__ */ new Map();
+    signal2.subs.clear();
   }
 }
 function dirtySignalConsumers(map) {
   for (const [subRef, edge] of map) {
     const sub = subRef.deref();
-    if (sub === void 0 || sub.computedCount !== edge.consumedAt) continue;
+    if (sub === void 0 || sub.computedCount !== edge.consumedAt)
+      continue;
     const dirtyState = sub._state;
     switch (dirtyState) {
-      case ReactiveFnState.Clean:
-        sub._state = ReactiveFnState.MaybeDirty;
+      case 0:
+        sub._state = 3;
         sub.dirtyHead = edge;
         edge.nextDirty = void 0;
         propagateDirty(sub);
         break;
-      case ReactiveFnState.Pending:
-      case ReactiveFnState.MaybeDirty:
-      case ReactiveFnState.PendingDirty: {
+      case 1:
+      case 3:
+      case 4: {
         let subEdge = sub.dirtyHead;
         const ord = edge.ord;
         if (subEdge.ord > ord) {
           sub.dirtyHead = edge;
           edge.nextDirty = subEdge;
-          if (dirtyState === ReactiveFnState.Pending || dirtyState === ReactiveFnState.PendingDirty) {
-            sub._state = ReactiveFnState.MaybeDirty;
+          if (dirtyState === 1 || dirtyState === 4) {
+            sub._state = 3;
             propagateDirty(sub);
           }
         } else {
@@ -353,21 +361,25 @@ function dirtySignalConsumers(map) {
   }
 }
 let CURRENT_ORD = 0;
-var EdgeType = /* @__PURE__ */ ((EdgeType2) => {
-  EdgeType2[EdgeType2["Signal"] = 0] = "Signal";
-  EdgeType2[EdgeType2["Promise"] = 1] = "Promise";
-  return EdgeType2;
-})(EdgeType || {});
+class EdgeBase {
+  type;
+  dep;
+  ord;
+  updatedAt;
+  consumedAt;
+  nextDirty;
+  constructor(type, dep, updatedAt, consumedAt) {
+    this.type = type;
+    this.dep = dep;
+    this.ord = CURRENT_ORD++;
+    this.updatedAt = updatedAt;
+    this.consumedAt = consumedAt;
+    this.nextDirty = void 0;
+  }
+}
 function createEdge(prevEdge, type, dep, updatedAt, consumedAt) {
   if (prevEdge === void 0) {
-    return {
-      type,
-      dep,
-      ord: CURRENT_ORD++,
-      updatedAt,
-      consumedAt,
-      nextDirty: void 0
-    };
+    return new EdgeBase(type, dep, updatedAt, consumedAt);
   }
   prevEdge.ord = CURRENT_ORD++;
   prevEdge.updatedAt = updatedAt;
@@ -395,14 +407,6 @@ function findAndRemoveDirty(sub, dep) {
   }
   return void 0;
 }
-const DEFAULT_EQUALS = (a, b) => a === b;
-const FALSE_EQUALS = () => false;
-const equalsFrom = (equals) => {
-  if (equals === false) {
-    return FALSE_EQUALS;
-  }
-  return equals ?? DEFAULT_EQUALS;
-};
 const GeneratorResultConstructor = (function* () {
 })().constructor;
 function isGeneratorResult(value) {
@@ -591,12 +595,15 @@ class ReactivePromiseImpl {
     let remaining = len;
     let rejected = false;
     const onFulfillAt = (i) => (v) => {
-      if (rejected) return;
+      if (rejected)
+        return;
       results[i] = v;
-      if (--remaining === 0) p._setValue(results);
+      if (--remaining === 0)
+        p._setValue(results);
     };
     const onReject = (r) => {
-      if (rejected) return;
+      if (rejected)
+        return;
       rejected = true;
       p._setError(r);
     };
@@ -609,15 +616,18 @@ class ReactivePromiseImpl {
     const p = new ReactivePromiseImpl();
     const arr = arrayFrom(values);
     const len = arr.length;
-    if (len === 0) return p;
+    if (len === 0)
+      return p;
     let settled2 = false;
     const onFulfill = (v) => {
-      if (settled2) return;
+      if (settled2)
+        return;
       settled2 = true;
       p._setValue(v);
     };
     const onReject = (r) => {
-      if (settled2) return;
+      if (settled2)
+        return;
       settled2 = true;
       p._setError(r);
     };
@@ -638,12 +648,14 @@ class ReactivePromiseImpl {
     const errors = new Array(len);
     let fulfilled = false;
     const onFulfill = (value) => {
-      if (fulfilled) return;
+      if (fulfilled)
+        return;
       fulfilled = true;
       p._setValue(value);
     };
     const onRejectAt = (index) => (reason) => {
-      if (fulfilled) return;
+      if (fulfilled)
+        return;
       errors[index] = reason;
       if (--pending === 0) {
         p._setError(new AggregateError(errors, "All promises were rejected in ReactivePromise.any"));
@@ -666,11 +678,13 @@ class ReactivePromiseImpl {
     let remaining = len;
     const onFulfillAt = (index) => (value) => {
       results[index] = { status: "fulfilled", value };
-      if (--remaining === 0) p._setValue(results);
+      if (--remaining === 0)
+        p._setValue(results);
     };
     const onRejectAt = (index) => (reason) => {
       results[index] = { status: "rejected", reason };
-      if (--remaining === 0) p._setValue(results);
+      if (--remaining === 0)
+        p._setValue(results);
     };
     for (let i = 0; i < len; i++) {
       thenLoop(arr[i], onFulfillAt(i), onRejectAt(i));
@@ -678,7 +692,8 @@ class ReactivePromiseImpl {
     return p;
   }
   static resolve(value) {
-    if (value instanceof ReactivePromiseImpl) return value;
+    if (value instanceof ReactivePromiseImpl)
+      return value;
     return new ReactivePromiseImpl((resolve) => resolve(value));
   }
   static reject(reason) {
@@ -689,7 +704,7 @@ class ReactivePromiseImpl {
     p._equals = DEFAULT_EQUALS;
     p._initFlags(
       1
-      /* Pending */
+      /* AsyncFlags.Pending */
     );
     const resolve = (value) => {
       if (value && typeof value.then === "function") {
@@ -708,7 +723,8 @@ class ReactivePromiseImpl {
   }
   _consumeFlags(flags) {
     const currentConsumer = getCurrentConsumer();
-    if (currentConsumer === void 0) return;
+    if (currentConsumer === void 0)
+      return;
     if ((this._flags & 128) !== 0) {
       this._connect();
     }
@@ -724,7 +740,7 @@ class ReactivePromiseImpl {
       const { ref, computedCount, deps } = currentConsumer;
       const prevEdge = deps.get(signal2);
       if (prevEdge?.consumedAt !== computedCount) {
-        const newEdge = createEdge(prevEdge, EdgeType.Signal, signal2, signal2.updatedCount, computedCount);
+        const newEdge = createEdge(prevEdge, 0, signal2, signal2.updatedCount, computedCount);
         signal2.subs.set(ref, newEdge);
         deps.set(signal2, newEdge);
       }
@@ -764,7 +780,7 @@ class ReactivePromiseImpl {
     }
     this._setFlags(
       1
-      /* Pending */
+      /* AsyncFlags.Pending */
     );
     dirtySignalConsumers(this._awaitSubs);
     return this._awaitSubs = /* @__PURE__ */ new Map();
@@ -776,10 +792,10 @@ class ReactivePromiseImpl {
     this._promise = promise;
     const flags = this._flags;
     let awaitSubs = this._awaitSubs;
-    if ((flags & 1) === 0) {
-      awaitSubs = this._setPending();
-    }
     try {
+      if ((flags & 1) === 0) {
+        awaitSubs = this._setPending();
+      }
       const nextValue = await promise;
       if (promise !== this._promise) {
         return;
@@ -856,7 +872,7 @@ class ReactivePromiseImpl {
     }
   }
   _scheduleSubs(awaitSubs, dirty) {
-    const newState = dirty ? ReactiveFnState.Dirty : ReactiveFnState.PendingDirty;
+    const newState = dirty ? 2 : 4;
     for (const ref of awaitSubs.keys()) {
       const signal2 = ref.deref();
       if (signal2 === void 0) {
@@ -869,49 +885,49 @@ class ReactivePromiseImpl {
   get value() {
     this._consumeFlags(
       16
-      /* Value */
+      /* AsyncFlags.Value */
     );
     return this._value;
   }
   get error() {
     this._consumeFlags(
       32
-      /* Error */
+      /* AsyncFlags.Error */
     );
     return this._error;
   }
   get isPending() {
     this._consumeFlags(
       1
-      /* Pending */
+      /* AsyncFlags.Pending */
     );
     return (this._flags & 1) !== 0;
   }
   get isRejected() {
     this._consumeFlags(
       2
-      /* Rejected */
+      /* AsyncFlags.Rejected */
     );
     return (this._flags & 2) !== 0;
   }
   get isResolved() {
     this._consumeFlags(
       4
-      /* Resolved */
+      /* AsyncFlags.Resolved */
     );
     return (this._flags & 4) !== 0;
   }
   get isReady() {
     this._consumeFlags(
       8
-      /* Ready */
+      /* AsyncFlags.Ready */
     );
     return (this._flags & 8) !== 0;
   }
   get isSettled() {
     this._consumeFlags(
       6
-      /* Settled */
+      /* AsyncFlags.Settled */
     );
     return (this._flags & 6) !== 0;
   }
@@ -927,13 +943,7 @@ class ReactivePromiseImpl {
         }
         ref = currentConsumer.ref;
         const prevEdge = this._awaitSubs.get(ref) ?? findAndRemoveDirty(currentConsumer, this);
-        edge = createEdge(
-          prevEdge,
-          EdgeType.Promise,
-          this,
-          this._updatedCount,
-          currentConsumer.computedCount
-        );
+        edge = createEdge(prevEdge, 1, this, this._updatedCount, currentConsumer.computedCount);
       }
       const wrappedFulfilled = onfulfilled ? (value) => {
         try {
@@ -969,16 +979,13 @@ class ReactivePromiseImpl {
     return this.then(null, onrejected);
   }
   finally(onfinally) {
-    return this.then(
-      (value) => {
-        onfinally?.();
-        return value;
-      },
-      (reason) => {
-        onfinally?.();
-        throw reason;
-      }
-    );
+    return this.then((value) => {
+      onfinally?.();
+      return value;
+    }, (reason) => {
+      onfinally?.();
+      throw reason;
+    });
   }
   get [Symbol.toStringTag]() {
     return `ReactivePromise`;
@@ -1000,7 +1007,7 @@ function createPromise(promise, signal2) {
   p["_equals"] = signal2.def.equals;
   p["_initFlags"](
     1
-    /* Pending */
+    /* AsyncFlags.Pending */
   );
   p["_setPromise"](promise);
   return p;
@@ -1017,11 +1024,14 @@ function createRelay(activate, scope, opts) {
     }
     const signal2 = p["_signal"];
     signal2.subs = /* @__PURE__ */ new Map();
-    signal2._state = ReactiveFnState.Dirty;
+    signal2._state = 2;
     active = false;
     currentSub = void 0;
   };
   const state = {
+    get isPending() {
+      return (p["_flags"] & 1) !== 0;
+    },
     get value() {
       return p["_value"];
     },
@@ -1059,7 +1069,7 @@ function createRelay(activate, scope, opts) {
   p["_equals"] = equalsFrom(opts?.equals);
   p["_initFlags"](
     128 | 1
-    /* Pending */
+    /* AsyncFlags.Pending */
   );
   return p;
 }
@@ -1069,9 +1079,13 @@ function createTask(task, scope, opts) {
   p["_equals"] = equalsFrom(opts?.equals);
   p["_initFlags"](
     64
-    /* isRunnable */
+    /* AsyncFlags.isRunnable */
   );
+  const throwIfRunning = opts?.throwIfRunning === true;
   p["run"] = ((...args) => {
+    if (throwIfRunning && (p["_flags"] & 1) !== 0) {
+      throw new Error("Task is already running");
+    }
     p._setPromise(fn(...args));
     return p;
   });
@@ -1091,7 +1105,7 @@ function getSignal(signal2) {
         }
       }
       const updatedAt = checkSignal(signal2);
-      const newEdge = createEdge(prevEdge, EdgeType.Signal, signal2, updatedAt, computedCount);
+      const newEdge = createEdge(prevEdge, 0, signal2, updatedAt, computedCount);
       signal2.subs.set(ref, newEdge);
       deps.set(signal2, newEdge);
     } else {
@@ -1107,26 +1121,26 @@ function getSignal(signal2) {
 }
 function checkSignal(signal2) {
   const { ref, _state: state } = signal2;
-  if (state < ReactiveFnState.Dirty) {
+  if (state < 2) {
     return signal2.updatedCount;
   }
-  if (state >= ReactiveFnState.MaybeDirty) {
+  if (state >= 3) {
     let edge = signal2.dirtyHead;
     while (edge !== void 0) {
-      if (edge.type === EdgeType.Promise) {
+      if (edge.type === 1) {
         const dep2 = edge.dep;
         if (dep2._getPending()) {
           const value = signal2._value;
           dep2["_awaitSubs"].set(ref, edge);
           value._setPending();
-          signal2._state = ReactiveFnState.Pending;
+          signal2._state = 1;
           signal2.dirtyHead = edge;
           return signal2.updatedCount;
         } else if (edge.updatedAt === edge.dep._updatedCount) {
           dep2["_awaitSubs"].set(ref, edge);
         } else {
           signal2.dirtyHead = edge.nextDirty;
-          signal2._state = ReactiveFnState.Dirty;
+          signal2._state = 2;
           break;
         }
         edge = edge.nextDirty;
@@ -1137,23 +1151,23 @@ function checkSignal(signal2) {
       dep.subs.set(ref, edge);
       if (edge.updatedAt !== updatedAt) {
         signal2.dirtyHead = edge.nextDirty;
-        signal2._state = ReactiveFnState.Dirty;
+        signal2._state = 2;
         break;
       }
       edge = edge.nextDirty;
     }
   }
   const newState = signal2._state;
-  if (newState === ReactiveFnState.Dirty) {
+  if (newState === 2) {
     if (signal2._isLazy) {
       signal2.updatedCount++;
     } else {
       runSignal(signal2);
     }
-  } else if (newState === ReactiveFnState.PendingDirty) {
+  } else if (newState === 4) {
     signal2._value._clearPending();
   }
-  signal2._state = ReactiveFnState.Clean;
+  signal2._state = 0;
   signal2.dirtyHead = void 0;
   return signal2.updatedCount;
 }
@@ -1322,56 +1336,56 @@ function hashDate(date, _seen) {
   return hashNumber(
     date.getTime(),
     14
-    /* DATE */
+    /* HashType.DATE */
   );
 }
 function hashRegExp(regexp, _seen) {
   const h = hashStr(
     regexp.source + regexp.flags,
     15
-    /* REGEXP */
+    /* HashType.REGEXP */
   );
   return (h ^ regexp.lastIndex) >>> 0;
 }
 const UNDEFINED = hashStr(
   "undefined",
   0
-  /* UNDEFINED */
+  /* HashType.UNDEFINED */
 );
 const NULL = hashStr(
   "null",
   1
-  /* NULL */
+  /* HashType.NULL */
 );
 const TRUE = hashStr(
   "true",
   2
-  /* TRUE */
+  /* HashType.TRUE */
 );
 const FALSE = hashStr(
   "false",
   3
-  /* FALSE */
+  /* HashType.FALSE */
 );
 const ARRAY = hashStr(
   "array",
   7
-  /* ARRAY */
+  /* HashType.ARRAY */
 );
 const OBJECT = hashStr(
   "object",
   8
-  /* OBJECT */
+  /* HashType.OBJECT */
 );
 const SET = hashStr(
   "set",
   13
-  /* SET */
+  /* HashType.SET */
 );
 const MAP = hashStr(
   "map",
   12
-  /* MAP */
+  /* HashType.MAP */
 );
 const getObjectProto = Object.getPrototypeOf;
 const PROTO_TO_HASH = /* @__PURE__ */ new Map([
@@ -1395,19 +1409,19 @@ function hashValue(node, seen = []) {
       return hashStr(
         String(node),
         4
-        /* NUMBER */
+        /* HashType.NUMBER */
       );
     case "string":
       return hashStr(
         node,
         5
-        /* STRING */
+        /* HashType.STRING */
       );
     case "bigint":
       return hashStr(
         node.toString(),
         6
-        /* BIGINT */
+        /* HashType.BIGINT */
       );
     case "object": {
       if (node === null) {
@@ -1418,7 +1432,7 @@ function hashValue(node, seen = []) {
         return hashStr(
           String(index),
           11
-          /* CYCLE */
+          /* HashType.CYCLE */
         );
       }
       const hashFn = PROTO_TO_HASH.get(getObjectProto(node));
@@ -1436,7 +1450,7 @@ function hashValue(node, seen = []) {
       return hashStr(
         node.toString(),
         10
-        /* SYMBOL */
+        /* HashType.SYMBOL */
       );
   }
 }
@@ -1448,7 +1462,7 @@ function getObjectHash(obj) {
     id = hashNumber(
       nextHashMapId++,
       9
-      /* REFERENCE */
+      /* HashType.REFERENCE */
     );
     objectToHashMap.set(obj, id);
   }
@@ -1465,25 +1479,16 @@ function hashReactiveFn(fn, args) {
   h = h << 13 | h >>> 19;
   return imul(h, 5) + 3864292196 >>> 0;
 }
-var ReactiveFnState = /* @__PURE__ */ ((ReactiveFnState2) => {
-  ReactiveFnState2[ReactiveFnState2["Clean"] = 0] = "Clean";
-  ReactiveFnState2[ReactiveFnState2["Pending"] = 1] = "Pending";
-  ReactiveFnState2[ReactiveFnState2["Dirty"] = 2] = "Dirty";
-  ReactiveFnState2[ReactiveFnState2["MaybeDirty"] = 3] = "MaybeDirty";
-  ReactiveFnState2[ReactiveFnState2["PendingDirty"] = 4] = "PendingDirty";
-  return ReactiveFnState2;
-})(ReactiveFnState || {});
 let ID = 0;
 function createReactiveDefinition(id, desc, compute, equals, isRelay2, paramKey, tracer) {
-  return {
-    id,
-    desc,
+  const def = {
     compute,
     equals: equalsFrom(equals),
     isRelay: isRelay2,
     paramKey,
-    tracer
+    tracer: void 0
   };
+  return def;
 }
 class ReactiveSignal {
   // Bitmask containing state in the first 2 bits and boolean properties in the remaining bits
@@ -1552,22 +1557,33 @@ class ReactiveSignal {
   get listeners() {
     return this._listeners ?? (this._listeners = {
       updatedAt: 0,
-      current: /* @__PURE__ */ new Set(),
+      current: /* @__PURE__ */ new Map(),
       cachedBoundAdd: this.addListener.bind(this)
     });
   }
   get value() {
     return getSignal(this);
   }
-  addListener(listener) {
+  addListener(listener, opts) {
     const { current } = this.listeners;
     if (!current.has(listener)) {
+      let effective = listener;
+      if (opts?.skipInitial) {
+        let initial = true;
+        effective = () => {
+          if (initial) {
+            initial = false;
+            return;
+          }
+          listener();
+        };
+      }
       if (!this._isListener) {
         watchSignal(this, this._isSuspended);
         this.flags |= 16;
       }
       schedulePull(this);
-      current.add(listener);
+      current.set(listener, effective);
     }
     return () => {
       if (current.has(listener)) {
@@ -1576,6 +1592,7 @@ class ReactiveSignal {
           cancelPull(this);
           unwatchSignal(this, this._isSuspended);
           this.flags &= -17;
+          this.listeners.updatedAt = 0;
         }
       }
     };
@@ -1623,7 +1640,7 @@ const runListeners = (signal2) => {
     return;
   }
   const { current } = listeners;
-  for (const listener of current) {
+  for (const listener of current.values()) {
     listener();
   }
 };
@@ -1635,13 +1652,14 @@ function createReactiveSignal(def, args = [], key, scope) {
 }
 let CONTEXT_ID = 0;
 class ContextImpl {
+  defaultValue;
+  _key;
+  _description;
   constructor(defaultValue, desc) {
     this.defaultValue = defaultValue;
     this._description = desc ?? `context:${CONTEXT_ID++}`;
     this._key = Symbol(this._description);
   }
-  _key;
-  _description;
 }
 const context = (initialValue, description) => {
   return new ContextImpl(initialValue, description);
@@ -1659,9 +1677,7 @@ function withContexts(contexts, fn) {
 const getContext = (context2) => {
   const scope = CURRENT_SCOPE ?? getCurrentConsumer()?.scope;
   if (scope === void 0) {
-    throw new Error(
-      "getContext must be used within a reactive function, a withContext, or within a framework-specific context provider."
-    );
+    throw new Error("getContext must be used within a reactive function, a withContext, or within a framework-specific context provider.");
   }
   return scope.getContext(context2) ?? context2.defaultValue;
 };
@@ -1792,9 +1808,9 @@ export {
   getCurrentConsumer as f,
   getCurrentScope as g,
   getGlobalScope as h,
-  hashValue as i,
-  signal as j,
-  isReactivePromise as k,
+  isReactivePromise as i,
+  hashValue as j,
+  signal as k,
   isRelay$1 as l,
   getSignal as m,
   isPromise as n,
@@ -1811,4 +1827,4 @@ export {
   getContext as y,
   withContexts as z
 };
-//# sourceMappingURL=contexts-Dj9Y86xW.js.map
+//# sourceMappingURL=contexts-X0gSj6rQ.js.map