@but212/atom-effect-jquery 0.8.2

package/dist/index.mjs

@@ -0,0 +1,1799 @@
+import u from "jquery";
+import { default as Nt } from "jquery";
+const Be = {
+  /** One second in milliseconds */
+  ONE_SECOND_MS: 1e3
+}, oe = {
+  IDLE: "idle",
+  PENDING: "pending",
+  RESOLVED: "resolved",
+  REJECTED: "rejected"
+}, Z = {
+  DISPOSED: 1,
+  // 0001 - Effect has been disposed
+  EXECUTING: 2
+  // 0010 - Effect is currently executing
+}, d = {
+  DIRTY: 1,
+  // 0001 - Needs recomputation
+  IDLE: 2,
+  // 0010 - Initial state, not computed yet
+  PENDING: 4,
+  // 0100 - Async computation in progress
+  RESOLVED: 8,
+  // 1000 - Successfully computed
+  REJECTED: 16,
+  // 10000 - Computation failed
+  RECOMPUTING: 32,
+  // 100000 - Currently recomputing
+  HAS_ERROR: 64
+  // 1000000 - Has error state
+}, V = {
+  /** Maximum effect executions per second to detect infinite loops (Legacy/Fallback) */
+  MAX_EXECUTIONS_PER_SECOND: 1e3,
+  /**
+   * Maximum executions per effect within a single flush cycle
+   * Increased from 50 to 100
+   */
+  MAX_EXECUTIONS_PER_EFFECT: 100,
+  /**
+   * Maximum total executions across all effects in a single flush cycle
+   * Increased from 5000 to 10000
+   */
+  MAX_EXECUTIONS_PER_FLUSH: 1e4,
+  /** Maximum iterations for synchronous flush loop to prevent infinite loops */
+  MAX_FLUSH_ITERATIONS: 1e3,
+  /** Minimum allowed value for max flush iterations */
+  MIN_FLUSH_ITERATIONS: 10
+}, Ee = {
+  /** Maximum dependencies before warning about large dependency graphs */
+  MAX_DEPENDENCIES: 1e3,
+  /** Enable infinite loop detection warnings */
+  WARN_INFINITE_LOOP: !0
+}, B = 1073741823, R = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", qe = Object.freeze([]);
+class k extends Error {
+  /**
+   * Creates a new AtomError
+   * @param message - Error message describing what went wrong
+   * @param cause - Original error that caused this error
+   * @param recoverable - Whether the operation can be retried
+   */
+  constructor(e, s = null, n = !0) {
+    super(e), this.name = "AtomError", this.cause = s, this.recoverable = n, this.timestamp = /* @__PURE__ */ new Date();
+  }
+}
+class X extends k {
+  /**
+   * Creates a new ComputedError
+   * @param message - Error message
+   * @param cause - Original error
+   */
+  constructor(e, s = null) {
+    super(e, s, !0), this.name = "ComputedError";
+  }
+}
+class M extends k {
+  /**
+   * Creates a new EffectError
+   * @param message - Error message
+   * @param cause - Original error
+   */
+  constructor(e, s = null) {
+    super(e, s, !1), this.name = "EffectError";
+  }
+}
+class ee extends k {
+  /**
+   * Creates a new SchedulerError
+   * @param message - Error message
+   * @param cause - Original error
+   */
+  constructor(e, s = null) {
+    super(e, s, !1), this.name = "SchedulerError";
+  }
+}
+const m = {
+  // ─────────────────────────────────────────────────────────────────
+  // Computed errors
+  // ─────────────────────────────────────────────────────────────────
+  /**
+   * Error thrown when computed() receives a non-function argument.
+   */
+  COMPUTED_MUST_BE_FUNCTION: "Computed function must be a function",
+  /**
+   * Error thrown when subscribe() receives an invalid listener.
+   */
+  COMPUTED_SUBSCRIBER_MUST_BE_FUNCTION: "Subscriber listener must be a function or Subscriber object",
+  /**
+   * Error thrown when accessing a pending async computed without a default value.
+   */
+  COMPUTED_ASYNC_PENDING_NO_DEFAULT: "Async computation is pending. No default value provided",
+  /**
+   * Error thrown when a synchronous computed computation fails.
+   */
+  COMPUTED_COMPUTATION_FAILED: "Computed computation failed",
+  /**
+   * Error thrown when an asynchronous computed computation fails.
+   */
+  COMPUTED_ASYNC_COMPUTATION_FAILED: "Async computed computation failed",
+  /**
+   * Error thrown when subscribing to a dependency fails.
+   */
+  COMPUTED_DEPENDENCY_SUBSCRIPTION_FAILED: "Failed to subscribe to dependency",
+  // ─────────────────────────────────────────────────────────────────
+  // Atom errors
+  // ─────────────────────────────────────────────────────────────────
+  /**
+   * Error thrown when atom.subscribe() receives an invalid listener.
+   */
+  ATOM_SUBSCRIBER_MUST_BE_FUNCTION: "Subscription listener must be a function or Subscriber object",
+  /**
+   * Error thrown when the atom subscriber notification process fails.
+   */
+  ATOM_SUBSCRIBER_EXECUTION_FAILED: "Error occurred while executing atom subscribers",
+  /**
+   * Error logged when an individual subscriber throws during notification.
+   * @remarks This error is caught and logged to prevent cascading failures.
+   */
+  ATOM_INDIVIDUAL_SUBSCRIBER_FAILED: "Error during individual atom subscriber execution",
+  // ─────────────────────────────────────────────────────────────────
+  // Effect errors
+  // ─────────────────────────────────────────────────────────────────
+  /**
+   * Error thrown when effect() receives a non-function argument.
+   */
+  EFFECT_MUST_BE_FUNCTION: "Effect function must be a function",
+  /**
+   * Error thrown when an effect's execution fails.
+   */
+  EFFECT_EXECUTION_FAILED: "Effect execution failed",
+  /**
+   * Error thrown when an effect's cleanup function fails.
+   */
+  EFFECT_CLEANUP_FAILED: "Effect cleanup function execution failed",
+  // ─────────────────────────────────────────────────────────────────
+  // Debug warnings
+  // ─────────────────────────────────────────────────────────────────
+  /**
+   * Warning message for large dependency graphs.
+   *
+   * @param count - The number of dependencies detected
+   * @returns Formatted warning message with dependency count
+   *
+   * @example
+   * ```ts
+   * console.warn(ERROR_MESSAGES.LARGE_DEPENDENCY_GRAPH(150));
+   * // Output: "Large dependency graph detected: 150 dependencies"
+   * ```
+   */
+  LARGE_DEPENDENCY_GRAPH: (t) => `Large dependency graph detected: ${t} dependencies`,
+  /**
+   * Warning logged when attempting to unsubscribe a non-existent listener.
+   */
+  UNSUBSCRIBE_NON_EXISTENT: "Attempted to unsubscribe a non-existent listener",
+  /**
+   * Error logged when the onError callback itself throws an error.
+   * @remarks This prevents cascading failures from masking the original error.
+   */
+  CALLBACK_ERROR_IN_ERROR_HANDLER: "Error occurred during onError callback execution"
+}, he = /* @__PURE__ */ Symbol("debugName"), ze = /* @__PURE__ */ Symbol("id"), ae = /* @__PURE__ */ Symbol("type"), ge = /* @__PURE__ */ Symbol("noDefaultValue");
+function Xe(t) {
+  return "dependencies" in t && Array.isArray(t.dependencies);
+}
+let me = 0;
+function Ce(t, e, s) {
+  if (t._visitedEpoch !== s) {
+    if (t._visitedEpoch = s, t === e)
+      throw new X("Indirect circular dependency detected");
+    if (Xe(t)) {
+      const n = t.dependencies;
+      for (let i = 0; i < n.length; i++) {
+        const r = n[i];
+        r && Ce(r, e, s);
+      }
+    }
+  }
+}
+const w = {
+  enabled: typeof process < "u" && process.env?.NODE_ENV === "development",
+  maxDependencies: Ee.MAX_DEPENDENCIES,
+  warnInfiniteLoop: Ee.WARN_INFINITE_LOOP,
+  warn(t, e) {
+    this.enabled && t && console.warn(`[Atom Effect] ${e}`);
+  },
+  /**
+   * Checks for circular dependencies.
+   * Direct check runs always; indirect check only in dev mode.
+   * @throws {ComputedError} When circular dependency detected
+   */
+  checkCircular(t, e) {
+    if (t === e)
+      throw new X("Direct circular dependency detected");
+    this.enabled && (me++, Ce(t, e, me));
+  },
+  attachDebugInfo(t, e, s) {
+    if (!this.enabled)
+      return;
+    const n = t;
+    n[he] = `${e}_${s}`, n[ze] = s, n[ae] = e;
+  },
+  getDebugName(t) {
+    if (t != null && he in t)
+      return t[he];
+  },
+  getDebugType(t) {
+    if (t != null && ae in t)
+      return t[ae];
+  }
+};
+let Ge = 1;
+const Qe = () => Ge++;
+class ve {
+  constructor() {
+    this.id = Qe() & B, this.flags = 0;
+  }
+}
+class Ne extends ve {
+  constructor() {
+    super(), this.version = 0, this._lastSeenEpoch = -1;
+  }
+  /**
+   * Subscribes a listener function or Subscriber object to value changes.
+   *
+   * @param listener - Function or Subscriber object to call when the value changes
+   * @returns An unsubscribe function
+   * @throws {AtomError} If listener is not a function or Subscriber
+   */
+  subscribe(e) {
+    if (typeof e == "object" && e !== null && "execute" in e)
+      return this._objectSubscribers.add(e);
+    if (typeof e != "function")
+      throw new k(m.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+    return this._functionSubscribers.add(e);
+  }
+  /**
+   * Gets the total number of active subscribers.
+   */
+  subscriberCount() {
+    return this._functionSubscribers.size + this._objectSubscribers.size;
+  }
+  /**
+   * Notifies all subscribers of a change.
+   *
+   * @param newValue - The new value
+   * @param oldValue - The old value
+   */
+  _notifySubscribers(e, s) {
+    this._functionSubscribers.forEachSafe(
+      (n) => n(e, s),
+      (n) => console.error(new k(m.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, n))
+    ), this._objectSubscribers.forEachSafe(
+      (n) => n.execute(),
+      (n) => console.error(new k(m.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, n))
+    );
+  }
+}
+let te = 0;
+function Te() {
+  return te = (te + 1 | 0) & B, te;
+}
+function He() {
+  return te;
+}
+let ne = 0, fe = 0, ie = !1;
+function Se() {
+  return ie ? (R && console.warn(
+    "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
+  ), !1) : (ie = !0, ne = ne + 1 & B, fe = 0, !0);
+}
+function ye() {
+  ie = !1;
+}
+function Je() {
+  return ie ? ++fe : 0;
+}
+class Ye {
+  constructor() {
+    this.queueA = [], this.queueB = [], this.queue = this.queueA, this.queueSize = 0, this._epoch = 0, this.isProcessing = !1, this.isBatching = !1, this.batchDepth = 0, this.batchQueue = [], this.batchQueueSize = 0, this.isFlushingSync = !1, this.maxFlushIterations = V.MAX_FLUSH_ITERATIONS;
+  }
+  get phase() {
+    return this.isProcessing || this.isFlushingSync ? 2 : this.isBatching ? 1 : 0;
+  }
+  /**
+   * Schedules a task for execution.
+   * Tasks are deduplicated within the same flush cycle using epoch tracking.
+   * @param callback - The function to execute.
+   * @throws {SchedulerError} If the callback is not a function.
+   */
+  schedule(e) {
+    if (typeof e != "function")
+      throw new ee("Scheduler callback must be a function");
+    e._nextEpoch !== this._epoch && (e._nextEpoch = this._epoch, this.isBatching || this.isFlushingSync ? this.batchQueue[this.batchQueueSize++] = e : (this.queue[this.queueSize++] = e, this.isProcessing || this.flush()));
+  }
+  flush() {
+    if (this.isProcessing || this.queueSize === 0) return;
+    this.isProcessing = !0;
+    const e = this.queue, s = this.queueSize;
+    this.queue = this.queue === this.queueA ? this.queueB : this.queueA, this.queueSize = 0, this._epoch++, queueMicrotask(() => {
+      const n = Se();
+      this._processJobs(e, s), this.isProcessing = !1, n && ye(), this.queueSize > 0 && !this.isBatching && this.flush();
+    });
+  }
+  flushSync() {
+    this.isFlushingSync = !0;
+    const e = Se();
+    try {
+      this._mergeBatchQueue(), this._drainQueue();
+    } finally {
+      this.isFlushingSync = !1, e && ye();
+    }
+  }
+  _mergeBatchQueue() {
+    if (this._epoch++, this.batchQueueSize > 0) {
+      for (let e = 0; e < this.batchQueueSize; e++) {
+        const s = this.batchQueue[e];
+        s && s._nextEpoch !== this._epoch && (s._nextEpoch = this._epoch, this.queue[this.queueSize++] = s);
+      }
+      this.batchQueueSize = 0;
+    }
+  }
+  _drainQueue() {
+    let e = 0;
+    for (; this.queueSize > 0; ) {
+      if (++e > this.maxFlushIterations) {
+        this._handleFlushOverflow();
+        break;
+      }
+      this._processCurrentQueue(), this._mergeBatchQueue();
+    }
+  }
+  _processCurrentQueue() {
+    const e = this.queue, s = this.queueSize;
+    this.queue = this.queue === this.queueA ? this.queueB : this.queueA, this.queueSize = 0, this._epoch++, this._processJobs(e, s);
+  }
+  _handleFlushOverflow() {
+    console.error(
+      new ee(
+        `Maximum flush iterations (${this.maxFlushIterations}) exceeded. Possible infinite loop.`
+      )
+    ), this.queueSize = 0, this.queue.length = 0, this.batchQueueSize = 0;
+  }
+  _processJobs(e, s) {
+    for (let n = 0; n < s; n++)
+      try {
+        e[n]?.();
+      } catch (i) {
+        console.error(
+          new ee("Error occurred during scheduler execution", i)
+        );
+      }
+    e.length = 0;
+  }
+  /** Starts a new batch of updates. Updates will be deferred until endBatch is called. */
+  startBatch() {
+    this.batchDepth++, this.isBatching = !0;
+  }
+  /**
+   * Ends the current batch. If the batch depth reaches zero, all pending updates are flushed synchronously.
+   */
+  endBatch() {
+    this.batchDepth = Math.max(0, this.batchDepth - 1), this.batchDepth === 0 && (this.flushSync(), this.isBatching = !1);
+  }
+  /**
+   * Configures the maximum number of iterations allowed during a synchronous flush.
+   * Used to prevent infinite loops.
+   * @param max - Maximum iterations count.
+   */
+  setMaxFlushIterations(e) {
+    if (e < V.MIN_FLUSH_ITERATIONS)
+      throw new ee(
+        `Max flush iterations must be at least ${V.MIN_FLUSH_ITERATIONS}`
+      );
+    this.maxFlushIterations = e;
+  }
+}
+const Y = new Ye();
+function z(t) {
+  if (typeof t != "function")
+    throw new k("Batch callback must be a function");
+  Y.startBatch();
+  try {
+    return t();
+  } finally {
+    Y.endBatch();
+  }
+}
+const q = {
+  current: null,
+  run(t, e) {
+    const s = this.current;
+    this.current = t;
+    try {
+      return e();
+    } finally {
+      this.current = s;
+    }
+  },
+  getCurrent() {
+    return this.current;
+  }
+};
+function Re(t) {
+  if (typeof t != "function")
+    throw new k("Untracked callback must be a function");
+  const e = q.current;
+  q.current = null;
+  try {
+    return t();
+  } finally {
+    q.current = e;
+  }
+}
+class re {
+  constructor() {
+    this.subscribers = null;
+  }
+  /** Adds subscriber and returns unsubscribe function (idempotent) */
+  add(e) {
+    if (this.subscribers || (this.subscribers = []), this.subscribers.indexOf(e) !== -1)
+      return () => {
+      };
+    this.subscribers.push(e);
+    let s = !1;
+    return () => {
+      s || (s = !0, this.remove(e));
+    };
+  }
+  /** Removes subscriber using swap-and-pop */
+  remove(e) {
+    if (!this.subscribers)
+      return !1;
+    const s = this.subscribers.indexOf(e);
+    if (s === -1)
+      return !1;
+    const n = this.subscribers.length - 1;
+    return s !== n && (this.subscribers[s] = this.subscribers[n]), this.subscribers.pop(), !0;
+  }
+  has(e) {
+    return this.subscribers ? this.subscribers.indexOf(e) !== -1 : !1;
+  }
+  forEach(e) {
+    if (this.subscribers)
+      for (let s = 0; s < this.subscribers.length; s++)
+        e(this.subscribers[s], s);
+  }
+  /** Iterates with error handling to prevent one failure from breaking the chain */
+  forEachSafe(e, s) {
+    if (this.subscribers)
+      for (let n = 0; n < this.subscribers.length; n++)
+        try {
+          e(this.subscribers[n], n);
+        } catch (i) {
+          s ? s(i) : console.error("[SubscriberManager] Error in subscriber callback:", i);
+        }
+  }
+  get size() {
+    return this.subscribers?.length ?? 0;
+  }
+  get hasSubscribers() {
+    return this.subscribers !== null && this.subscribers.length > 0;
+  }
+  clear() {
+    this.subscribers = null;
+  }
+  toArray() {
+    return this.subscribers ? [...this.subscribers] : [];
+  }
+}
+function le(t) {
+  return t !== null && typeof t == "object" && "value" in t && "subscribe" in t && typeof t.subscribe == "function";
+}
+function De(t) {
+  if (w.enabled && (t == null || typeof t == "object")) {
+    const e = w.getDebugType(t);
+    if (e)
+      return e === "computed";
+  }
+  return le(t) && "invalidate" in t && typeof t.invalidate == "function";
+}
+function Ue(t) {
+  return t != null && typeof t.then == "function";
+}
+function Ke(t) {
+  return typeof t == "object" && t !== null;
+}
+function xe(t) {
+  return (typeof t == "object" || typeof t == "function") && t !== null && typeof t.addDependency == "function";
+}
+function Oe(t) {
+  return typeof t == "function" && typeof t.addDependency != "function";
+}
+function Ae(t) {
+  return Ke(t) && typeof t.execute == "function";
+}
+class We extends Ne {
+  constructor(e, s) {
+    super(), this._isNotificationScheduled = !1, this._value = e, this._functionSubscribersStore = new re(), this._objectSubscribersStore = new re(), this._sync = s, this._notifyTask = this._flushNotifications.bind(this), w.attachDebugInfo(this, "atom", this.id);
+  }
+  /** Gets the manager for function-based subscribers. */
+  get _functionSubscribers() {
+    return this._functionSubscribersStore;
+  }
+  /** Gets the manager for object-based subscribers. */
+  get _objectSubscribers() {
+    return this._objectSubscribersStore;
+  }
+  /**
+   * Returns the current value and registers the atom as a dependency in the current tracking context.
+   */
+  get value() {
+    const e = q.getCurrent();
+    return e && this._track(e), this._value;
+  }
+  /**
+   * Sets a new value and schedules notifications if the value has changed.
+   * Uses `Object.is` for comparison.
+   */
+  set value(e) {
+    if (Object.is(this._value, e)) return;
+    const s = this._value;
+    this.version = this.version + 1 & B, this._value = e, !(!this._functionSubscribersStore.hasSubscribers && !this._objectSubscribersStore.hasSubscribers) && this._scheduleNotification(s);
+  }
+  _track(e) {
+    if (xe(e)) {
+      e.addDependency(this);
+      return;
+    }
+    if (Oe(e)) {
+      this._functionSubscribersStore.add(e);
+      return;
+    }
+    Ae(e) && this._objectSubscribersStore.add(e);
+  }
+  _scheduleNotification(e) {
+    this._isNotificationScheduled || (this._pendingOldValue = e, this._isNotificationScheduled = !0), this._sync && !Y.isBatching ? this._flushNotifications() : Y.schedule(this._notifyTask);
+  }
+  _flushNotifications() {
+    if (!this._isNotificationScheduled) return;
+    const e = this._pendingOldValue, s = this._value;
+    this._pendingOldValue = void 0, this._isNotificationScheduled = !1, this._notifySubscribers(s, e);
+  }
+  /**
+   * Returns the current value without registering as a dependency in the tracking context.
+   */
+  peek() {
+    return this._value;
+  }
+  /**
+   * Disposes of the atom, clearing all subscribers and resetting the value.
+   */
+  dispose() {
+    this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this._value = void 0;
+  }
+}
+function Ze(t, e = {}) {
+  return new We(t, e.sync ?? !1);
+}
+class de {
+  constructor() {
+    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = R ? {
+      acquired: 0,
+      released: 0,
+      rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
+    } : null;
+  }
+  /** Acquires an array from the pool or creates a new one if the pool is empty. */
+  acquire() {
+    return R && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
+  }
+  /**
+   * Releases an array back to the pool.
+   * Clears the array before storing it.
+   * @param arr - The array to release.
+   * @param emptyConst - Optional reference to a constant empty array to skip.
+   */
+  release(e, s) {
+    if (!(s && e === s)) {
+      if (Object.isFrozen(e)) {
+        R && this.stats && this.stats.rejected.frozen++;
+        return;
+      }
+      if (e.length > this.maxReusableCapacity) {
+        R && this.stats && this.stats.rejected.tooLarge++;
+        return;
+      }
+      if (this.pool.length >= this.maxPoolSize) {
+        R && this.stats && this.stats.rejected.poolFull++;
+        return;
+      }
+      e.length = 0, this.pool.push(e), R && this.stats && this.stats.released++;
+    }
+  }
+  /** Returns current stats for the pool (dev mode only). */
+  getStats() {
+    if (!R || !this.stats) return null;
+    const { acquired: e, released: s, rejected: n } = this.stats, i = n.frozen + n.tooLarge + n.poolFull;
+    return {
+      acquired: e,
+      released: s,
+      rejected: n,
+      leaked: e - s - i,
+      poolSize: this.pool.length
+    };
+  }
+  /** Resets the pool and its stats. */
+  reset() {
+    this.pool.length = 0, R && this.stats && (this.stats.acquired = 0, this.stats.released = 0, this.stats.rejected = { frozen: 0, tooLarge: 0, poolFull: 0 });
+  }
+}
+const y = Object.freeze([]), O = Object.freeze([]), D = Object.freeze([]), $ = new de(), j = new de(), A = new de();
+function et(t, e, s, n) {
+  if (e !== y && s !== O)
+    for (let r = 0; r < e.length; r++) {
+      const o = e[r];
+      o && (o._tempUnsub = s[r]);
+    }
+  const i = j.acquire();
+  i.length = t.length;
+  for (let r = 0; r < t.length; r++) {
+    const o = t[r];
+    o && (o._tempUnsub ? (i[r] = o._tempUnsub, o._tempUnsub = void 0) : (w.checkCircular(o, n), i[r] = o.subscribe(n)));
+  }
+  if (e !== y)
+    for (let r = 0; r < e.length; r++) {
+      const o = e[r];
+      o?._tempUnsub && (o._tempUnsub(), o._tempUnsub = void 0);
+    }
+  return s !== O && j.release(s), i;
+}
+function G(t, e, s) {
+  if (t instanceof TypeError)
+    return new e(`Type error (${s}): ${t.message}`, t);
+  if (t instanceof ReferenceError)
+    return new e(`Reference error (${s}): ${t.message}`, t);
+  if (t instanceof k)
+    return t;
+  const n = t instanceof Error ? t.message : String(t), i = t instanceof Error ? t : null;
+  return new e(`Unexpected error (${s}): ${n}`, i);
+}
+const we = d.RESOLVED | d.PENDING | d.REJECTED, ce = Array(we + 1).fill(oe.IDLE);
+ce[d.RESOLVED] = oe.RESOLVED;
+ce[d.PENDING] = oe.PENDING;
+ce[d.REJECTED] = oe.REJECTED;
+class ke extends Ne {
+  constructor(e, s = {}) {
+    if (typeof e != "function")
+      throw new X(m.COMPUTED_MUST_BE_FUNCTION);
+    if (super(), this._cachedErrors = null, this._errorCacheEpoch = -1, this._value = void 0, this.flags = d.DIRTY | d.IDLE, this._error = null, this._promiseId = 0, this._equal = s.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in s ? s.defaultValue : ge, this._hasDefaultValue = this._defaultValue !== ge, this._onError = s.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._functionSubscribersStore = new re(), this._objectSubscribersStore = new re(), this._dependencies = y, this._dependencyVersions = D, this._unsubscribes = O, this._notifyJob = () => {
+      this._functionSubscribersStore.forEachSafe(
+        (n) => n(),
+        (n) => console.error(n)
+      ), this._objectSubscribersStore.forEachSafe(
+        (n) => n.execute(),
+        (n) => console.error(n)
+      );
+    }, this._trackable = Object.assign(() => this._markDirty(), {
+      addDependency: (n) => {
+      }
+    }), w.attachDebugInfo(this, "computed", this.id), w.enabled) {
+      const n = this;
+      n.subscriberCount = () => this._functionSubscribersStore.size + this._objectSubscribersStore.size, n.isDirty = () => this._isDirty(), n.dependencies = this._dependencies, n.stateFlags = this._getFlagsAsString();
+    }
+    if (s.lazy === !1)
+      try {
+        this._recompute();
+      } catch {
+      }
+  }
+  get _functionSubscribers() {
+    return this._functionSubscribersStore;
+  }
+  get _objectSubscribers() {
+    return this._objectSubscribersStore;
+  }
+  get value() {
+    return this._registerTracking(), this._computeValue();
+  }
+  peek() {
+    return this._value;
+  }
+  get state() {
+    return this._registerTracking(), this._getAsyncState();
+  }
+  get hasError() {
+    if (this._registerTracking(), this._isRejected())
+      return !0;
+    for (let e = 0; e < this._dependencies.length; e++) {
+      const s = this._dependencies[e];
+      if (s && "hasError" in s && s.hasError)
+        return !0;
+    }
+    return !1;
+  }
+  get isValid() {
+    return !this.hasError;
+  }
+  get errors() {
+    if (this._registerTracking(), !this.hasError)
+      return qe;
+    const e = He();
+    if (this._errorCacheEpoch === e && this._cachedErrors !== null)
+      return this._cachedErrors;
+    const s = /* @__PURE__ */ new Set();
+    this._error && s.add(this._error);
+    for (let n = 0; n < this._dependencies.length; n++) {
+      const i = this._dependencies[n];
+      if (i && "errors" in i) {
+        const r = i.errors;
+        for (let o = 0; o < r.length; o++) {
+          const c = r[o];
+          c && s.add(c);
+        }
+      }
+    }
+    return this._cachedErrors = Object.freeze([...s]), this._errorCacheEpoch = e, this._cachedErrors;
+  }
+  get lastError() {
+    return this._registerTracking(), this._error;
+  }
+  get isPending() {
+    return this._registerTracking(), this._isPending();
+  }
+  get isResolved() {
+    return this._registerTracking(), this._isResolved();
+  }
+  invalidate() {
+    this._markDirty(), this._dependencyVersions !== D && (A.release(this._dependencyVersions), this._dependencyVersions = D), this._errorCacheEpoch = -1, this._cachedErrors = null;
+  }
+  dispose() {
+    if (this._unsubscribes !== O) {
+      for (let e = 0; e < this._unsubscribes.length; e++) {
+        const s = this._unsubscribes[e];
+        s && s();
+      }
+      j.release(this._unsubscribes), this._unsubscribes = O;
+    }
+    this._dependencies !== y && ($.release(this._dependencies), this._dependencies = y), this._dependencyVersions !== D && (A.release(this._dependencyVersions), this._dependencyVersions = D), this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this.flags = d.DIRTY | d.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID, this._cachedErrors = null, this._errorCacheEpoch = -1;
+  }
+  // State flag operations
+  _isDirty() {
+    return (this.flags & d.DIRTY) !== 0;
+  }
+  _setDirty() {
+    this.flags |= d.DIRTY;
+  }
+  _clearDirty() {
+    this.flags &= -2;
+  }
+  _isIdle() {
+    return (this.flags & d.IDLE) !== 0;
+  }
+  _setIdle() {
+    this.flags |= d.IDLE, this.flags &= -29;
+  }
+  _isPending() {
+    return (this.flags & d.PENDING) !== 0;
+  }
+  _setPending() {
+    this.flags |= d.PENDING, this.flags &= -27;
+  }
+  _isResolved() {
+    return (this.flags & d.RESOLVED) !== 0;
+  }
+  _setResolved() {
+    this.flags |= d.RESOLVED, this.flags &= -87;
+  }
+  _isRejected() {
+    return (this.flags & d.REJECTED) !== 0;
+  }
+  _setRejected() {
+    this.flags |= d.REJECTED | d.HAS_ERROR, this.flags &= -15;
+  }
+  _isRecomputing() {
+    return (this.flags & d.RECOMPUTING) !== 0;
+  }
+  _setRecomputing(e) {
+    const s = d.RECOMPUTING;
+    this.flags = this.flags & ~s | -Number(e) & s;
+  }
+  _getAsyncState() {
+    return ce[this.flags & we];
+  }
+  _getFlagsAsString() {
+    const e = [];
+    return this._isDirty() && e.push("DIRTY"), this._isIdle() && e.push("IDLE"), this._isPending() && e.push("PENDING"), this._isResolved() && e.push("RESOLVED"), this._isRejected() && e.push("REJECTED"), this._isRecomputing() && e.push("RECOMPUTING"), e.join(" | ");
+  }
+  _computeValue() {
+    return this._isRecomputing() ? this._value : ((this._isDirty() || this._isIdle()) && this._recompute(), this._isPending() ? this._handlePending() : this._isRejected() ? this._handleRejected() : this._value);
+  }
+  _recompute() {
+    if (this._isRecomputing()) return;
+    this._setRecomputing(!0);
+    const e = this._prepareComputationContext();
+    let s = !1;
+    try {
+      const n = q.run(this._trackable, this._fn);
+      this._commitDependencies(e), s = !0, Ue(n) ? this._handleAsyncComputation(n) : this._handleSyncResult(n);
+    } catch (n) {
+      if (!s)
+        try {
+          this._commitDependencies(e), s = !0;
+        } catch (i) {
+          this._handleComputationError(i);
+        }
+      this._handleComputationError(n);
+    } finally {
+      this._cleanupContext(e, s), this._setRecomputing(!1);
+    }
+  }
+  _prepareComputationContext() {
+    const e = this._dependencies, s = this._dependencyVersions, n = $.acquire(), i = A.acquire(), r = Te(), o = { depCount: 0 }, c = (_) => {
+      _._lastSeenEpoch !== r && (_._lastSeenEpoch = r, o.depCount < n.length ? (n[o.depCount] = _, i[o.depCount] = _.version) : (n.push(_), i.push(_.version)), o.depCount++);
+    }, f = this._trackable.addDependency;
+    return this._trackable.addDependency = c, { prevDeps: e, prevVersions: s, nextDeps: n, nextVersions: i, originalAdd: f, state: o };
+  }
+  _commitDependencies(e) {
+    const { nextDeps: s, nextVersions: n, state: i, prevDeps: r } = e;
+    s.length = i.depCount, n.length = i.depCount, this._unsubscribes = et(s, r, this._unsubscribes, this), this._dependencies = s, this._dependencyVersions = n;
+  }
+  _cleanupContext(e, s) {
+    this._trackable.addDependency = e.originalAdd, s ? (e.prevDeps !== y && $.release(e.prevDeps), e.prevVersions !== D && A.release(e.prevVersions)) : ($.release(e.nextDeps), A.release(e.nextVersions));
+  }
+  _handleSyncResult(e) {
+    const s = !this._isResolved() || !this._equal(this._value, e);
+    this.version = this.version + Number(s) & B, this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1;
+  }
+  _handleAsyncComputation(e) {
+    this._setPending(), this._clearDirty(), this._notifyJob(), this._promiseId = this._promiseId >= this.MAX_PROMISE_ID ? 1 : this._promiseId + 1;
+    const s = this._promiseId;
+    e.then((n) => {
+      s === this._promiseId && this._handleAsyncResolution(n);
+    }).catch((n) => {
+      s === this._promiseId && this._handleAsyncRejection(n);
+    });
+  }
+  _handleAsyncResolution(e) {
+    const s = !this._isResolved() || !this._equal(this._value, e);
+    this.version = this.version + Number(s) & B, this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1, this._notifyJob();
+  }
+  _handleAsyncRejection(e) {
+    const s = G(e, X, m.COMPUTED_ASYNC_COMPUTATION_FAILED), n = !this._isRejected();
+    if (this.version = this.version + Number(n) & B, this._error = s, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
+      try {
+        this._onError(s);
+      } catch (i) {
+        console.error(m.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
+      }
+    this._notifyJob();
+  }
+  _handleComputationError(e) {
+    const s = G(e, X, m.COMPUTED_COMPUTATION_FAILED);
+    if (this._error = s, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
+      try {
+        this._onError(s);
+      } catch (n) {
+        console.error(m.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
+      }
+    throw s;
+  }
+  _handlePending() {
+    if (this._hasDefaultValue)
+      return this._defaultValue;
+    throw new X(m.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+  }
+  _handleRejected() {
+    if (this._error?.recoverable && this._hasDefaultValue)
+      return this._defaultValue;
+    throw this._error;
+  }
+  /** Subscriber interface - marks dirty on dependency change */
+  execute() {
+    this._markDirty();
+  }
+  _markDirty() {
+    this._isRecomputing() || this._isDirty() || (this._setDirty(), this._notifyJob());
+  }
+  _registerTracking() {
+    const e = q.getCurrent();
+    if (e) {
+      if (xe(e)) {
+        e.addDependency(this);
+        return;
+      }
+      if (Oe(e)) {
+        this._functionSubscribersStore.add(e);
+        return;
+      }
+      Ae(e) && this._objectSubscribersStore.add(e);
+    }
+  }
+}
+Object.freeze(ke.prototype);
+function tt(t, e = {}) {
+  return new ke(t, e);
+}
+class st extends ve {
+  /**
+   * Creates a new EffectImpl instance.
+   * @param fn - The effect function to run.
+   * @param options - Configuration options for the effect.
+   */
+  constructor(e, s = {}) {
+    super(), this.run = () => {
+      if (this.isDisposed)
+        throw new M(m.EFFECT_MUST_BE_FUNCTION);
+      this._dependencyVersions !== D && (A.release(this._dependencyVersions), this._dependencyVersions = D), this.execute();
+    }, this.dispose = () => {
+      if (!this.isDisposed) {
+        if (this._setDisposed(), this._safeCleanup(), this._unsubscribes !== O) {
+          for (let n = 0; n < this._unsubscribes.length; n++) {
+            const i = this._unsubscribes[n];
+            i && i();
+          }
+          j.release(this._unsubscribes), this._unsubscribes = O;
+        }
+        this._dependencies !== y && ($.release(this._dependencies), this._dependencies = y), this._dependencyVersions !== D && (A.release(this._dependencyVersions), this._dependencyVersions = D);
+      }
+    }, this.addDependency = (n) => {
+      if (this.isExecuting && this._nextDeps && this._nextUnsubs && this._nextVersions) {
+        const i = this._currentEpoch;
+        if (n._lastSeenEpoch === i) return;
+        n._lastSeenEpoch = i, this._nextDeps.push(n), this._nextVersions.push(n.version), n._tempUnsub ? (this._nextUnsubs.push(n._tempUnsub), n._tempUnsub = void 0) : this._subscribeTo(n);
+      }
+    }, this.execute = () => {
+      if (this.isDisposed || this.isExecuting || !this._shouldExecute()) return;
+      this._checkInfiniteLoop(), this._setExecuting(!0), this._safeCleanup();
+      const n = this._prepareEffectContext();
+      let i = !1;
+      try {
+        const r = q.run(this, this._fn);
+        this._commitEffect(n), i = !0, this._checkLoopWarnings(), Ue(r) ? r.then((o) => {
+          !this.isDisposed && typeof o == "function" && (this._cleanup = o);
+        }).catch((o) => {
+          console.error(G(o, M, m.EFFECT_EXECUTION_FAILED));
+        }) : this._cleanup = typeof r == "function" ? r : null;
+      } catch (r) {
+        i = !0, console.error(G(r, M, m.EFFECT_EXECUTION_FAILED)), this._cleanup = null;
+      } finally {
+        this._cleanupEffect(n, i), this._setExecuting(!1);
+      }
+    }, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = s.sync ?? !1, this._maxExecutions = s.maxExecutionsPerSecond ?? V.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = s.maxExecutionsPerFlush ?? V.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = s.trackModifications ?? !1, this._cleanup = null, this._dependencies = y, this._dependencyVersions = D, this._unsubscribes = O, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._history = R ? [] : null, this._executionCount = 0, w.attachDebugInfo(this, "effect", this.id);
+  }
+  /**
+   * Prepares the execution context by acquiring pools and setting up epoch.
+   * @returns The prepared EffectContext.
+   */
+  _prepareEffectContext() {
+    const e = this._dependencies, s = this._dependencyVersions, n = this._unsubscribes, i = $.acquire(), r = A.acquire(), o = j.acquire(), c = Te();
+    if (e !== y && n !== O)
+      for (let f = 0; f < e.length; f++) {
+        const _ = e[f];
+        _ && (_._tempUnsub = n[f]);
+      }
+    return this._nextDeps = i, this._nextVersions = r, this._nextUnsubs = o, this._currentEpoch = c, { prevDeps: e, prevVersions: s, prevUnsubs: n, nextDeps: i, nextVersions: r, nextUnsubs: o };
+  }
+  /**
+   * Commits the tracked dependencies as the current active dependencies.
+   * @param ctx - The current effect context.
+   */
+  _commitEffect(e) {
+    const s = e.nextDeps.length;
+    e.nextDeps.length = s, e.nextVersions.length = s, this._dependencies = e.nextDeps, this._dependencyVersions = e.nextVersions, this._unsubscribes = e.nextUnsubs;
+  }
+  /**
+   * Cleans up the effect execution context, releasing resources back to pools.
+   * @param ctx - The effect context to clean up.
+   * @param committed - Whether the changes were committed to the effect.
+   */
+  _cleanupEffect(e, s) {
+    if (this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, s) {
+      if (e.prevDeps !== y) {
+        for (let n = 0; n < e.prevDeps.length; n++) {
+          const i = e.prevDeps[n];
+          i?._tempUnsub && (i._tempUnsub(), i._tempUnsub = void 0);
+        }
+        $.release(e.prevDeps);
+      }
+      e.prevUnsubs !== O && j.release(e.prevUnsubs), e.prevVersions !== D && A.release(e.prevVersions);
+    } else {
+      $.release(e.nextDeps), A.release(e.nextVersions);
+      for (let n = 0; n < e.nextUnsubs.length; n++)
+        e.nextUnsubs[n]?.();
+      if (j.release(e.nextUnsubs), e.prevDeps !== y)
+        for (let n = 0; n < e.prevDeps.length; n++) {
+          const i = e.prevDeps[n];
+          i && (i._tempUnsub = void 0);
+        }
+    }
+  }
+  /**
+   * Subscribes to a dependency's changes.
+   * @param dep - The dependency to subscribe to.
+   */
+  _subscribeTo(e) {
+    try {
+      const s = e.subscribe(() => {
+        this._trackModifications && this.isExecuting && (e._modifiedAtEpoch = this._currentEpoch), this._sync ? this.execute() : Y.schedule(this.execute);
+      });
+      this._nextUnsubs && this._nextUnsubs.push(s);
+    } catch (s) {
+      console.error(G(s, M, m.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
+      });
+    }
+  }
+  /**
+   * Whether the effect has been disposed.
+   */
+  get isDisposed() {
+    return (this.flags & Z.DISPOSED) !== 0;
+  }
+  /**
+   * Total number of times this effect has executed.
+   */
+  get executionCount() {
+    return this._executionCount;
+  }
+  /**
+   * Whether the effect is currently executing.
+   */
+  get isExecuting() {
+    return (this.flags & Z.EXECUTING) !== 0;
+  }
+  _setDisposed() {
+    this.flags |= Z.DISPOSED;
+  }
+  _setExecuting(e) {
+    const s = Z.EXECUTING;
+    this.flags = this.flags & ~s | -Number(e) & s;
+  }
+  /**
+   * Executes the cleanup function if it exists.
+   */
+  _safeCleanup() {
+    if (this._cleanup) {
+      try {
+        this._cleanup();
+      } catch (e) {
+        console.error(G(e, M, m.EFFECT_CLEANUP_FAILED));
+      }
+      this._cleanup = null;
+    }
+  }
+  /**
+   * Checks for infinite loops by tracking execution counts within a flush and time period.
+   * @throws {EffectError} If an infinite loop is detected.
+   */
+  _checkInfiniteLoop() {
+    if (this._lastFlushEpoch !== ne && (this._lastFlushEpoch = ne, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), Je() > V.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history) {
+      const e = Date.now();
+      this._history.push(e), this._history.length > V.MAX_EXECUTIONS_PER_SECOND + 10 && this._history.shift(), this._checkTimestampLoop(e);
+    }
+  }
+  _checkTimestampLoop(e) {
+    const s = this._history;
+    if (!s || this._maxExecutions <= 0) return;
+    const n = e - Be.ONE_SECOND_MS;
+    let i = 0;
+    for (let r = s.length - 1; r >= 0 && !(s[r] < n); r--)
+      i++;
+    if (i > this._maxExecutions) {
+      const r = new M(
+        `Effect executed ${i} times within 1 second. Infinite loop suspected`
+      );
+      if (this.dispose(), console.error(r), R)
+        throw r;
+    }
+  }
+  _throwInfiniteLoopError(e) {
+    const s = new M(
+      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${fe}`
+    );
+    throw this.dispose(), console.error(s), s;
+  }
+  /**
+   * Determines if the effect should execute based on dependency versions.
+   * @returns true if any dependency has changed or if it's the first run.
+   */
+  _shouldExecute() {
+    if (this._dependencies === y || this._dependencyVersions === D)
+      return !0;
+    for (let e = 0; e < this._dependencies.length; e++) {
+      const s = this._dependencies[e];
+      if (s) {
+        if ("value" in s)
+          try {
+            Re(() => s.value);
+          } catch {
+            return !0;
+          }
+        if (s.version !== this._dependencyVersions[e])
+          return !0;
+      }
+    }
+    return !1;
+  }
+  /**
+   * Checks for potential infinite loops where an effect modifies its own dependencies.
+   * Only active if trackModifications is enabled and debug is on.
+   */
+  _checkLoopWarnings() {
+    if (this._trackModifications && w.enabled) {
+      const e = this._dependencies;
+      for (let s = 0; s < e.length; s++) {
+        const n = e[s];
+        n && n._modifiedAtEpoch === this._currentEpoch && w.warn(
+          !0,
+          `Effect is reading a dependency (${w.getDebugName(n) || "unknown"}) that it just modified. Infinite loop may occur`
+        );
+      }
+    }
+  }
+}
+function I(t, e = {}) {
+  if (typeof t != "function")
+    throw new M(m.EFFECT_MUST_BE_FUNCTION);
+  const s = new st(t, e);
+  return s.execute(), s;
+}
+function b(t) {
+  return t !== null && typeof t == "object" && "value" in t && "subscribe" in t;
+}
+function E(t) {
+  return b(t) ? t.value : t;
+}
+function ue(t) {
+  const e = t.jquery ? t[0] : t;
+  if (!e) return "unknown";
+  if (e.id) return `#${e.id}`;
+  if (e.className) {
+    const s = String(e.className).split(/\s+/).filter(Boolean).join(".");
+    return s ? `${e.tagName.toLowerCase()}.${s}` : e.tagName.toLowerCase();
+  }
+  return e.tagName.toLowerCase();
+}
+function nt() {
+  if (typeof window < "u") {
+    const t = window.__ATOM_DEBUG__;
+    if (typeof t == "boolean")
+      return t;
+  }
+  try {
+    if (typeof process < "u" && process.env && process.env.NODE_ENV === "development")
+      return !0;
+  } catch {
+  }
+  return !1;
+}
+let P = nt();
+const h = {
+  get enabled() {
+    return P;
+  },
+  set enabled(t) {
+    P = t;
+  },
+  log(t, ...e) {
+    P && console.log(`[atom-effect-jquery] ${t}:`, ...e);
+  },
+  atomChanged(t, e, s) {
+    P && console.log(`[atom-effect-jquery] Atom "${t || "anonymous"}" changed:`, e, "→", s);
+  },
+  /**
+   * Logs DOM updates and triggers visual highlight.
+   */
+  domUpdated(t, e, s) {
+    if (!P) return;
+    const n = ue(t);
+    console.log(`[atom-effect-jquery] DOM updated: ${n}.${e} =`, s), it(t);
+  },
+  cleanup(t) {
+    P && console.log(`[atom-effect-jquery] Cleanup: ${t}`);
+  },
+  warn(...t) {
+    P && console.warn("[atom-effect-jquery]", ...t);
+  }
+};
+function it(t) {
+  const e = t[0];
+  if (!e || !document.contains(e)) return;
+  const s = "atom_debug_timer", n = "atom_debug_cleanup_timer", i = "atom_debug_org_style";
+  clearTimeout(t.data(s)), clearTimeout(t.data(n)), t.data(i) || t.data(i, {
+    outline: t.css("outline"),
+    outlineOffset: t.css("outline-offset"),
+    transition: t.css("transition")
+  }), t.css({
+    outline: "2px solid rgba(255, 68, 68, 0.8)",
+    "outline-offset": "1px",
+    transition: "none"
+    // Remove transition for instant feedback on update
+  });
+  const r = setTimeout(() => {
+    const o = t.data(i);
+    t.css("transition", "outline 0.5s ease-out"), requestAnimationFrame(() => {
+      t.css({
+        outline: o?.outline || "",
+        "outline-offset": o?.outlineOffset || ""
+      });
+      const c = setTimeout(() => {
+        t.css("transition", o?.transition || ""), t.removeData(s), t.removeData(n), t.removeData(i);
+      }, 500);
+      t.data(n, c);
+    });
+  }, 100);
+  t.data(s, r);
+}
+const rt = /* @__PURE__ */ new WeakMap();
+function Fe(t, e = {}) {
+  const s = Ze(t, e);
+  return e.name && rt.set(s, { name: e.name }), s;
+}
+Object.defineProperty(Fe, "debug", {
+  get() {
+    return h.enabled;
+  },
+  set(t) {
+    h.enabled = t;
+  }
+});
+function ot() {
+  return new Promise((t) => setTimeout(t, 0));
+}
+u.extend({
+  atom: Fe,
+  computed: tt,
+  effect: I,
+  batch: z,
+  untracked: Re,
+  isAtom: le,
+  isComputed: De,
+  isReactive: (t) => le(t) || De(t),
+  nextTick: ot
+});
+function Me() {
+  return { timeoutId: null, phase: "idle", hasFocus: !1 };
+}
+function $e(t, e, s = {}) {
+  const {
+    debounce: n,
+    event: i = "input",
+    parse: r = (p) => p,
+    format: o = (p) => String(p ?? "")
+  } = s, c = Me(), f = () => {
+    c.phase = "composing";
+  }, _ = () => {
+    c.phase = "idle", F();
+  };
+  t.on("compositionstart", f), t.on("compositionend", _);
+  const C = () => {
+    c.hasFocus = !0;
+  }, S = () => {
+    c.hasFocus = !1;
+    const p = o(e.value);
+    t.val() !== p && t.val(p);
+  };
+  t.on("focus", C), t.on("blur", S);
+  const F = () => {
+    c.phase === "idle" && (c.phase = "syncing-to-atom", z(() => {
+      e.value = r(t.val());
+    }), c.phase = "idle");
+  }, v = () => {
+    c.phase === "idle" && (n ? (c.timeoutId && clearTimeout(c.timeoutId), c.timeoutId = window.setTimeout(F, n)) : F());
+  };
+  return t.on(i, v), t.on("change", v), { effect: () => {
+    const p = o(e.value), L = t.val();
+    if (L !== p) {
+      if (c.hasFocus && r(L) === e.value)
+        return;
+      c.phase = "syncing-to-dom", t.val(p), h.domUpdated(t, "val", p), c.phase = "idle";
+    }
+  }, cleanup: () => {
+    t.off(i, v), t.off("change", v), t.off("compositionstart", f), t.off("compositionend", _), t.off("focus", C), t.off("blur", S), c.timeoutId && clearTimeout(c.timeoutId);
+  } };
+}
+class ct {
+  // DOM Element -> Effect Array (for disposal)
+  effects = /* @__PURE__ */ new WeakMap();
+  // DOM Element -> Custom Cleanup Function Array
+  cleanups = /* @__PURE__ */ new WeakMap();
+  // Track bound elements (Performance optimization)
+  boundElements = /* @__PURE__ */ new WeakSet();
+  /**
+   * Tracks elements that are temporarily detached (e.g. via .detach())
+   * so they are NOT cleaned up by the MutationObserver.
+   */
+  preservedNodes = /* @__PURE__ */ new WeakSet();
+  keep(e) {
+    this.preservedNodes.add(e);
+  }
+  isKept(e) {
+    return this.preservedNodes.has(e);
+  }
+  /**
+   * Registers an Effect to be disposed later.
+   */
+  trackEffect(e, s) {
+    const n = this.effects.get(e) || [];
+    n.push(s), this.effects.set(e, n), this.boundElements.add(e);
+  }
+  /**
+   * Registers a custom cleanup function (e.g., event listener removal).
+   */
+  trackCleanup(e, s) {
+    const n = this.cleanups.get(e) || [];
+    n.push(s), this.cleanups.set(e, n), this.boundElements.add(e);
+  }
+  /**
+   * Checks if an element has bindings (Fast check).
+   */
+  hasBind(e) {
+    return this.boundElements.has(e);
+  }
+  /**
+   * Cleans up a single element.
+   * - Disposes all Effects (severs connection with Atom).
+   * - Executes all custom cleanups.
+   */
+  cleanup(e) {
+    if (!this.boundElements.has(e)) return;
+    h.cleanup(ue(e));
+    const s = this.effects.get(e);
+    s && (this.effects.delete(e), s.forEach((i) => {
+      try {
+        i.dispose();
+      } catch (r) {
+        h.warn("Effect dispose error:", r);
+      }
+    }));
+    const n = this.cleanups.get(e);
+    n && (this.cleanups.delete(e), n.forEach((i) => {
+      try {
+        i();
+      } catch (r) {
+        h.warn("Cleanup error:", r);
+      }
+    })), this.boundElements.delete(e);
+  }
+  /**
+   * Cleans up the element and all its descendants (Recursive).
+   * - Essential for deep removal (empty(), remove(), etc.).
+   */
+  cleanupTree(e) {
+    e.querySelectorAll("*").forEach((n) => {
+      this.boundElements.has(n) && this.cleanup(n);
+    }), this.cleanup(e);
+  }
+}
+const l = new ct();
+let J = null;
+function ut(t = document.body) {
+  J || (J = new MutationObserver((e) => {
+    for (const s of e)
+      s.removedNodes.forEach((n) => {
+        l.isKept(n) || n.isConnected || n.nodeType === 1 && l.cleanupTree(n);
+      });
+  }), J.observe(t, { childList: !0, subtree: !0 }));
+}
+function Dt() {
+  J?.disconnect(), J = null;
+}
+u.fn.atomText = function(t, e) {
+  return this.each(function() {
+    const s = u(this);
+    if (b(t)) {
+      const n = I(() => {
+        const i = E(t), r = e ? e(i) : String(i ?? "");
+        s.text(r), h.domUpdated(s, "text", r);
+      });
+      l.trackEffect(this, n);
+    } else {
+      const n = e ? e(t) : String(t ?? "");
+      s.text(n);
+    }
+  });
+};
+u.fn.atomHtml = function(t) {
+  return this.each(function() {
+    const e = u(this);
+    if (b(t)) {
+      const s = I(() => {
+        const n = String(E(t) ?? "");
+        e.html(n), h.domUpdated(e, "html", n);
+      });
+      l.trackEffect(this, s);
+    } else
+      e.html(String(t ?? ""));
+  });
+};
+u.fn.atomClass = function(t, e) {
+  return this.each(function() {
+    const s = u(this);
+    if (b(e)) {
+      const n = I(() => {
+        const i = !!E(e);
+        s.toggleClass(t, i), h.domUpdated(s, `class.${t}`, i);
+      });
+      l.trackEffect(this, n);
+    } else
+      s.toggleClass(t, !!e);
+  });
+};
+u.fn.atomCss = function(t, e, s) {
+  return this.each(function() {
+    const n = u(this);
+    if (b(e)) {
+      const i = I(() => {
+        const r = E(e), o = s ? `${r}${s}` : r;
+        n.css(t, o), h.domUpdated(n, `css.${t}`, o);
+      });
+      l.trackEffect(this, i);
+    } else
+      n.css(t, s ? `${e}${s}` : e);
+  });
+};
+u.fn.atomAttr = function(t, e) {
+  return this.each(function() {
+    const s = u(this), n = (i) => {
+      i == null || i === !1 ? s.removeAttr(t) : i === !0 ? s.attr(t, t) : s.attr(t, String(i)), h.domUpdated(s, `attr.${t}`, i);
+    };
+    if (b(e)) {
+      const i = I(() => n(E(e)));
+      l.trackEffect(this, i);
+    } else
+      n(e);
+  });
+};
+u.fn.atomProp = function(t, e) {
+  return this.each(function() {
+    const s = u(this);
+    if (b(e)) {
+      const n = I(() => {
+        const i = E(e);
+        s.prop(t, i), h.domUpdated(s, `prop.${t}`, i);
+      });
+      l.trackEffect(this, n);
+    } else
+      s.prop(t, e);
+  });
+};
+u.fn.atomShow = function(t) {
+  return this.each(function() {
+    const e = u(this);
+    if (b(t)) {
+      const s = I(() => {
+        const n = !!E(t);
+        e.toggle(n), h.domUpdated(e, "show", n);
+      });
+      l.trackEffect(this, s);
+    } else
+      e.toggle(!!t);
+  });
+};
+u.fn.atomHide = function(t) {
+  return this.each(function() {
+    const e = u(this);
+    if (b(t)) {
+      const s = I(() => {
+        const n = !E(t);
+        e.toggle(n), h.domUpdated(e, "hide", !n);
+      });
+      l.trackEffect(this, s);
+    } else
+      e.toggle(!t);
+  });
+};
+u.fn.atomVal = function(t, e = {}) {
+  return this.each(function() {
+    const { effect: s, cleanup: n } = $e(u(this), t, e), i = I(s);
+    l.trackEffect(this, i), l.trackCleanup(this, n);
+  });
+};
+u.fn.atomChecked = function(t) {
+  return this.each(function() {
+    const e = u(this);
+    let s = !1;
+    const n = () => {
+      s || z(() => {
+        t.value = e.prop("checked");
+      });
+    };
+    e.on("change", n), l.trackCleanup(this, () => e.off("change", n));
+    const i = I(() => {
+      s = !0, e.prop("checked", t.value), h.domUpdated(e, "checked", t.value), s = !1;
+    });
+    l.trackEffect(this, i);
+  });
+};
+u.fn.atomOn = function(t, e) {
+  return this.each(function() {
+    const s = u(this), n = function(i) {
+      z(() => e.call(this, i));
+    };
+    s.on(t, n), l.trackCleanup(this, () => s.off(t, n));
+  });
+};
+u.fn.atomUnbind = function() {
+  return this.each(function() {
+    l.cleanupTree(this);
+  });
+};
+function ht(t, e) {
+  b(e) ? t.effects.push(() => {
+    const s = String(E(e) ?? "");
+    t.$el.text(s), h.domUpdated(t.$el, "text", s);
+  }) : t.$el.text(String(e ?? ""));
+}
+function at(t, e) {
+  b(e) ? t.effects.push(() => {
+    const s = String(E(e) ?? "");
+    t.$el.html(s), h.domUpdated(t.$el, "html", s);
+  }) : t.$el.html(String(e ?? ""));
+}
+function lt(t, e) {
+  for (const [s, n] of Object.entries(e))
+    b(n) ? t.effects.push(() => {
+      const i = !!E(n);
+      t.$el.toggleClass(s, i), h.domUpdated(t.$el, `class.${s}`, i);
+    }) : t.$el.toggleClass(s, !!n);
+}
+function ft(t, e) {
+  for (const [s, n] of Object.entries(e))
+    if (Array.isArray(n)) {
+      const [i, r] = n;
+      b(i) ? t.effects.push(() => {
+        const o = `${E(i)}${r}`;
+        t.$el.css(s, o), h.domUpdated(t.$el, `css.${s}`, o);
+      }) : t.$el.css(s, `${i}${r}`);
+    } else b(n) ? t.effects.push(() => {
+      const i = E(n);
+      t.$el.css(s, i), h.domUpdated(t.$el, `css.${s}`, i);
+    }) : t.$el.css(s, n);
+}
+function dt(t, e) {
+  for (const [s, n] of Object.entries(e)) {
+    const i = (r) => {
+      r == null || r === !1 ? t.$el.removeAttr(s) : r === !0 ? t.$el.attr(s, s) : t.$el.attr(s, String(r)), h.domUpdated(t.$el, `attr.${s}`, r);
+    };
+    b(n) ? t.effects.push(() => i(E(n))) : i(n);
+  }
+}
+function _t(t, e) {
+  for (const [s, n] of Object.entries(e))
+    b(n) ? t.effects.push(() => {
+      const i = E(n);
+      t.$el.prop(s, i), h.domUpdated(t.$el, `prop.${s}`, i);
+    }) : t.$el.prop(s, n);
+}
+function pt(t, e) {
+  b(e) ? t.effects.push(() => {
+    const s = !!E(e);
+    t.$el.toggle(s), h.domUpdated(t.$el, "show", s);
+  }) : t.$el.toggle(!!e);
+}
+function bt(t, e) {
+  b(e) ? t.effects.push(() => {
+    const s = !E(e);
+    t.$el.toggle(s), h.domUpdated(t.$el, "hide", !s);
+  }) : t.$el.toggle(!e);
+}
+function Et(t, e) {
+  const s = Array.isArray(e) ? e[0] : e, n = Array.isArray(e) ? e[1] : {}, { effect: i, cleanup: r } = $e(t.$el, s, n);
+  t.effects.push(i), t.trackCleanup(r);
+}
+function gt(t, e) {
+  const s = Me(), n = () => {
+    s.phase === "idle" && z(() => {
+      e.value = t.$el.prop("checked");
+    });
+  };
+  t.$el.on("change", n), t.trackCleanup(() => t.$el.off("change", n)), t.effects.push(() => {
+    s.phase = "syncing-to-dom", t.$el.prop("checked", e.value), h.domUpdated(t.$el, "checked", e.value), s.phase = "idle";
+  });
+}
+function mt(t, e) {
+  for (const [s, n] of Object.entries(e)) {
+    const i = function(r) {
+      z(() => n.call(this, r));
+    };
+    t.$el.on(s, i), t.trackCleanup(() => t.$el.off(s, i));
+  }
+}
+u.fn.atomBind = function(t) {
+  return this.each(function() {
+    const e = u(this), s = [], n = {
+      $el: e,
+      el: this,
+      effects: s,
+      trackCleanup: (i) => l.trackCleanup(this, i)
+    };
+    t.text !== void 0 && ht(n, t.text), t.html !== void 0 && at(n, t.html), t.class && lt(n, t.class), t.css && ft(n, t.css), t.attr && dt(n, t.attr), t.prop && _t(n, t.prop), t.show !== void 0 && pt(n, t.show), t.hide !== void 0 && bt(n, t.hide), t.val !== void 0 && Et(n, t.val), t.checked !== void 0 && gt(n, t.checked), t.on && mt(n, t.on), s.forEach((i) => {
+      const r = I(i);
+      l.trackEffect(this, r);
+    });
+  });
+};
+function St(t) {
+  if (t.length === 0) return [];
+  const e = t.slice(), s = [0];
+  let n, i, r, o;
+  const c = t.length;
+  for (n = 0; n < c; n++) {
+    const C = t[n];
+    if (C !== -1) {
+      const S = s[s.length - 1];
+      if (t[S] < C) {
+        e[n] = S, s.push(n);
+        continue;
+      }
+      for (i = 0, r = s.length - 1; i < r; )
+        o = (i + r) / 2 | 0, t[s[o]] < C ? i = o + 1 : r = o;
+      C < t[s[i]] && (i > 0 && (e[n] = s[i - 1]), s[i] = n);
+    }
+  }
+  let f = s.length, _ = s[f - 1];
+  for (; f-- > 0; )
+    s[f] = _, _ = e[_];
+  return s;
+}
+u.fn.atomList = function(t, e) {
+  return this.each(function() {
+    const s = u(this), n = ue(this), { key: i, render: r, bind: o, onAdd: c, onRemove: f, empty: _ } = e, C = typeof i == "function" ? i : (p) => p[i], S = /* @__PURE__ */ new Map();
+    let F = [], v = null;
+    const K = /* @__PURE__ */ new Set(), _e = I(() => {
+      const p = t.value, L = [], pe = /* @__PURE__ */ new Set();
+      for (let a = 0; a < p.length; a++) {
+        const g = p[a], T = C(g, a);
+        L.push(T), pe.add(T);
+      }
+      if (h.log("list", `${n} updating with ${p.length} items`), p.length === 0 && _) {
+        v || (v = u(_), s.append(v));
+        for (const [, a] of S) {
+          a.$el.remove();
+          const g = a.$el[0];
+          g && l.cleanup(g);
+        }
+        S.clear(), F = [];
+        return;
+      } else v && (v.remove(), v = null);
+      for (const [a, g] of S)
+        if (!pe.has(a)) {
+          if (K.has(a)) continue;
+          const T = () => {
+            g.$el.remove();
+            const W = g.$el[0];
+            W && l.cleanup(W), K.delete(a), h.log("list", `${n} removed item:`, a);
+          };
+          S.delete(a), K.add(a), f ? Promise.resolve(f(g.$el)).then(T) : T();
+        }
+      const be = /* @__PURE__ */ new Map();
+      F.forEach((a, g) => be.set(a, g));
+      const Pe = L.map((a) => be.get(a) ?? -1), Ve = St(Pe), je = new Set(Ve);
+      let U = null;
+      for (let a = p.length - 1; a >= 0; a--) {
+        const g = L[a], T = p[a], W = je.has(a);
+        if (S.has(g)) {
+          const N = S.get(g);
+          if (!N) continue;
+          N.item = T;
+          const x = N.$el[0];
+          if (!x) continue;
+          if (e.update && e.update(N.$el, T, a), !W)
+            U ? N.$el.insertBefore(U) : N.$el.appendTo(s);
+          else {
+            const Q = x.nextSibling;
+            U && Q !== U ? N.$el.insertBefore(U) : !U && Q && N.$el.appendTo(s);
+          }
+          U = x;
+        } else {
+          const N = r(T, a), x = N instanceof Element ? u(N) : u(N);
+          S.set(g, { $el: x, item: T }), U ? x.insertBefore(U) : x.appendTo(s), o && o(x, T, a), c && c(x), h.log("list", `${n} added item:`, g);
+          const Q = x[0];
+          Q && (U = Q);
+        }
+      }
+      F = L;
+    });
+    l.trackEffect(this, _e), l.trackCleanup(this, () => {
+      S.clear(), F = [], v?.remove();
+    });
+  });
+};
+const se = /* @__PURE__ */ new WeakMap();
+u.fn.atomMount = function(t, e = {}) {
+  return this.each(function() {
+    const s = u(this), n = ue(this), i = se.get(this);
+    i && (h.log("mount", `${n} unmounting existing component`), i()), h.log("mount", `${n} mounting component`);
+    let r;
+    try {
+      r = t(s, e);
+    } catch (f) {
+      console.error("[atom-effect-jquery] Mount error:", f);
+      return;
+    }
+    let o = !1;
+    const c = () => {
+      if (!o) {
+        if (o = !0, h.log("mount", `${n} full cleanup`), typeof r == "function")
+          try {
+            r();
+          } catch {
+          }
+        l.cleanupTree(this), se.delete(this);
+      }
+    };
+    se.set(this, c), l.trackCleanup(this, c);
+  });
+};
+u.fn.atomUnmount = function() {
+  return this.each(function() {
+    se.get(this)?.();
+  });
+};
+const H = /* @__PURE__ */ new WeakMap();
+let Ie = !1;
+function Le() {
+  if (Ie) return;
+  Ie = !0;
+  const t = u.fn.on, e = u.fn.off, s = u.fn.remove, n = u.fn.empty, i = u.fn.detach;
+  u.fn.remove = function(r) {
+    return (r ? this.filter(r) : this).each(function() {
+      l.cleanupTree(this);
+    }), s.call(this, r);
+  }, u.fn.empty = function() {
+    return this.each(function() {
+      this.querySelectorAll("*").forEach((o) => l.cleanup(o));
+    }), n.call(this);
+  }, u.fn.detach = function(r) {
+    return (r ? this.filter(r) : this).each(function() {
+      l.keep(this);
+    }), i.call(this, r);
+  }, u.fn.on = function(...r) {
+    let o = -1;
+    for (let c = r.length - 1; c >= 0; c--)
+      if (typeof r[c] == "function") {
+        o = c;
+        break;
+      }
+    if (o !== -1) {
+      const c = r[o];
+      let f;
+      H.has(c) ? f = H.get(c) : (f = function(..._) {
+        let C;
+        return z(() => {
+          C = c.apply(this, _);
+        }), C;
+      }, H.set(c, f)), r[o] = f;
+    }
+    return t.apply(this, r);
+  }, u.fn.off = function(...r) {
+    let o = -1;
+    for (let c = r.length - 1; c >= 0; c--)
+      if (typeof r[c] == "function") {
+        o = c;
+        break;
+      }
+    if (o !== -1) {
+      const c = r[o];
+      H.has(c) && (r[o] = H.get(c));
+    }
+    return e.apply(this, r);
+  };
+}
+const It = Le;
+Le();
+u(() => {
+  ut(document.body);
+});
+export {
+  Ze as atom,
+  z as batch,
+  tt as computed,
+  Nt as default,
+  Dt as disableAutoCleanup,
+  I as effect,
+  ut as enableAutoCleanup,
+  It as enablejQueryBatching,
+  Le as enablejQueryOverrides,
+  l as registry,
+  Re as untracked
+};
+//# sourceMappingURL=index.mjs.map