@manyducks.co/dolla 2.0.0-alpha.55 → 2.0.0-alpha.56

package/dist/logger-sSxIw5od.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger-sSxIw5od.js","sources":["../node_modules/alien-signals/esm/index.mjs","../src/core/signals.ts","../src/utils.ts","../src/core/env.ts","../src/core/logger.ts"],"sourcesContent":["// src/system.ts\nvar SubscriberFlags = /* @__PURE__ */ ((SubscriberFlags2) => {\n  SubscriberFlags2[SubscriberFlags2[\"Computed\"] = 1] = \"Computed\";\n  SubscriberFlags2[SubscriberFlags2[\"Effect\"] = 2] = \"Effect\";\n  SubscriberFlags2[SubscriberFlags2[\"Tracking\"] = 4] = \"Tracking\";\n  SubscriberFlags2[SubscriberFlags2[\"Notified\"] = 8] = \"Notified\";\n  SubscriberFlags2[SubscriberFlags2[\"Recursed\"] = 16] = \"Recursed\";\n  SubscriberFlags2[SubscriberFlags2[\"Dirty\"] = 32] = \"Dirty\";\n  SubscriberFlags2[SubscriberFlags2[\"PendingComputed\"] = 64] = \"PendingComputed\";\n  SubscriberFlags2[SubscriberFlags2[\"PendingEffect\"] = 128] = \"PendingEffect\";\n  SubscriberFlags2[SubscriberFlags2[\"Propagated\"] = 224] = \"Propagated\";\n  return SubscriberFlags2;\n})(SubscriberFlags || {});\nfunction createReactiveSystem({\n  updateComputed,\n  notifyEffect: notifyEffect2\n}) {\n  let queuedEffects;\n  let queuedEffectsTail;\n  return {\n    /**\n     * Links a given dependency and subscriber if they are not already linked.\n     * \n     * @param dep - The dependency to be linked.\n     * @param sub - The subscriber that depends on this dependency.\n     * @returns The newly created link object if the two are not already linked; otherwise `undefined`.\n     */\n    link(dep, sub) {\n      const currentDep = sub.depsTail;\n      if (currentDep !== void 0 && currentDep.dep === dep) {\n        return;\n      }\n      const nextDep = currentDep !== void 0 ? currentDep.nextDep : sub.deps;\n      if (nextDep !== void 0 && nextDep.dep === dep) {\n        sub.depsTail = nextDep;\n        return;\n      }\n      const depLastSub = dep.subsTail;\n      if (depLastSub !== void 0 && depLastSub.sub === sub && isValidLink(depLastSub, sub)) {\n        return;\n      }\n      return linkNewDep(dep, sub, nextDep, currentDep);\n    },\n    /**\n     * Traverses and marks subscribers starting from the provided link.\n     * \n     * It sets flags (e.g., Dirty, PendingComputed, PendingEffect) on each subscriber\n     * to indicate which ones require re-computation or effect processing. \n     * This function should be called after a signal's value changes.\n     * \n     * @param link - The starting link from which propagation begins.\n     */\n    propagate(link2) {\n      let targetFlag = 32 /* Dirty */;\n      let subs = link2;\n      let stack = 0;\n      top: do {\n        const sub = link2.sub;\n        const subFlags = sub.flags;\n        if (!(subFlags & (4 /* Tracking */ | 16 /* Recursed */ | 224 /* Propagated */)) && (sub.flags = subFlags | targetFlag | 8 /* Notified */, true) || subFlags & 16 /* Recursed */ && !(subFlags & 4 /* Tracking */) && (sub.flags = subFlags & ~16 /* Recursed */ | targetFlag | 8 /* Notified */, true) || !(subFlags & 224 /* Propagated */) && isValidLink(link2, sub) && (sub.flags = subFlags | 16 /* Recursed */ | targetFlag | 8 /* Notified */, sub.subs !== void 0)) {\n          const subSubs = sub.subs;\n          if (subSubs !== void 0) {\n            if (subSubs.nextSub !== void 0) {\n              subSubs.prevSub = subs;\n              link2 = subs = subSubs;\n              targetFlag = 64 /* PendingComputed */;\n              ++stack;\n            } else {\n              link2 = subSubs;\n              targetFlag = subFlags & 2 /* Effect */ ? 128 /* PendingEffect */ : 64 /* PendingComputed */;\n            }\n            continue;\n          }\n          if (subFlags & 2 /* Effect */) {\n            if (queuedEffectsTail !== void 0) {\n              queuedEffectsTail.depsTail.nextDep = sub.deps;\n            } else {\n              queuedEffects = sub;\n            }\n            queuedEffectsTail = sub;\n          }\n        } else if (!(subFlags & (4 /* Tracking */ | targetFlag))) {\n          sub.flags = subFlags | targetFlag | 8 /* Notified */;\n          if ((subFlags & (2 /* Effect */ | 8 /* Notified */)) === 2 /* Effect */) {\n            if (queuedEffectsTail !== void 0) {\n              queuedEffectsTail.depsTail.nextDep = sub.deps;\n            } else {\n              queuedEffects = sub;\n            }\n            queuedEffectsTail = sub;\n          }\n        } else if (!(subFlags & targetFlag) && subFlags & 224 /* Propagated */ && isValidLink(link2, sub)) {\n          sub.flags = subFlags | targetFlag;\n        }\n        if ((link2 = subs.nextSub) !== void 0) {\n          subs = link2;\n          targetFlag = stack ? 64 /* PendingComputed */ : 32 /* Dirty */;\n          continue;\n        }\n        while (stack) {\n          --stack;\n          const dep = subs.dep;\n          const depSubs = dep.subs;\n          subs = depSubs.prevSub;\n          depSubs.prevSub = void 0;\n          if ((link2 = subs.nextSub) !== void 0) {\n            subs = link2;\n            targetFlag = stack ? 64 /* PendingComputed */ : 32 /* Dirty */;\n            continue top;\n          }\n        }\n        break;\n      } while (true);\n    },\n    /**\n     * Prepares the given subscriber to track new dependencies.\n     * \n     * It resets the subscriber's internal pointers (e.g., depsTail) and\n     * sets its flags to indicate it is now tracking dependency links.\n     * \n     * @param sub - The subscriber to start tracking.\n     */\n    startTracking(sub) {\n      sub.depsTail = void 0;\n      sub.flags = sub.flags & ~(8 /* Notified */ | 16 /* Recursed */ | 224 /* Propagated */) | 4 /* Tracking */;\n    },\n    /**\n     * Concludes tracking of dependencies for the specified subscriber.\n     * \n     * It clears or unlinks any tracked dependency information, then\n     * updates the subscriber's flags to indicate tracking is complete.\n     * \n     * @param sub - The subscriber whose tracking is ending.\n     */\n    endTracking(sub) {\n      const depsTail = sub.depsTail;\n      if (depsTail !== void 0) {\n        const nextDep = depsTail.nextDep;\n        if (nextDep !== void 0) {\n          clearTracking(nextDep);\n          depsTail.nextDep = void 0;\n        }\n      } else if (sub.deps !== void 0) {\n        clearTracking(sub.deps);\n        sub.deps = void 0;\n      }\n      sub.flags &= ~4 /* Tracking */;\n    },\n    /**\n     * Updates the dirty flag for the given subscriber based on its dependencies.\n     * \n     * If the subscriber has any pending computeds, this function sets the Dirty flag\n     * and returns `true`. Otherwise, it clears the PendingComputed flag and returns `false`.\n     * \n     * @param sub - The subscriber to update.\n     * @param flags - The current flag set for this subscriber.\n     * @returns `true` if the subscriber is marked as Dirty; otherwise `false`.\n     */\n    updateDirtyFlag(sub, flags) {\n      if (checkDirty(sub.deps)) {\n        sub.flags = flags | 32 /* Dirty */;\n        return true;\n      } else {\n        sub.flags = flags & ~64 /* PendingComputed */;\n        return false;\n      }\n    },\n    /**\n     * Updates the computed subscriber if necessary before its value is accessed.\n     * \n     * If the subscriber is marked Dirty or PendingComputed, this function runs\n     * the provided updateComputed logic and triggers a shallowPropagate for any\n     * downstream subscribers if an actual update occurs.\n     * \n     * @param computed - The computed subscriber to update.\n     * @param flags - The current flag set for this subscriber.\n     */\n    processComputedUpdate(computed2, flags) {\n      if (flags & 32 /* Dirty */ || (checkDirty(computed2.deps) ? true : (computed2.flags = flags & ~64 /* PendingComputed */, false))) {\n        if (updateComputed(computed2)) {\n          const subs = computed2.subs;\n          if (subs !== void 0) {\n            shallowPropagate(subs);\n          }\n        }\n      }\n    },\n    /**\n     * Ensures all pending internal effects for the given subscriber are processed.\n     * \n     * This should be called after an effect decides not to re-run itself but may still\n     * have dependencies flagged with PendingEffect. If the subscriber is flagged with\n     * PendingEffect, this function clears that flag and invokes `notifyEffect` on any\n     * related dependencies marked as Effect and Propagated, processing pending effects.\n     * \n     * @param sub - The subscriber which may have pending effects.\n     * @param flags - The current flags on the subscriber to check.\n     */\n    processPendingInnerEffects(sub, flags) {\n      if (flags & 128 /* PendingEffect */) {\n        sub.flags = flags & ~128 /* PendingEffect */;\n        let link2 = sub.deps;\n        do {\n          const dep = link2.dep;\n          if (\"flags\" in dep && dep.flags & 2 /* Effect */ && dep.flags & 224 /* Propagated */) {\n            notifyEffect2(dep);\n          }\n          link2 = link2.nextDep;\n        } while (link2 !== void 0);\n      }\n    },\n    /**\n     * Processes queued effect notifications after a batch operation finishes.\n     * \n     * Iterates through all queued effects, calling notifyEffect on each.\n     * If an effect remains partially handled, its flags are updated, and future\n     * notifications may be triggered until fully handled.\n     */\n    processEffectNotifications() {\n      while (queuedEffects !== void 0) {\n        const effect2 = queuedEffects;\n        const depsTail = effect2.depsTail;\n        const queuedNext = depsTail.nextDep;\n        if (queuedNext !== void 0) {\n          depsTail.nextDep = void 0;\n          queuedEffects = queuedNext.sub;\n        } else {\n          queuedEffects = void 0;\n          queuedEffectsTail = void 0;\n        }\n        if (!notifyEffect2(effect2)) {\n          effect2.flags &= ~8 /* Notified */;\n        }\n      }\n    }\n  };\n  function linkNewDep(dep, sub, nextDep, depsTail) {\n    const newLink = {\n      dep,\n      sub,\n      nextDep,\n      prevSub: void 0,\n      nextSub: void 0\n    };\n    if (depsTail === void 0) {\n      sub.deps = newLink;\n    } else {\n      depsTail.nextDep = newLink;\n    }\n    if (dep.subs === void 0) {\n      dep.subs = newLink;\n    } else {\n      const oldTail = dep.subsTail;\n      newLink.prevSub = oldTail;\n      oldTail.nextSub = newLink;\n    }\n    sub.depsTail = newLink;\n    dep.subsTail = newLink;\n    return newLink;\n  }\n  function checkDirty(link2) {\n    let stack = 0;\n    let dirty;\n    top: do {\n      dirty = false;\n      const dep = link2.dep;\n      if (\"flags\" in dep) {\n        const depFlags = dep.flags;\n        if ((depFlags & (1 /* Computed */ | 32 /* Dirty */)) === (1 /* Computed */ | 32 /* Dirty */)) {\n          if (updateComputed(dep)) {\n            const subs = dep.subs;\n            if (subs.nextSub !== void 0) {\n              shallowPropagate(subs);\n            }\n            dirty = true;\n          }\n        } else if ((depFlags & (1 /* Computed */ | 64 /* PendingComputed */)) === (1 /* Computed */ | 64 /* PendingComputed */)) {\n          const depSubs = dep.subs;\n          if (depSubs.nextSub !== void 0) {\n            depSubs.prevSub = link2;\n          }\n          link2 = dep.deps;\n          ++stack;\n          continue;\n        }\n      }\n      if (!dirty && link2.nextDep !== void 0) {\n        link2 = link2.nextDep;\n        continue;\n      }\n      if (stack) {\n        let sub = link2.sub;\n        do {\n          --stack;\n          const subSubs = sub.subs;\n          if (dirty) {\n            if (updateComputed(sub)) {\n              if ((link2 = subSubs.prevSub) !== void 0) {\n                subSubs.prevSub = void 0;\n                shallowPropagate(sub.subs);\n                sub = link2.sub;\n              } else {\n                sub = subSubs.sub;\n              }\n              continue;\n            }\n          } else {\n            sub.flags &= ~64 /* PendingComputed */;\n          }\n          if ((link2 = subSubs.prevSub) !== void 0) {\n            subSubs.prevSub = void 0;\n            if (link2.nextDep !== void 0) {\n              link2 = link2.nextDep;\n              continue top;\n            }\n            sub = link2.sub;\n          } else {\n            if ((link2 = subSubs.nextDep) !== void 0) {\n              continue top;\n            }\n            sub = subSubs.sub;\n          }\n          dirty = false;\n        } while (stack);\n      }\n      return dirty;\n    } while (true);\n  }\n  function shallowPropagate(link2) {\n    do {\n      const sub = link2.sub;\n      const subFlags = sub.flags;\n      if ((subFlags & (64 /* PendingComputed */ | 32 /* Dirty */)) === 64 /* PendingComputed */) {\n        sub.flags = subFlags | 32 /* Dirty */ | 8 /* Notified */;\n        if ((subFlags & (2 /* Effect */ | 8 /* Notified */)) === 2 /* Effect */) {\n          if (queuedEffectsTail !== void 0) {\n            queuedEffectsTail.depsTail.nextDep = sub.deps;\n          } else {\n            queuedEffects = sub;\n          }\n          queuedEffectsTail = sub;\n        }\n      }\n      link2 = link2.nextSub;\n    } while (link2 !== void 0);\n  }\n  function isValidLink(checkLink, sub) {\n    const depsTail = sub.depsTail;\n    if (depsTail !== void 0) {\n      let link2 = sub.deps;\n      do {\n        if (link2 === checkLink) {\n          return true;\n        }\n        if (link2 === depsTail) {\n          break;\n        }\n        link2 = link2.nextDep;\n      } while (link2 !== void 0);\n    }\n    return false;\n  }\n  function clearTracking(link2) {\n    do {\n      const dep = link2.dep;\n      const nextDep = link2.nextDep;\n      const nextSub = link2.nextSub;\n      const prevSub = link2.prevSub;\n      if (nextSub !== void 0) {\n        nextSub.prevSub = prevSub;\n      } else {\n        dep.subsTail = prevSub;\n      }\n      if (prevSub !== void 0) {\n        prevSub.nextSub = nextSub;\n      } else {\n        dep.subs = nextSub;\n      }\n      if (dep.subs === void 0 && \"deps\" in dep) {\n        const depFlags = dep.flags;\n        if (!(depFlags & 32 /* Dirty */)) {\n          dep.flags = depFlags | 32 /* Dirty */;\n        }\n        const depDeps = dep.deps;\n        if (depDeps !== void 0) {\n          link2 = depDeps;\n          dep.depsTail.nextDep = nextDep;\n          dep.deps = void 0;\n          dep.depsTail = void 0;\n          continue;\n        }\n      }\n      link2 = nextDep;\n    } while (link2 !== void 0);\n  }\n}\n\n// src/index.ts\nvar {\n  link,\n  propagate,\n  updateDirtyFlag,\n  startTracking,\n  endTracking,\n  processEffectNotifications,\n  processComputedUpdate,\n  processPendingInnerEffects\n} = createReactiveSystem({\n  updateComputed(computed2) {\n    const prevSub = activeSub;\n    activeSub = computed2;\n    startTracking(computed2);\n    try {\n      const oldValue = computed2.currentValue;\n      const newValue = computed2.getter(oldValue);\n      if (oldValue !== newValue) {\n        computed2.currentValue = newValue;\n        return true;\n      }\n      return false;\n    } finally {\n      activeSub = prevSub;\n      endTracking(computed2);\n    }\n  },\n  notifyEffect(e) {\n    if (\"isScope\" in e) {\n      return notifyEffectScope(e);\n    } else {\n      return notifyEffect(e);\n    }\n  }\n});\nvar pauseStack = [];\nvar batchDepth = 0;\nvar activeSub;\nvar activeScope;\nfunction startBatch() {\n  ++batchDepth;\n}\nfunction endBatch() {\n  if (!--batchDepth) {\n    processEffectNotifications();\n  }\n}\nfunction pauseTracking() {\n  pauseStack.push(activeSub);\n  activeSub = void 0;\n}\nfunction resumeTracking() {\n  activeSub = pauseStack.pop();\n}\nfunction signal(oldValue) {\n  return signalGetterSetter.bind({\n    currentValue: oldValue,\n    subs: void 0,\n    subsTail: void 0\n  });\n}\nfunction computed(getter) {\n  return computedGetter.bind({\n    currentValue: void 0,\n    subs: void 0,\n    subsTail: void 0,\n    deps: void 0,\n    depsTail: void 0,\n    flags: 1 /* Computed */ | 32 /* Dirty */,\n    getter\n  });\n}\nfunction effect(fn) {\n  const e = {\n    fn,\n    subs: void 0,\n    subsTail: void 0,\n    deps: void 0,\n    depsTail: void 0,\n    flags: 2 /* Effect */\n  };\n  if (activeSub !== void 0) {\n    link(e, activeSub);\n  } else if (activeScope !== void 0) {\n    link(e, activeScope);\n  }\n  runEffect(e);\n  return effectStop.bind(e);\n}\nfunction effectScope(fn) {\n  const e = {\n    deps: void 0,\n    depsTail: void 0,\n    flags: 2 /* Effect */,\n    isScope: true\n  };\n  runEffectScope(e, fn);\n  return effectStop.bind(e);\n}\nfunction runEffect(e) {\n  const prevSub = activeSub;\n  activeSub = e;\n  startTracking(e);\n  try {\n    e.fn();\n  } finally {\n    activeSub = prevSub;\n    endTracking(e);\n  }\n}\nfunction runEffectScope(e, fn) {\n  const prevSub = activeScope;\n  activeScope = e;\n  startTracking(e);\n  try {\n    fn();\n  } finally {\n    activeScope = prevSub;\n    endTracking(e);\n  }\n}\nfunction notifyEffect(e) {\n  const flags = e.flags;\n  if (flags & 32 /* Dirty */ || flags & 64 /* PendingComputed */ && updateDirtyFlag(e, flags)) {\n    runEffect(e);\n  } else {\n    processPendingInnerEffects(e, e.flags);\n  }\n  return true;\n}\nfunction notifyEffectScope(e) {\n  const flags = e.flags;\n  if (flags & 128 /* PendingEffect */) {\n    processPendingInnerEffects(e, e.flags);\n    return true;\n  }\n  return false;\n}\nfunction computedGetter() {\n  const flags = this.flags;\n  if (flags & (32 /* Dirty */ | 64 /* PendingComputed */)) {\n    processComputedUpdate(this, flags);\n  }\n  if (activeSub !== void 0) {\n    link(this, activeSub);\n  } else if (activeScope !== void 0) {\n    link(this, activeScope);\n  }\n  return this.currentValue;\n}\nfunction signalGetterSetter(...value) {\n  if (value.length) {\n    if (this.currentValue !== (this.currentValue = value[0])) {\n      const subs = this.subs;\n      if (subs !== void 0) {\n        propagate(subs);\n        if (!batchDepth) {\n          processEffectNotifications();\n        }\n      }\n    }\n  } else {\n    if (activeSub !== void 0) {\n      link(this, activeSub);\n    }\n    return this.currentValue;\n  }\n}\nfunction effectStop() {\n  startTracking(this);\n  endTracking(this);\n}\nexport {\n  SubscriberFlags,\n  computed,\n  createReactiveSystem,\n  effect,\n  effectScope,\n  endBatch,\n  pauseTracking,\n  resumeTracking,\n  signal,\n  startBatch\n};\n","import { createReactiveSystem, type Dependency, type Subscriber, SubscriberFlags } from \"alien-signals\";\nimport { isFunction } from \"../typeChecking\";\n\nexport interface Effect extends Subscriber, Dependency {\n  /**\n   * Effect function. Can return an optional cleanup callback to be invoked before the next fn() call.\n   */\n  fn(): (() => void) | void;\n\n  cleanup?: () => void;\n}\n\nexport interface Computed<T = any> extends Value<T | undefined>, Subscriber {\n  getter: (cachedValue?: T) => T;\n  equals: EqualityFn<T>;\n}\n\nexport interface Value<T = any> extends Dependency {\n  current: T;\n}\n\nexport const {\n  link,\n  propagate,\n  updateDirtyFlag,\n  startTracking,\n  endTracking,\n  processEffectNotifications,\n  processComputedUpdate,\n  processPendingInnerEffects,\n} = createReactiveSystem({\n  updateComputed(c: Computed): boolean {\n    const prevSub = activeSub;\n    activeSub = c;\n    startTracking(c);\n    try {\n      const oldValue = c.current;\n      const newValue = c.getter(oldValue);\n      if (!c.equals(oldValue, newValue)) {\n        c.current = newValue;\n        return true;\n      }\n      return false;\n    } finally {\n      activeSub = prevSub;\n      endTracking(c);\n    }\n  },\n  notifyEffect(e: Effect) {\n    const flags = e.flags;\n    if (flags & SubscriberFlags.Dirty || (flags & SubscriberFlags.PendingComputed && updateDirtyFlag(e, flags))) {\n      queueEffect(e);\n    } else {\n      processPendingInnerEffects(e, e.flags);\n    }\n    return true;\n  },\n});\n\nfunction _createSource<T>(initialValue: T, options?: SignalOptions<T>): Source<T> {\n  const value: Value<T> = {\n    current: initialValue,\n    subs: undefined,\n    subsTail: undefined,\n  };\n  const equals = options?.equals ?? Object.is;\n  const signal: Signal<any> = function () {\n    if (arguments.length > 0) {\n      let next = arguments[0] as T;\n\n      if (typeof next === \"function\") {\n        next = next(value.current);\n      }\n\n      if (!equals(value.current, next)) {\n        value.current = next;\n        const subs = value.subs;\n        if (subs !== undefined) {\n          propagate(subs);\n          processEffectNotifications();\n        }\n      }\n    } else {\n      if (activeSub !== undefined) {\n        link(value, activeSub);\n      }\n      return value.current;\n    }\n  };\n  (signal as any)._type = SOURCE;\n\n  return signal;\n}\n\nfunction _createSignal<T>(fn: (cachedValue?: T) => T, options?: SignalOptions<T>): Signal<T> {\n  if (isFunction(fn) && (fn as any)._type === SIGNAL) {\n    if ((fn as any)._type === SOURCE) {\n      return (() => fn()) as Signal<T>;\n    } else {\n      return fn as Signal<T>;\n    }\n  }\n\n  const computed: Computed<T> = {\n    current: undefined,\n    equals: options?.equals ?? Object.is,\n    subs: undefined,\n    subsTail: undefined,\n    deps: undefined,\n    depsTail: undefined,\n    flags: SubscriberFlags.Computed | SubscriberFlags.Dirty,\n    getter: (cachedValue?: T) => {\n      const returned = fn(cachedValue);\n\n      // If a signal is returned, track it and return its value.\n      return get(returned);\n    },\n  };\n  const signal: Signal<T> = function () {\n    if (arguments.length > 0) {\n      throw new Error(\"Signals cannot be set as their values are derived from the sources they depend on.\");\n    }\n    if (activeSub !== undefined) {\n      link(computed, activeSub);\n    }\n    const flags = computed.flags;\n    if (flags & (SubscriberFlags.Dirty | SubscriberFlags.PendingComputed)) {\n      processComputedUpdate(computed, flags);\n    }\n    return computed.current!;\n  };\n  (signal as any)._type = SIGNAL;\n\n  return signal;\n}\n\n/*===================================*\\\n||        EFFECTS & TRACKING         ||\n\\*===================================*/\n\nexport let activeSub: Subscriber | undefined;\n\nconst PENDING_EFFECTS: Effect[] = [];\n\nlet flushPending = false;\n\nfunction flushEffects(): void {\n  if (!flushPending) {\n    flushPending = true;\n\n    queueMicrotask(() => {\n      flushPending = false;\n      for (let i = 0; i < PENDING_EFFECTS.length; i++) {\n        const e = PENDING_EFFECTS[i];\n        const prevSub = activeSub;\n        activeSub = e;\n        startTracking(e);\n        try {\n          if (e.cleanup) {\n            pauseTracking();\n            e.cleanup();\n            resumeTracking();\n          }\n          e.cleanup = e.fn() ?? undefined;\n        } finally {\n          activeSub = prevSub;\n          endTracking(e);\n        }\n      }\n      PENDING_EFFECTS.length = 0;\n    });\n  }\n}\n\nexport function queueEffect(e: Effect) {\n  PENDING_EFFECTS.push(e);\n  flushEffects();\n}\n\nexport function stopEffect(this: Effect): void {\n  startTracking(this);\n  endTracking(this);\n  // Cancel it after it receives its current value.\n  queueMicrotask(() => {\n    PENDING_EFFECTS.splice(PENDING_EFFECTS.indexOf(this), 1);\n    if (this.cleanup) {\n      this.cleanup();\n    }\n  });\n}\n\nconst pauseStack: (Subscriber | undefined)[] = [];\n\nexport function pauseTracking() {\n  pauseStack.push(activeSub);\n  activeSub = undefined;\n}\n\nexport function resumeTracking() {\n  activeSub = pauseStack.pop();\n}\n\n/*===================================*\\\n||                API                ||\n\\*===================================*/\n\n/* -------------- TYPES --------------- */\n\nconst SIGNAL = Symbol(\"SIGNAL\");\nconst SOURCE = Symbol(\"SOURCE\");\n\n/**\n * A getter that returns the current value held within the signal.\n * If called inside a trackable scope this signal will be tracked as a dependency.\n */\nexport interface Signal<T> {\n  (): T;\n}\n\n/**\n * Extends Signal with the ability to pass a value or an updater function to change the Signal's value.\n */\nexport interface Source<T> extends Signal<T> {\n  (value: T): void;\n  (updater: (value: T) => T): void;\n}\n\nexport type MaybeSignal<T> = Signal<T> | T;\n\nexport type EqualityFn<T> = (current: T, next: T) => boolean;\nexport interface SignalOptions<T> {\n  /**\n   * A function to compare the current and next values. Returning `true` means the value has changed.\n   */\n  equals?: EqualityFn<T>;\n}\n\n/* -------------- PUBLIC API --------------- */\n\nexport function isSource<T>(value: MaybeSignal<T>): value is Source<T> {\n  return isFunction(value) && (value as any)._type === SOURCE;\n}\n\nexport function peek<T>(value: MaybeSignal<T>) {\n  let result: T;\n  pauseTracking();\n  result = get(value);\n  resumeTracking();\n  return result;\n}\n\nexport function get<T>(value: MaybeSignal<T>) {\n  if (isFunction(value)) {\n    return (value as () => T)();\n  } else {\n    return value;\n  }\n}\n\n/**\n * Function to be invoked for the effect. Can return an optional cleanup function to be called between invocations.\n */\nexport type EffectFn = () => void | (() => void);\n\nexport type UnsubscribeFn = () => void;\n\n/**\n * Creates a tracked scope that re-runs whenever the values of any tracked reactives changes.\n * Reactives are tracked by accessing their `value` within the body of the function.\n *\n * NOTE: You must call the unsubscribe function to stop watching for changes.\n * If you are using an effect inside a View or Store, use `ctx.effect` instead, which cleans up automatically when the component unmounts.\n */\nexport function effect(fn: EffectFn): UnsubscribeFn {\n  const e: Effect = {\n    fn,\n    subs: undefined,\n    subsTail: undefined,\n    deps: undefined,\n    depsTail: undefined,\n    flags: SubscriberFlags.Effect,\n  };\n  if (activeSub !== undefined) {\n    link(e, activeSub);\n  }\n  queueEffect(e);\n  return stopEffect.bind(e);\n}\n\nexport function $<T>(compute: () => MaybeSignal<T>, options?: SignalOptions<T>): Signal<T>;\nexport function $<T>(value: T, options?: SignalOptions<T>): Source<T>;\nexport function $<T>(value: undefined, options?: SignalOptions<T>): Source<T | undefined>;\nexport function $<T>(): Source<T | undefined>;\n\nexport function $<T>(init?: (() => T) | T, options?: SignalOptions<T>) {\n  if (isFunction(init)) {\n    return _createSignal(init as () => T, options);\n  } else if (init === undefined) {\n    return _createSource<T | undefined>(undefined, options as SignalOptions<T | undefined>);\n  } else {\n    return _createSource(init, options);\n  }\n}\n","import { isFunction, isObject, typeOf } from \"./typeChecking.js\";\n\nexport const noOp = () => {};\n\n// Guarantee unique ID by incrementing a global counter.\nlet idCounter = 1;\nexport function getUniqueId(): string {\n  idCounter = (idCounter % Number.MAX_SAFE_INTEGER) + 1;\n  return idCounter.toString(36) + Date.now().toString(36);\n}\n\n/*=============================*\\\n||       Object Equality       ||\n\\*=============================*/\n\n/**\n * Equality check that passes if both values are the same object.\n * This is the default equality check for states.\n */\nexport function strictEqual(a: any, b: any): boolean {\n  return Object.is(a, b);\n}\n\n/**\n * Equality check that passes if both values are the same object, or if both are objects or arrays with equal keys and values.\n */\nexport function shallowEqual(a: any, b: any): boolean {\n  if (Object.is(a, b)) return true;\n\n  // Must be same type\n  const t = typeOf(a);\n  if (t !== typeOf(b)) {\n    return false;\n  }\n\n  switch (t) {\n    case \"object\":\n      // Objects must have same number of keys with strict equal values\n      let size = 0;\n      for (const key in a) {\n        if (a[key] !== b[key]) return false;\n        size++;\n      }\n      return Object.keys(b).length === size;\n    case \"array\":\n      // Arrays must be the same length with strict equal values\n      if (a.length !== b.length) return false;\n      for (let i = 0; i < a.length; i++) {\n        if (a[i] !== b[i]) return false;\n      }\n      return true;\n    case \"map\":\n      if (a.size !== b.size) return false;\n      for (const key of a.keys()) {\n        if (a[key] !== b[key]) return false;\n      }\n      return true;\n    case \"set\":\n      if (isFunction(a.symmetricDifference)) {\n        return a.symmetricDifference(b).size === 0;\n      } else {\n        for (const key of a.keys()) {\n          if (a[key] !== b.get(key)) return false;\n        }\n        return true;\n      }\n  }\n\n  return false;\n}\n\n/**\n * Equality check that passes if two objects have equal values, even if they are not the same object.\n */\n// NOTE: This code is https://github.com/epoberezkin/fast-deep-equal licensed under MIT.\n// I imported it because I couldn't get the old school module to play nice with my modern ES code as an external dependency.\nexport function deepEqual(a: any, b: any): boolean {\n  if (a === b) return true;\n\n  if (a && b && typeof a == \"object\" && typeof b == \"object\") {\n    if (a.constructor !== b.constructor) return false;\n\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0; ) if (!deepEqual(a[i], b[i])) return false;\n      return true;\n    }\n\n    if (a instanceof Map && b instanceof Map) {\n      if (a.size !== b.size) return false;\n      for (i of a.entries()) if (!b.has(i[0])) return false;\n      for (i of a.entries()) if (!deepEqual(i[1], b.get(i[0]))) return false;\n      return true;\n    }\n\n    if (a instanceof Set && b instanceof Set) {\n      if (a.size !== b.size) return false;\n      for (i of a.entries()) if (!b.has(i[0])) return false;\n      return true;\n    }\n\n    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {\n      length = (a as any).length;\n      if (length != (b as any).length) return false;\n      for (i = length; i-- !== 0; ) if ((a as any)[i] !== (b as any)[i]) return false;\n      return true;\n    }\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0; ) if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n    for (i = length; i-- !== 0; ) {\n      var key = keys[i];\n\n      if (!deepEqual(a[key], b[key])) return false;\n    }\n\n    return true;\n  }\n\n  // true if both NaN, false otherwise\n  return a !== a && b !== b;\n}\n\n/*=============================*\\\n||         Object Utils        ||\n\\*=============================*/\n\n/**\n * Takes an old value and a new value.  Returns a merged copy if both are objects, otherwise returns the new value.\n */\nexport function merge(one: unknown, two: unknown) {\n  if (isObject(one)) {\n    if (!isObject(two)) {\n      return two;\n    }\n\n    const merged = Object.assign({}, one) as any;\n\n    for (const key in two) {\n      merged[key] = merge(merged[key], two[key]);\n    }\n\n    return merged;\n  } else {\n    return two;\n  }\n}\n\n/**\n * Returns a new object without the specified keys.\n * If called without object, returns a function that takes an object\n * and returns a version with the original keys omitted.\n *\n * @param keys - An array of keys to omit.\n * @param object - An object to clone without the omitted keys.\n */\nexport function omit<O extends Record<any, any>>(keys: (keyof O)[], object: O): Record<any, any> {\n  const newObject: Record<any, any> = {};\n\n  for (const key in object) {\n    if (!keys.includes(key)) {\n      newObject[key] = object[key];\n    }\n  }\n\n  return newObject;\n}\n\n/*=============================*\\\n||          Misc Utils         ||\n\\*=============================*/\n\n/**\n * Takes any string and returns an OKLCH color.\n */\nexport function okhash(value: string) {\n  let hue = 0;\n  for (let i = 0; i < value.length; i++) {\n    hue = (hue + value.charCodeAt(i) * 10) % 360;\n  }\n  return `oklch(0.68 0.15 ${hue}deg)`;\n}\n\nexport type MatcherFunction = (value: string) => boolean;\n\n/**\n * Parses a filter string into a matcher function.\n *\n * @param pattern - A string or regular expression that specifies a pattern for names of loggers whose messages you want to display.\n */\nexport function createMatcher(pattern: string | RegExp): MatcherFunction {\n  if (pattern instanceof RegExp) {\n    return (value: string) => pattern.test(value);\n  }\n\n  const matchers: Record<\"positive\" | \"negative\", MatcherFunction[]> = {\n    positive: [],\n    negative: [],\n  };\n\n  const parts = pattern\n    .split(\",\")\n    .map((p) => p.trim())\n    .filter((p) => p !== \"\");\n\n  for (let part of parts) {\n    let section: \"positive\" | \"negative\" = \"positive\";\n\n    if (part.startsWith(\"-\")) {\n      section = \"negative\";\n      part = part.slice(1);\n    }\n\n    if (part === \"*\") {\n      matchers[section].push(function () {\n        return true;\n      });\n    } else if (part.endsWith(\"*\")) {\n      matchers[section].push(function (value) {\n        return value.startsWith(part.slice(0, part.length - 1));\n      });\n    } else {\n      matchers[section].push(function (value) {\n        return value === part;\n      });\n    }\n  }\n\n  return function (name: string) {\n    const { positive, negative } = matchers;\n\n    // Matching any negative matcher disqualifies.\n    if (negative.some((fn) => fn(name))) {\n      return false;\n    }\n\n    // Matching at least one positive matcher is required if any are specified.\n    if (positive.length > 0 && !positive.some((fn) => fn(name))) {\n      return false;\n    }\n\n    return true;\n  };\n}\n","import type { Env } from \"../types\";\n\nlet currentEnv = \"production\";\n\nexport function getEnv() {\n  return currentEnv;\n}\n\nexport function setEnv(value: Env) {\n  currentEnv = value;\n}\n","import { isString } from \"../typeChecking.js\";\nimport type { Env } from \"../types.js\";\nimport { createMatcher, noOp, okhash, type MatcherFunction } from \"../utils.js\";\nimport { getEnv } from \"./env.js\";\nimport { get, peek, type MaybeSignal } from \"./signals.js\";\n\nexport interface LogLevels {\n  info: boolean | Env;\n  log: boolean | Env;\n  warn: boolean | Env;\n  error: boolean | Env;\n}\n\nexport interface Logger {\n  info(...args: any[]): void;\n  log(...args: any[]): void;\n  warn(...args: any[]): void;\n  error(...args: any[]): void;\n  crash(error: Error): Error;\n}\n\nexport interface LoggerOptions {\n  /**\n   * Tag value to print with logs.\n   */\n  tag?: string;\n\n  /**\n   * Label for tag value. Will be printed without a label if not specified.\n   */\n  tagName?: string;\n\n  /**\n   * Console object to use for logging (mostly for testing). Uses window.console by default.\n   */\n  console?: any;\n}\n\nexport interface LoggerErrorContext {\n  error: Error;\n  loggerName: string;\n  tag?: string;\n  tagName?: string;\n}\n\nlet levels: LogLevels = {\n  info: \"development\",\n  log: \"development\",\n  warn: \"development\",\n  error: true,\n};\nlet match: MatcherFunction = createMatcher(\"*,-dolla.*\");\nlet crashListeners: ((context: LoggerErrorContext) => void)[] = [];\n\nexport function onLoggerCrash(listener: (context: LoggerErrorContext) => void) {\n  crashListeners.push(listener);\n\n  return function cancel() {\n    crashListeners.splice(crashListeners.indexOf(listener), 1);\n  };\n}\n\nexport function createLogger(name: MaybeSignal<string>, options?: LoggerOptions): Logger {\n  const _console = options?.console ?? _getDefaultConsole();\n\n  const bind = (method: keyof LogLevels) => {\n    let _name = peek(name);\n    if (levels[method] === false || (isString(levels[method]) && levels[method] !== getEnv()) || !match(_name)) {\n      return noOp;\n    } else {\n      let label = `%c${_name}`;\n      if (options?.tag) {\n        if (options.tagName) {\n          label += ` %c[${options.tagName}: %c${options.tag}%c]`;\n        } else {\n          label += ` %c[%c${options.tag}%c]`;\n        }\n      } else {\n        label += `%c%c%c`;\n      }\n      return _console[method].bind(\n        _console,\n        label,\n        `color:${okhash(label)};font-weight:bold`,\n        `color:#777`,\n        `color:#aaa`,\n        `color:#777`,\n      );\n    }\n  };\n\n  return {\n    get info() {\n      return bind(\"info\");\n    },\n    get log() {\n      return bind(\"log\");\n    },\n    get warn() {\n      return bind(\"warn\");\n    },\n    get error() {\n      return bind(\"error\");\n    },\n    crash(error: Error) {\n      const ctx: LoggerErrorContext = {\n        error,\n        loggerName: get(name),\n        tag: options?.tag,\n        tagName: options?.tagName,\n      };\n\n      for (const listener of crashListeners) {\n        listener(ctx);\n      }\n\n      return error;\n    },\n  };\n}\n\nexport function setLogFilter(filter: string | RegExp) {\n  match = createMatcher(filter);\n}\n\nexport function setLogLevels(options: Partial<LogLevels>) {\n  for (const key in options) {\n    const value = options[key as keyof LogLevels];\n    if (value) {\n      levels[key as keyof LogLevels] = value;\n    }\n  }\n}\n\nfunction _getDefaultConsole() {\n  if (typeof window !== \"undefined\" && window.console) {\n    return window.console;\n  }\n  if (typeof global !== \"undefined\" && global.console) {\n    return global.console;\n  }\n}\n"],"names":["SubscriberFlags","SubscriberFlags2","createReactiveSystem","updateComputed","notifyEffect2","queuedEffects","queuedEffectsTail","dep","sub","currentDep","nextDep","depLastSub","isValidLink","linkNewDep","link2","targetFlag","subs","stack","top","subFlags","subSubs","depSubs","depsTail","clearTracking","flags","checkDirty","computed2","shallowPropagate","effect2","queuedNext","newLink","oldTail","dirty","depFlags","checkLink","nextSub","prevSub","depDeps","link","propagate","updateDirtyFlag","startTracking","endTracking","processEffectNotifications","processComputedUpdate","processPendingInnerEffects","oldValue","newValue","notifyEffectScope","notifyEffect","runEffect","c","activeSub","queueEffect","_createSource","initialValue","options","value","equals","signal","next","SOURCE","_createSignal","fn","isFunction","SIGNAL","computed","cachedValue","returned","get","PENDING_EFFECTS","flushPending","flushEffects","i","e","pauseTracking","resumeTracking","stopEffect","pauseStack","peek","result","effect","$","init","noOp","idCounter","getUniqueId","strictEqual","a","b","shallowEqual","t","typeOf","size","key","deepEqual","length","keys","omit","object","newObject","okhash","hue","createMatcher","pattern","matchers","parts","p","part","section","name","positive","negative","currentEnv","getEnv","setEnv","levels","match","crashListeners","onLoggerCrash","listener","createLogger","_console","_getDefaultConsole","bind","method","_name","isString","label","error","ctx","setLogFilter","filter","setLogLevels"],"mappings":"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","x_google_ignoreList":[0]}