@solidjs/signals 0.0.1

package/dist/prod.js

@@ -0,0 +1,1403 @@
+// src/core/error.ts
+var NotReadyError = class extends Error {
+};
+var NoOwnerError = class extends Error {
+  constructor() {
+    super(
+      ""
+    );
+  }
+};
+var ContextNotFoundError = class extends Error {
+  constructor() {
+    super(
+      ""
+    );
+  }
+};
+
+// src/utils.ts
+function isUndefined(value) {
+  return typeof value === "undefined";
+}
+
+// src/core/constants.ts
+var STATE_CLEAN = 0;
+var STATE_CHECK = 1;
+var STATE_DIRTY = 2;
+var STATE_DISPOSED = 3;
+var EFFECT_PURE = 0;
+var EFFECT_RENDER = 1;
+var EFFECT_USER = 2;
+var SUPPORTS_PROXY = typeof Proxy === "function";
+
+// src/core/owner.ts
+var currentOwner = null;
+var defaultContext = {};
+function getOwner() {
+  return currentOwner;
+}
+function setOwner(owner) {
+  const out = currentOwner;
+  currentOwner = owner;
+  return out;
+}
+var Owner = class {
+  // We flatten the owner tree into a linked list so that we don't need a pointer to .firstChild
+  // However, the children are actually added in reverse creation order
+  // See comment at the top of the file for an example of the _nextSibling traversal
+  q = null;
+  l = null;
+  o = null;
+  a = STATE_CLEAN;
+  g = null;
+  m = defaultContext;
+  h = null;
+  e = null;
+  constructor(signal = false) {
+    if (currentOwner && !signal)
+      currentOwner.append(this);
+  }
+  append(child) {
+    child.q = this;
+    child.o = this;
+    if (this.l)
+      this.l.o = child;
+    child.l = this.l;
+    this.l = child;
+    if (child.m !== this.m) {
+      child.m = { ...this.m, ...child.m };
+    }
+    if (this.h) {
+      child.h = !child.h ? this.h : [...child.h, ...this.h];
+    }
+    if (this.e)
+      child.e = this.e;
+  }
+  dispose(self = true) {
+    if (this.a === STATE_DISPOSED)
+      return;
+    let head = self ? this.o || this.q : this, current = this.l, next = null;
+    while (current && current.q === this) {
+      current.dispose(true);
+      current.w();
+      next = current.l;
+      current.l = null;
+      current = next;
+    }
+    if (self)
+      this.w();
+    if (current)
+      current.o = !self ? this : this.o;
+    if (head)
+      head.l = current;
+  }
+  w() {
+    if (this.o)
+      this.o.l = null;
+    this.q = null;
+    this.o = null;
+    this.m = defaultContext;
+    this.h = null;
+    this.a = STATE_DISPOSED;
+    this.emptyDisposal();
+  }
+  emptyDisposal() {
+    if (!this.g)
+      return;
+    if (Array.isArray(this.g)) {
+      for (let i = 0; i < this.g.length; i++) {
+        const callable = this.g[i];
+        callable.call(callable);
+      }
+    } else {
+      this.g.call(this.g);
+    }
+    this.g = null;
+  }
+  handleError(error) {
+    if (!this.h)
+      throw error;
+    let i = 0, len = this.h.length;
+    for (i = 0; i < len; i++) {
+      try {
+        this.h[i](error);
+        break;
+      } catch (e) {
+        error = e;
+      }
+    }
+    if (i === len)
+      throw error;
+  }
+};
+function createContext(defaultValue, description) {
+  return { id: Symbol(description), defaultValue };
+}
+function getContext(context, owner = currentOwner) {
+  if (!owner) {
+    throw new NoOwnerError();
+  }
+  const value = hasContext(context, owner) ? owner.m[context.id] : context.defaultValue;
+  if (isUndefined(value)) {
+    throw new ContextNotFoundError();
+  }
+  return value;
+}
+function setContext(context, value, owner = currentOwner) {
+  if (!owner) {
+    throw new NoOwnerError();
+  }
+  owner.m = {
+    ...owner.m,
+    [context.id]: isUndefined(value) ? context.defaultValue : value
+  };
+}
+function hasContext(context, owner = currentOwner) {
+  return !isUndefined(owner?.m[context.id]);
+}
+function onCleanup(disposable) {
+  if (!currentOwner)
+    return;
+  const node = currentOwner;
+  if (!node.g) {
+    node.g = disposable;
+  } else if (Array.isArray(node.g)) {
+    node.g.push(disposable);
+  } else {
+    node.g = [node.g, disposable];
+  }
+}
+
+// src/core/flags.ts
+var ERROR_OFFSET = 0;
+var ERROR_BIT = 1 << ERROR_OFFSET;
+var LOADING_OFFSET = 1;
+var LOADING_BIT = 1 << LOADING_OFFSET;
+var DEFAULT_FLAGS = ERROR_BIT;
+
+// src/core/core.ts
+var currentObserver = null;
+var currentMask = DEFAULT_FLAGS;
+var newSources = null;
+var newSourcesIndex = 0;
+var newFlags = 0;
+var clock = 0;
+var syncResolve = false;
+var updateCheck = null;
+function getObserver() {
+  return currentObserver;
+}
+function incrementClock() {
+  clock++;
+}
+var UNCHANGED = Symbol(0);
+var Computation = class extends Owner {
+  b = null;
+  c = null;
+  d;
+  C;
+  // Used in __DEV__ mode, hopefully removed in production
+  U;
+  // Using false is an optimization as an alternative to _equals: () => false
+  // which could enable more efficient DIRTY notification
+  D = isEqual;
+  N;
+  /** Whether the computation is an error or has ancestors that are unresolved */
+  i = 0;
+  /** Which flags raised by sources are handled, vs. being passed through. */
+  A = DEFAULT_FLAGS;
+  E = null;
+  F = null;
+  G = -1;
+  constructor(initialValue, compute2, options) {
+    super(compute2 === null);
+    this.C = compute2;
+    this.a = compute2 ? STATE_DIRTY : STATE_CLEAN;
+    this.d = initialValue;
+    if (options?.equals !== void 0)
+      this.D = options.equals;
+    if (options?.unobserved)
+      this.N = options?.unobserved;
+  }
+  O() {
+    if (this.C)
+      this.r();
+    if (!this.b || this.b.length)
+      track(this);
+    newFlags |= this.i & ~currentMask;
+    if (this.i & ERROR_BIT) {
+      throw this.d;
+    } else {
+      return this.d;
+    }
+  }
+  /**
+   * Return the current value of this computation
+   * Automatically re-executes the surrounding computation when the value changes
+   */
+  read() {
+    return this.O();
+  }
+  /**
+   * Return the current value of this computation
+   * Automatically re-executes the surrounding computation when the value changes
+   *
+   * If the computation has any unresolved ancestors, this function waits for the value to resolve
+   * before continuing
+   */
+  wait() {
+    if (!syncResolve && this.loading()) {
+      throw new NotReadyError();
+    }
+    return this.O();
+  }
+  /**
+   * Return true if the computation is the value is dependent on an unresolved promise
+   * Triggers re-execution of the computation when the loading state changes
+   *
+   * This is useful especially when effects want to re-execute when a computation's
+   * loading state changes
+   */
+  loading() {
+    if (this.F === null) {
+      this.F = loadingState(this);
+    }
+    return this.F.read();
+  }
+  /**
+   * Return true if the computation is the computation threw an error
+   * Triggers re-execution of the computation when the error state changes
+   */
+  error() {
+    if (this.E === null) {
+      this.E = errorState(this);
+    }
+    return this.E.read();
+  }
+  /** Update the computation with a new value. */
+  write(value, flags = 0, raw = false) {
+    const newValue = !raw && typeof value === "function" ? value(this.d) : value;
+    const valueChanged = newValue !== UNCHANGED && (!!(flags & ERROR_BIT) || this.D === false || !this.D(this.d, newValue));
+    if (valueChanged)
+      this.d = newValue;
+    const changedFlagsMask = this.i ^ flags, changedFlags = changedFlagsMask & flags;
+    this.i = flags;
+    this.G = clock + 1;
+    if (this.c) {
+      for (let i = 0; i < this.c.length; i++) {
+        if (valueChanged) {
+          this.c[i].s(STATE_DIRTY);
+        } else if (changedFlagsMask) {
+          this.c[i].P(changedFlagsMask, changedFlags);
+        }
+      }
+    }
+    return this.d;
+  }
+  /**
+   * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
+   */
+  s(state) {
+    if (this.a >= state)
+      return;
+    this.a = state;
+    if (this.c) {
+      for (let i = 0; i < this.c.length; i++) {
+        this.c[i].s(STATE_CHECK);
+      }
+    }
+  }
+  /**
+   * Notify the computation that one of its sources has changed flags.
+   *
+   * @param mask A bitmask for which flag(s) were changed.
+   * @param newFlags The source's new flags, masked to just the changed ones.
+   */
+  P(mask, newFlags2) {
+    if (this.a >= STATE_DIRTY)
+      return;
+    if (mask & this.A) {
+      this.s(STATE_DIRTY);
+      return;
+    }
+    if (this.a >= STATE_CHECK)
+      return;
+    const prevFlags = this.i & mask;
+    const deltaFlags = prevFlags ^ newFlags2;
+    if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
+      this.s(STATE_CHECK);
+    } else {
+      this.i ^= deltaFlags;
+      if (this.c) {
+        for (let i = 0; i < this.c.length; i++) {
+          this.c[i].P(mask, newFlags2);
+        }
+      }
+    }
+  }
+  Q(error) {
+    this.write(error, this.i | ERROR_BIT);
+  }
+  /**
+   * This is the core part of the reactivity system, which makes sure that the values are updated
+   * before they are read. We've also adapted it to return the loading state of the computation,
+   * so that we can propagate that to the computation's observers.
+   *
+   * This function will ensure that the value and states we read from the computation are up to date
+   */
+  r() {
+    if (this.a === STATE_DISPOSED) {
+      throw new Error("Tried to read a disposed computation");
+    }
+    if (this.a === STATE_CLEAN) {
+      return;
+    }
+    let observerFlags = 0;
+    if (this.a === STATE_CHECK) {
+      for (let i = 0; i < this.b.length; i++) {
+        this.b[i].r();
+        observerFlags |= this.b[i].i;
+        if (this.a === STATE_DIRTY) {
+          break;
+        }
+      }
+    }
+    if (this.a === STATE_DIRTY) {
+      update(this);
+    } else {
+      this.write(UNCHANGED, observerFlags);
+      this.a = STATE_CLEAN;
+    }
+  }
+  /**
+   * Remove ourselves from the owner graph and the computation graph
+   */
+  w() {
+    if (this.a === STATE_DISPOSED)
+      return;
+    if (this.b)
+      removeSourceObservers(this, 0);
+    super.w();
+  }
+};
+function loadingState(node) {
+  const prevOwner = setOwner(node.q);
+  const options = void 0;
+  const computation = new Computation(
+    void 0,
+    () => {
+      track(node);
+      node.r();
+      return !!(node.i & LOADING_BIT);
+    },
+    options
+  );
+  computation.A = ERROR_BIT | LOADING_BIT;
+  setOwner(prevOwner);
+  return computation;
+}
+function errorState(node) {
+  const prevOwner = setOwner(node.q);
+  const options = void 0;
+  const computation = new Computation(
+    void 0,
+    () => {
+      track(node);
+      node.r();
+      return !!(node.i & ERROR_BIT);
+    },
+    options
+  );
+  computation.A = ERROR_BIT;
+  setOwner(prevOwner);
+  return computation;
+}
+function track(computation) {
+  if (currentObserver) {
+    if (!newSources && currentObserver.b && currentObserver.b[newSourcesIndex] === computation) {
+      newSourcesIndex++;
+    } else if (!newSources)
+      newSources = [computation];
+    else if (computation !== newSources[newSources.length - 1]) {
+      newSources.push(computation);
+    }
+    if (updateCheck) {
+      updateCheck.d = computation.G > currentObserver.G;
+    }
+  }
+}
+function update(node) {
+  const prevSources = newSources, prevSourcesIndex = newSourcesIndex, prevFlags = newFlags;
+  newSources = null;
+  newSourcesIndex = 0;
+  newFlags = 0;
+  try {
+    node.dispose(false);
+    node.emptyDisposal();
+    const result = compute(node, node.C, node);
+    node.write(result, newFlags, true);
+  } catch (error) {
+    if (error instanceof NotReadyError) {
+      node.write(UNCHANGED, newFlags | LOADING_BIT);
+    } else {
+      node.Q(error);
+    }
+  } finally {
+    if (newSources) {
+      if (node.b)
+        removeSourceObservers(node, newSourcesIndex);
+      if (node.b && newSourcesIndex > 0) {
+        node.b.length = newSourcesIndex + newSources.length;
+        for (let i = 0; i < newSources.length; i++) {
+          node.b[newSourcesIndex + i] = newSources[i];
+        }
+      } else {
+        node.b = newSources;
+      }
+      let source;
+      for (let i = newSourcesIndex; i < node.b.length; i++) {
+        source = node.b[i];
+        if (!source.c)
+          source.c = [node];
+        else
+          source.c.push(node);
+      }
+    } else if (node.b && newSourcesIndex < node.b.length) {
+      removeSourceObservers(node, newSourcesIndex);
+      node.b.length = newSourcesIndex;
+    }
+    newSources = prevSources;
+    newSourcesIndex = prevSourcesIndex;
+    newFlags = prevFlags;
+    node.a = STATE_CLEAN;
+  }
+}
+function removeSourceObservers(node, index) {
+  let source;
+  let swap;
+  for (let i = index; i < node.b.length; i++) {
+    source = node.b[i];
+    if (source.c) {
+      swap = source.c.indexOf(node);
+      source.c[swap] = source.c[source.c.length - 1];
+      source.c.pop();
+      if (!source.c.length)
+        source.N?.();
+    }
+  }
+}
+function isEqual(a, b) {
+  return a === b;
+}
+function untrack(fn) {
+  if (currentObserver === null)
+    return fn();
+  return compute(getOwner(), fn, null);
+}
+function hasUpdated(fn) {
+  const current = updateCheck;
+  updateCheck = { d: false };
+  try {
+    fn();
+    return updateCheck.d;
+  } finally {
+    updateCheck = current;
+  }
+}
+function isPending(fn) {
+  try {
+    fn();
+    return false;
+  } catch (e) {
+    return e instanceof NotReadyError;
+  }
+}
+function latest(fn) {
+  const prevFlags = newFlags;
+  syncResolve = true;
+  try {
+    return fn();
+  } catch {
+  } finally {
+    newFlags = prevFlags;
+    syncResolve = false;
+  }
+}
+function compute(owner, compute2, observer) {
+  const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask;
+  currentObserver = observer;
+  currentMask = observer?.A ?? DEFAULT_FLAGS;
+  try {
+    return compute2(observer ? observer.d : void 0);
+  } finally {
+    setOwner(prevOwner);
+    currentObserver = prevObserver;
+    currentMask = prevMask;
+  }
+}
+
+// src/core/scheduler.ts
+var scheduled = false;
+function schedule() {
+  if (scheduled)
+    return;
+  scheduled = true;
+  queueMicrotask(flushSync);
+}
+var Queue = class {
+  H = false;
+  t = [[], [], []];
+  y = [];
+  enqueue(type, node) {
+    this.t[0].push(node);
+    if (type)
+      this.t[type].push(node);
+    schedule();
+  }
+  run(type) {
+    if (this.t[type].length) {
+      if (type === EFFECT_PURE) {
+        runPureQueue(this.t[type]);
+        this.t[type] = [];
+      } else {
+        const effects = this.t[type];
+        this.t[type] = [];
+        runEffectQueue(effects);
+      }
+    }
+    for (let i = 0; i < this.y.length; i++) {
+      this.y[i].run(type);
+    }
+  }
+  flush() {
+    if (this.H)
+      return;
+    this.H = true;
+    try {
+      this.run(EFFECT_PURE);
+      incrementClock();
+      this.run(EFFECT_RENDER);
+      this.run(EFFECT_USER);
+    } finally {
+      this.H = false;
+    }
+  }
+  addChild(child) {
+    this.y.push(child);
+  }
+  removeChild(child) {
+    const index = this.y.indexOf(child);
+    if (index >= 0)
+      this.y.splice(index, 1);
+  }
+};
+var globalQueue = new Queue();
+function flushSync() {
+  globalQueue.flush();
+  scheduled = false;
+}
+function createBoundary(fn, queue) {
+  const owner = new Owner();
+  const parentQueue = owner.e || globalQueue;
+  parentQueue.addChild(owner.e = queue);
+  onCleanup(() => parentQueue.removeChild(owner.e));
+  return compute(owner, fn, null);
+}
+function runTop(node) {
+  const ancestors = [];
+  for (let current = node; current !== null; current = current.q) {
+    if (current.a !== STATE_CLEAN) {
+      ancestors.push(current);
+    }
+  }
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    if (ancestors[i].a !== STATE_DISPOSED)
+      ancestors[i].r();
+  }
+}
+function runPureQueue(queue) {
+  for (let i = 0; i < queue.length; i++) {
+    if (queue[i].a !== STATE_CLEAN)
+      runTop(queue[i]);
+  }
+}
+function runEffectQueue(queue) {
+  for (let i = 0; i < queue.length; i++) {
+    if (queue[i].I && queue[i].a !== STATE_DISPOSED) {
+      queue[i].J(queue[i].d, queue[i].B);
+      queue[i].I = false;
+      queue[i].B = queue[i].d;
+    }
+  }
+}
+
+// src/core/effect.ts
+var Effect = class extends Computation {
+  J;
+  I = false;
+  B;
+  K;
+  e;
+  constructor(initialValue, compute2, effect, options) {
+    super(initialValue, compute2, options);
+    this.J = effect;
+    this.B = initialValue;
+    this.K = options?.render ? EFFECT_RENDER : EFFECT_USER;
+    this.e = getOwner()?.e || globalQueue;
+    this.e.enqueue(this.K, this);
+    this.r();
+  }
+  write(value, flags = 0) {
+    const currentFlags = this.i;
+    this.i = flags;
+    if ((flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
+      this.e.S?.(this);
+    }
+    if (value === UNCHANGED)
+      return this.d;
+    this.d = value;
+    this.I = true;
+    return value;
+  }
+  s(state) {
+    if (this.a >= state)
+      return;
+    if (this.a === STATE_CLEAN)
+      this.e.enqueue(this.K, this);
+    this.a = state;
+  }
+  Q(error) {
+    this.handleError(error);
+  }
+  w() {
+    this.J = void 0;
+    this.B = void 0;
+    super.w();
+  }
+};
+var EagerComputation = class extends Computation {
+  e;
+  constructor(initialValue, compute2, options) {
+    super(initialValue, compute2, options);
+    this.e = getOwner()?.e || globalQueue;
+    this.r();
+  }
+  s(state) {
+    if (this.a >= state)
+      return;
+    if (this.a === STATE_CLEAN)
+      this.e.enqueue(EFFECT_PURE, this);
+    super.s(state);
+  }
+};
+
+// src/core/suspense.ts
+var SuspenseQueue = class extends Queue {
+  k = /* @__PURE__ */ new Set();
+  z = false;
+  L = new Computation(false, null);
+  run(type) {
+    if (type && this.z)
+      return;
+    super.run(type);
+  }
+  S(node) {
+    if (node.i & LOADING_BIT) {
+      this.k.add(node);
+      if (!this.z) {
+        this.z = true;
+        queueMicrotask(() => this.L.write(true));
+      }
+    } else {
+      this.k.delete(node);
+      if (this.k.size === 0) {
+        this.z = false;
+        queueMicrotask(() => this.L.write(false));
+      }
+    }
+  }
+};
+function createSuspense(fn, fallbackFn) {
+  const queue = new SuspenseQueue();
+  const tree = createBoundary(fn, queue);
+  const equality = new Computation(null, () => queue.L.read() || queue.z);
+  const comp = new Computation(null, () => equality.read() ? untrack(fallbackFn) : tree);
+  return comp.read.bind(comp);
+}
+
+// src/signals.ts
+function createSignal(first, second, third) {
+  if (typeof first === "function") {
+    const memo = createMemo((p) => {
+      const node2 = new Computation(
+        first(p ? untrack(p[0]) : second),
+        null,
+        third
+      );
+      return [node2.read.bind(node2), node2.write.bind(node2)];
+    });
+    return [() => memo()[0](), (value) => memo()[1](value)];
+  }
+  const node = new Computation(first, null, second);
+  return [node.read.bind(node), node.write.bind(node)];
+}
+function createAsync(fn, initial, options) {
+  const lhs = new EagerComputation(
+    {
+      d: initial
+    },
+    (p) => {
+      const value = p?.d;
+      const source = fn(value);
+      const isPromise = source instanceof Promise;
+      const iterator = source[Symbol.asyncIterator];
+      if (!isPromise && !iterator) {
+        return {
+          wait() {
+            return source;
+          },
+          d: source
+        };
+      }
+      const signal = new Computation(value, null, options);
+      signal.write(UNCHANGED, LOADING_BIT);
+      if (isPromise) {
+        source.then(
+          (value2) => {
+            signal.write(value2, 0);
+          },
+          (error) => {
+            signal.write(error, ERROR_BIT);
+          }
+        );
+      } else {
+        let abort = false;
+        onCleanup(() => abort = true);
+        (async () => {
+          try {
+            for await (let value2 of source) {
+              if (abort)
+                return;
+              signal.write(value2, 0);
+            }
+          } catch (error) {
+            signal.write(error, ERROR_BIT);
+          }
+        })();
+      }
+      return signal;
+    }
+  );
+  return () => lhs.wait().wait();
+}
+function createMemo(compute2, initialValue, options) {
+  let node = new Computation(initialValue, compute2, options);
+  let value;
+  return () => {
+    if (node) {
+      value = node.wait();
+      if (!node.b?.length)
+        node = void 0;
+    }
+    return value;
+  };
+}
+function createEffect(compute2, effect, initialValue, options) {
+  void new Effect(
+    initialValue,
+    compute2,
+    effect,
+    void 0
+  );
+}
+function createRenderEffect(compute2, effect, initialValue, options) {
+  void new Effect(initialValue, compute2, effect, {
+    render: true,
+    ...void 0
+  });
+}
+function createRoot(init) {
+  const owner = new Owner();
+  return compute(owner, !init.length ? init : () => init(() => owner.dispose()), null);
+}
+function runWithOwner(owner, run) {
+  try {
+    return compute(owner, run, null);
+  } catch (error) {
+    owner?.handleError(error);
+    return void 0;
+  }
+}
+function catchError(fn, handler) {
+  const owner = new Owner();
+  owner.h = owner.h ? [handler, ...owner.h] : [handler];
+  try {
+    compute(owner, fn, null);
+  } catch (error) {
+    owner.handleError(error);
+  }
+}
+
+// src/store/store.ts
+var $RAW = Symbol(0);
+var $TRACK = Symbol(0);
+var $TARGET = Symbol(0);
+var $PROXY = Symbol(0);
+var STORE_VALUE = "v";
+var STORE_NODE = "n";
+var STORE_HAS = "h";
+function wrap(value) {
+  let p = value[$PROXY];
+  if (!p)
+    Object.defineProperty(value, $PROXY, {
+      value: p = new Proxy({ v: value }, proxyTraps),
+      writable: true
+    });
+  return p;
+}
+function isWrappable(obj) {
+  return obj != null && typeof obj === "object";
+}
+function unwrap(item, deep = true, set) {
+  let result, unwrapped, v, prop;
+  if (result = item != null && item[$RAW])
+    return result;
+  if (!deep)
+    return item;
+  if (!isWrappable(item) || set?.has(item))
+    return item;
+  if (!set)
+    set = /* @__PURE__ */ new Set();
+  set.add(item);
+  if (Array.isArray(item)) {
+    for (let i = 0, l = item.length; i < l; i++) {
+      v = item[i];
+      if ((unwrapped = unwrap(v, deep, set)) !== v)
+        item[i] = unwrapped;
+    }
+  } else {
+    if (!deep)
+      return item;
+    const keys = Object.keys(item);
+    for (let i = 0, l = keys.length; i < l; i++) {
+      prop = keys[i];
+      const desc = Object.getOwnPropertyDescriptor(item, prop);
+      if (desc.get)
+        continue;
+      v = item[prop];
+      if ((unwrapped = unwrap(v, deep, set)) !== v)
+        item[prop] = unwrapped;
+    }
+  }
+  return item;
+}
+function getNodes(target, type) {
+  let nodes = target[type];
+  if (!nodes)
+    target[type] = nodes = /* @__PURE__ */ Object.create(null);
+  return nodes;
+}
+function getNode(nodes, property, value, equals = isEqual) {
+  if (nodes[property])
+    return nodes[property];
+  return nodes[property] = new Computation(value, null, {
+    equals,
+    unobserved() {
+      delete nodes[property];
+    }
+  });
+}
+function proxyDescriptor(target, property) {
+  const desc = Reflect.getOwnPropertyDescriptor(target[STORE_VALUE], property);
+  if (!desc || desc.get || !desc.configurable || property === $PROXY)
+    return desc;
+  delete desc.value;
+  delete desc.writable;
+  desc.get = () => target[STORE_VALUE][$PROXY][property];
+  return desc;
+}
+function trackSelf(target) {
+  getObserver() && getNode(getNodes(target, STORE_NODE), $TRACK, void 0, false).read();
+}
+function ownKeys(target) {
+  trackSelf(target);
+  return Reflect.ownKeys(target[STORE_VALUE]);
+}
+var Writing = /* @__PURE__ */ new Set();
+var proxyTraps = {
+  get(target, property, receiver) {
+    if (property === $TARGET)
+      return target;
+    if (property === $RAW)
+      return target[STORE_VALUE];
+    if (property === $PROXY)
+      return receiver;
+    if (property === $TRACK) {
+      trackSelf(target);
+      return receiver;
+    }
+    const nodes = getNodes(target, STORE_NODE);
+    const storeValue = target[STORE_VALUE];
+    const tracked = nodes[property];
+    if (!tracked) {
+      const desc = Object.getOwnPropertyDescriptor(storeValue, property);
+      if (desc && desc.get)
+        return desc.get.call(receiver);
+    }
+    if (Writing.has(storeValue)) {
+      const value2 = tracked ? tracked.d : storeValue[property];
+      return isWrappable(value2) ? (Writing.add(value2[$RAW] || value2), wrap(value2)) : value2;
+    }
+    let value = tracked ? nodes[property].read() : storeValue[property];
+    if (!tracked) {
+      if (typeof value === "function" && !storeValue.hasOwnProperty(property)) {
+        let proto;
+        return !Array.isArray(storeValue) && (proto = Object.getPrototypeOf(storeValue)) && proto !== Object.prototype ? value.bind(storeValue) : value;
+      } else if (getObserver()) {
+        value = getNode(nodes, property, isWrappable(value) ? wrap(value) : value).read();
+      }
+    }
+    return isWrappable(value) ? wrap(value) : value;
+  },
+  has(target, property) {
+    if (property === $RAW || property === $PROXY || property === $TRACK || property === "__proto__")
+      return true;
+    const has = property in target[STORE_VALUE];
+    getObserver() && getNode(getNodes(target, STORE_HAS), property, has).read();
+    return has;
+  },
+  set(target, property, value) {
+    Writing.has(target[STORE_VALUE]) && setProperty(target[STORE_VALUE], property, unwrap(value, false));
+    return true;
+  },
+  deleteProperty(target, property) {
+    Writing.has(target[STORE_VALUE]) && setProperty(target[STORE_VALUE], property, void 0, true);
+    return true;
+  },
+  ownKeys,
+  getOwnPropertyDescriptor: proxyDescriptor
+};
+function setProperty(state, property, value, deleting = false) {
+  const prev = state[property];
+  if (!deleting && prev === value)
+    return;
+  const len = state.length;
+  if (deleting)
+    delete state[property];
+  else
+    state[property] = value;
+  const target = state[$PROXY]?.[$TARGET];
+  if (!target)
+    return;
+  if (deleting)
+    target[STORE_HAS]?.[property]?.write(false);
+  else
+    target[STORE_HAS]?.[property]?.write(true);
+  const nodes = getNodes(target, STORE_NODE);
+  let node;
+  if (node = nodes[property])
+    node.write(isWrappable(value) ? wrap(value) : value);
+  Array.isArray(state) && state.length !== len && (node = nodes.length) && node.write(state.length);
+  (node = nodes[$TRACK]) && node.write(void 0);
+}
+function createStore(first, second) {
+  const derived = typeof first === "function", store = derived ? second : first, unwrappedStore = unwrap(store, false);
+  const wrappedStore = wrap(unwrappedStore);
+  const setStore = (fn) => {
+    try {
+      Writing.add(unwrappedStore);
+      fn(wrappedStore);
+    } finally {
+      Writing.clear();
+    }
+  };
+  if (derived) {
+    new EagerComputation(void 0, () => setStore(first));
+  }
+  return [wrappedStore, setStore];
+}
+function createProjection(fn, initialValue = {}) {
+  const [store] = createStore(fn, initialValue);
+  return store;
+}
+
+// src/store/reconcile.ts
+function applyState(next, state, keyFn) {
+  const target = state?.[$TARGET];
+  if (!target)
+    return;
+  const previous = target[STORE_VALUE];
+  if (next === previous)
+    return;
+  Object.defineProperty(next, $PROXY, {
+    value: previous[$PROXY],
+    writable: true
+  });
+  previous[$PROXY] = null;
+  target[STORE_VALUE] = next;
+  if (Array.isArray(previous)) {
+    let changed = false;
+    if (next.length && previous.length && next[0] && keyFn(next[0]) != null) {
+      let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
+      for (start = 0, end = Math.min(previous.length, next.length); start < end && (previous[start] === next[start] || previous[start] && next[start] && keyFn(previous[start]) === keyFn(next[start])); start++) {
+        applyState(next[start], wrap(previous[start]), keyFn);
+      }
+      const temp = new Array(next.length), newIndices = /* @__PURE__ */ new Map();
+      for (end = previous.length - 1, newEnd = next.length - 1; end >= start && newEnd >= start && (previous[end] === next[newEnd] || previous[end] && next[newEnd] && keyFn(previous[end]) === keyFn(next[newEnd])); end--, newEnd--) {
+        temp[newEnd] = previous[end];
+      }
+      if (start > newEnd || start > end) {
+        for (j = start; j <= newEnd; j++) {
+          changed = true;
+          target[STORE_NODE][j]?.write(wrap(next[j]));
+        }
+        for (; j < next.length; j++) {
+          changed = true;
+          const wrapped = wrap(temp[j]);
+          target[STORE_NODE][j]?.write(wrapped);
+          applyState(next[j], wrapped, keyFn);
+        }
+        changed && target[STORE_NODE][$TRACK]?.write(void 0);
+        previous.length !== next.length && target[STORE_NODE].length?.write(next.length);
+        return;
+      }
+      newIndicesNext = new Array(newEnd + 1);
+      for (j = newEnd; j >= start; j--) {
+        item = next[j];
+        keyVal = item ? keyFn(item) : item;
+        i = newIndices.get(keyVal);
+        newIndicesNext[j] = i === void 0 ? -1 : i;
+        newIndices.set(keyVal, j);
+      }
+      for (i = start; i <= end; i++) {
+        item = previous[i];
+        keyVal = item ? keyFn(item) : item;
+        j = newIndices.get(keyVal);
+        if (j !== void 0 && j !== -1) {
+          temp[j] = previous[i];
+          j = newIndicesNext[j];
+          newIndices.set(keyVal, j);
+        }
+      }
+      for (j = start; j < next.length; j++) {
+        if (j in temp) {
+          const wrapped = wrap(temp[j]);
+          target[STORE_NODE][j]?.write(wrapped);
+          applyState(next[j], wrapped, keyFn);
+        } else
+          target[STORE_NODE][j]?.write(wrap(next[j]));
+      }
+      if (start < next.length)
+        changed = true;
+    } else if (previous.length && next.length) {
+      for (let i = 0, len = next.length; i < len; i++) {
+        isWrappable(previous[i]) && applyState(next[i], wrap(previous[i]), keyFn);
+      }
+    }
+    if (previous.length !== next.length) {
+      changed = true;
+      target[STORE_NODE].length?.write(next.length);
+    }
+    changed && target[STORE_NODE][$TRACK]?.write(void 0);
+    return;
+  }
+  let nodes = target[STORE_NODE];
+  if (nodes) {
+    const keys = Object.keys(nodes);
+    for (let i = 0, len = keys.length; i < len; i++) {
+      const node = nodes[keys[i]];
+      const previousValue = unwrap(previous[keys[i]], false);
+      let nextValue = unwrap(next[keys[i]], false);
+      if (previousValue === nextValue)
+        continue;
+      if (!previousValue || !isWrappable(previousValue) || keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue))
+        node.write(isWrappable(nextValue) ? wrap(nextValue) : nextValue);
+      else
+        applyState(nextValue, wrap(previousValue), keyFn);
+    }
+  }
+  if (nodes = target[STORE_HAS]) {
+    const keys = Object.keys(nodes);
+    for (let i = 0, len = keys.length; i < len; i++) {
+      nodes[keys[i]].write(keys[i] in next);
+    }
+  }
+}
+function reconcile(value, key) {
+  return (state) => {
+    const keyFn = typeof key === "string" ? (item) => item[key] : key;
+    if (keyFn(value) !== keyFn(state))
+      throw new Error("Cannot reconcile states with different identity");
+    applyState(value, state, keyFn);
+  };
+}
+
+// src/store/utilities.ts
+function trueFn() {
+  return true;
+}
+var propTraps = {
+  get(_, property, receiver) {
+    if (property === $PROXY)
+      return receiver;
+    return _.get(property);
+  },
+  has(_, property) {
+    if (property === $PROXY)
+      return true;
+    return _.has(property);
+  },
+  set: trueFn,
+  deleteProperty: trueFn,
+  getOwnPropertyDescriptor(_, property) {
+    return {
+      configurable: true,
+      enumerable: true,
+      get() {
+        return _.get(property);
+      },
+      set: trueFn,
+      deleteProperty: trueFn
+    };
+  },
+  ownKeys(_) {
+    return _.keys();
+  }
+};
+function resolveSource(s) {
+  return !(s = typeof s === "function" ? s() : s) ? {} : s;
+}
+var $SOURCES = Symbol(0);
+function merge(...sources) {
+  if (sources.length === 1)
+    return sources[0];
+  let proxy = false;
+  const flattened = [];
+  for (let i = 0; i < sources.length; i++) {
+    const s = sources[i];
+    proxy = proxy || !!s && $PROXY in s;
+    const childSources = !!s && s[$SOURCES];
+    if (childSources)
+      flattened.push(...childSources);
+    else
+      flattened.push(
+        typeof s === "function" ? (proxy = true, createMemo(s)) : s
+      );
+  }
+  if (SUPPORTS_PROXY && proxy) {
+    return new Proxy(
+      {
+        get(property) {
+          if (property === $SOURCES)
+            return flattened;
+          for (let i = flattened.length - 1; i >= 0; i--) {
+            const s = resolveSource(flattened[i]);
+            if (property in s)
+              return s[property];
+          }
+        },
+        has(property) {
+          for (let i = flattened.length - 1; i >= 0; i--) {
+            if (property in resolveSource(flattened[i]))
+              return true;
+          }
+          return false;
+        },
+        keys() {
+          const keys = [];
+          for (let i = 0; i < flattened.length; i++)
+            keys.push(...Object.keys(resolveSource(flattened[i])));
+          return [...new Set(keys)];
+        }
+      },
+      propTraps
+    );
+  }
+  const defined = /* @__PURE__ */ Object.create(null);
+  let nonTargetKey = false;
+  let lastIndex = flattened.length - 1;
+  for (let i = lastIndex; i >= 0; i--) {
+    const source = flattened[i];
+    if (!source) {
+      i === lastIndex && lastIndex--;
+      continue;
+    }
+    const sourceKeys = Object.getOwnPropertyNames(source);
+    for (let j = sourceKeys.length - 1; j >= 0; j--) {
+      const key = sourceKeys[j];
+      if (key === "__proto__" || key === "constructor")
+        continue;
+      if (!defined[key]) {
+        nonTargetKey = nonTargetKey || i !== lastIndex;
+        const desc = Object.getOwnPropertyDescriptor(source, key);
+        defined[key] = desc.get ? {
+          enumerable: true,
+          configurable: true,
+          get: desc.get.bind(source)
+        } : desc;
+      }
+    }
+  }
+  if (!nonTargetKey)
+    return flattened[lastIndex];
+  const target = {};
+  const definedKeys = Object.keys(defined);
+  for (let i = definedKeys.length - 1; i >= 0; i--) {
+    const key = definedKeys[i], desc = defined[key];
+    if (desc.get)
+      Object.defineProperty(target, key, desc);
+    else
+      target[key] = desc.value;
+  }
+  target[$SOURCES] = flattened;
+  return target;
+}
+function omit(props, ...keys) {
+  const blocked = new Set(keys);
+  if (SUPPORTS_PROXY && $PROXY in props) {
+    return new Proxy(
+      {
+        get(property) {
+          return blocked.has(property) ? void 0 : props[property];
+        },
+        has(property) {
+          return !blocked.has(property) && property in props;
+        },
+        keys() {
+          return Object.keys(props).filter((k) => !blocked.has(k));
+        }
+      },
+      propTraps
+    );
+  }
+  const result = {};
+  for (const propName of Object.getOwnPropertyNames(props)) {
+    if (!blocked.has(propName)) {
+      const desc = Object.getOwnPropertyDescriptor(props, propName);
+      !desc.get && !desc.set && desc.enumerable && desc.writable && desc.configurable ? result[propName] = desc.value : Object.defineProperty(result, propName, desc);
+    }
+  }
+  return result;
+}
+
+// src/map.ts
+function mapArray(list, map, options) {
+  const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
+  return Computation.prototype.read.bind(
+    new Computation(
+      [],
+      updateKeyedMap.bind({
+        R: new Owner(),
+        u: 0,
+        T: list,
+        p: [],
+        M: map,
+        n: [],
+        k: [],
+        x: keyFn,
+        f: keyFn || options?.keyed === false ? [] : void 0,
+        j: map.length > 1 ? [] : void 0
+      }),
+      options
+    )
+  );
+}
+function updateKeyedMap() {
+  const newItems = this.T() || [], newLen = newItems.length;
+  newItems[$TRACK];
+  runWithOwner(this.R, () => {
+    let i, j, mapper = this.f ? () => {
+      this.f[j] = new Computation(newItems[j], null);
+      this.j[j] = new Computation(j, null);
+      return this.M(
+        Computation.prototype.read.bind(this.f[j]),
+        Computation.prototype.read.bind(this.j[j])
+      );
+    } : this.j ? () => {
+      const item = newItems[j];
+      this.j[j] = new Computation(j, null);
+      return this.M(() => item, Computation.prototype.read.bind(this.j[j]));
+    } : () => {
+      const item = newItems[j];
+      return this.M(() => item);
+    };
+    if (newLen === 0) {
+      if (this.u !== 0) {
+        this.R.dispose(false);
+        this.k = [];
+        this.p = [];
+        this.n = [];
+        this.u = 0;
+        this.f && (this.f = []);
+        this.j && (this.j = []);
+      }
+    } else if (this.u === 0) {
+      this.n = new Array(newLen);
+      for (j = 0; j < newLen; j++) {
+        this.p[j] = newItems[j];
+        this.n[j] = compute(this.k[j] = new Owner(), mapper, null);
+      }
+      this.u = newLen;
+    } else {
+      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.f ? new Array(newLen) : void 0, tempIndexes = this.j ? new Array(newLen) : void 0;
+      for (start = 0, end = Math.min(this.u, newLen); start < end && (this.p[start] === newItems[start] || this.f && compare(this.x, this.p[start], newItems[start])); start++) {
+        if (this.f)
+          this.f[start].write(newItems[start]);
+      }
+      for (end = this.u - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.p[end] === newItems[newEnd] || this.f && compare(this.x, this.p[end], newItems[newEnd])); end--, newEnd--) {
+        temp[newEnd] = this.n[end];
+        tempNodes[newEnd] = this.k[end];
+        tempRows && (tempRows[newEnd] = this.f[end]);
+        tempIndexes && (tempIndexes[newEnd] = this.j[end]);
+      }
+      newIndices = /* @__PURE__ */ new Map();
+      newIndicesNext = new Array(newEnd + 1);
+      for (j = newEnd; j >= start; j--) {
+        item = newItems[j];
+        key = this.x ? this.x(item) : item;
+        i = newIndices.get(key);
+        newIndicesNext[j] = i === void 0 ? -1 : i;
+        newIndices.set(key, j);
+      }
+      for (i = start; i <= end; i++) {
+        item = this.p[i];
+        key = this.x ? this.x(item) : item;
+        j = newIndices.get(key);
+        if (j !== void 0 && j !== -1) {
+          temp[j] = this.n[i];
+          tempNodes[j] = this.k[i];
+          tempRows && (tempRows[j] = this.f[i]);
+          tempIndexes && (tempIndexes[j] = this.j[i]);
+          j = newIndicesNext[j];
+          newIndices.set(key, j);
+        } else
+          this.k[i].dispose();
+      }
+      for (j = start; j < newLen; j++) {
+        if (j in temp) {
+          this.n[j] = temp[j];
+          this.k[j] = tempNodes[j];
+          if (tempRows) {
+            this.f[j] = tempRows[j];
+            this.f[j].write(newItems[j]);
+          }
+          if (tempIndexes) {
+            this.j[j] = tempIndexes[j];
+            this.j[j].write(j);
+          }
+        } else {
+          this.n[j] = compute(this.k[j] = new Owner(), mapper, null);
+        }
+      }
+      this.n = this.n.slice(0, this.u = newLen);
+      this.p = newItems.slice(0);
+    }
+  });
+  return this.n;
+}
+function compare(key, a, b) {
+  return key ? key(a) === key(b) : true;
+}
+
+export { $PROXY, $RAW, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, catchError, createAsync, createBoundary, createContext, createEffect, createMemo, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, runWithOwner, setContext, untrack, unwrap };