@darajs/core 1.26.3 → 1.26.5

package/dist/umd/dara.core.umd.cjs

@@ -39442,6 +39442,47 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
       return Object.assign(Object.assign({}, sort), { id: ((_a = columns.find((col) => col.accessor === sort.id)) === null || _a === void 0 ? void 0 : _a.sortKey) || sort.id });
     });
   };
+  const RE_SPLIT_ALPHANUMERIC = /([0-9]+)/g;
+  const caseInsensitiveAlphanumeric = (rowA, rowB, columnId) => {
+    const getVal = (row) => {
+      const val = row.values[columnId];
+      if (val == null) {
+        return "";
+      }
+      if (typeof val === "number") {
+        return Number.isNaN(val) || val === Infinity || val === -Infinity ? "" : String(val);
+      }
+      return typeof val === "string" ? val : String(val);
+    };
+    const a2 = getVal(rowA).split(RE_SPLIT_ALPHANUMERIC).filter(Boolean);
+    const b2 = getVal(rowB).split(RE_SPLIT_ALPHANUMERIC).filter(Boolean);
+    const len = Math.min(a2.length, b2.length);
+    for (let i2 = 0; i2 < len; i2++) {
+      const aa = a2[i2];
+      const bb = b2[i2];
+      const an = parseInt(aa);
+      const bn = parseInt(bb);
+      const aIsNaN = Number.isNaN(an);
+      const bIsNaN = Number.isNaN(bn);
+      if (aIsNaN && bIsNaN) {
+        const cmp = aa.toLowerCase().localeCompare(bb.toLowerCase());
+        if (cmp !== 0) {
+          return cmp;
+        }
+        continue;
+      }
+      if (aIsNaN) {
+        return 1;
+      }
+      if (bIsNaN) {
+        return -1;
+      }
+      if (an !== bn) {
+        return an > bn ? 1 : -1;
+      }
+    }
+    return a2.length - b2.length;
+  };
   const orderStickyCols = (columns) => {
     const leftStickyCols = [];
     const nonStickyCols = [];
@@ -39579,6 +39620,9 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
       columns: mappedColumns,
       data: data2 || infiniteData,
       filterTypes,
+      sortTypes: {
+        alphanumeric: caseInsensitiveAlphanumeric
+      },
       initialState: {
         sortBy: currentSortBy.map((sort) => Object.assign(Object.assign({}, sort), { id: mappedColumns.find((col) => [col.sortKey, col.accessor].includes(sort.id)).accessor }))
       },
@@ -71936,6 +71980,958 @@ ${String(error)}`;
   function cleanArgs(values, forceKeyOverride) {
     return values.map((val) => cleanValue(val, forceKeyOverride));
   }
+  var eventemitter3 = { exports: {} };
+  var hasRequiredEventemitter3;
+  function requireEventemitter3() {
+    if (hasRequiredEventemitter3) return eventemitter3.exports;
+    hasRequiredEventemitter3 = 1;
+    (function(module2) {
+      var has = Object.prototype.hasOwnProperty, prefix = "~";
+      function Events() {
+      }
+      if (Object.create) {
+        Events.prototype = /* @__PURE__ */ Object.create(null);
+        if (!new Events().__proto__) prefix = false;
+      }
+      function EE(fn, context, once) {
+        this.fn = fn;
+        this.context = context;
+        this.once = once || false;
+      }
+      function addListener(emitter, event, fn, context, once) {
+        if (typeof fn !== "function") {
+          throw new TypeError("The listener must be a function");
+        }
+        var listener2 = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+        if (!emitter._events[evt]) emitter._events[evt] = listener2, emitter._eventsCount++;
+        else if (!emitter._events[evt].fn) emitter._events[evt].push(listener2);
+        else emitter._events[evt] = [emitter._events[evt], listener2];
+        return emitter;
+      }
+      function clearEvent(emitter, evt) {
+        if (--emitter._eventsCount === 0) emitter._events = new Events();
+        else delete emitter._events[evt];
+      }
+      function EventEmitter2() {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      EventEmitter2.prototype.eventNames = function eventNames() {
+        var names = [], events, name;
+        if (this._eventsCount === 0) return names;
+        for (name in events = this._events) {
+          if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+        }
+        if (Object.getOwnPropertySymbols) {
+          return names.concat(Object.getOwnPropertySymbols(events));
+        }
+        return names;
+      };
+      EventEmitter2.prototype.listeners = function listeners(event) {
+        var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+        if (!handlers) return [];
+        if (handlers.fn) return [handlers.fn];
+        for (var i2 = 0, l2 = handlers.length, ee = new Array(l2); i2 < l2; i2++) {
+          ee[i2] = handlers[i2].fn;
+        }
+        return ee;
+      };
+      EventEmitter2.prototype.listenerCount = function listenerCount(event) {
+        var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+        if (!listeners) return 0;
+        if (listeners.fn) return 1;
+        return listeners.length;
+      };
+      EventEmitter2.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+        var evt = prefix ? prefix + event : event;
+        if (!this._events[evt]) return false;
+        var listeners = this._events[evt], len = arguments.length, args, i2;
+        if (listeners.fn) {
+          if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+          switch (len) {
+            case 1:
+              return listeners.fn.call(listeners.context), true;
+            case 2:
+              return listeners.fn.call(listeners.context, a1), true;
+            case 3:
+              return listeners.fn.call(listeners.context, a1, a2), true;
+            case 4:
+              return listeners.fn.call(listeners.context, a1, a2, a3), true;
+            case 5:
+              return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+            case 6:
+              return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+          }
+          for (i2 = 1, args = new Array(len - 1); i2 < len; i2++) {
+            args[i2 - 1] = arguments[i2];
+          }
+          listeners.fn.apply(listeners.context, args);
+        } else {
+          var length = listeners.length, j;
+          for (i2 = 0; i2 < length; i2++) {
+            if (listeners[i2].once) this.removeListener(event, listeners[i2].fn, void 0, true);
+            switch (len) {
+              case 1:
+                listeners[i2].fn.call(listeners[i2].context);
+                break;
+              case 2:
+                listeners[i2].fn.call(listeners[i2].context, a1);
+                break;
+              case 3:
+                listeners[i2].fn.call(listeners[i2].context, a1, a2);
+                break;
+              case 4:
+                listeners[i2].fn.call(listeners[i2].context, a1, a2, a3);
+                break;
+              default:
+                if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+                  args[j - 1] = arguments[j];
+                }
+                listeners[i2].fn.apply(listeners[i2].context, args);
+            }
+          }
+        }
+        return true;
+      };
+      EventEmitter2.prototype.on = function on(event, fn, context) {
+        return addListener(this, event, fn, context, false);
+      };
+      EventEmitter2.prototype.once = function once(event, fn, context) {
+        return addListener(this, event, fn, context, true);
+      };
+      EventEmitter2.prototype.removeListener = function removeListener(event, fn, context, once) {
+        var evt = prefix ? prefix + event : event;
+        if (!this._events[evt]) return this;
+        if (!fn) {
+          clearEvent(this, evt);
+          return this;
+        }
+        var listeners = this._events[evt];
+        if (listeners.fn) {
+          if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+            clearEvent(this, evt);
+          }
+        } else {
+          for (var i2 = 0, events = [], length = listeners.length; i2 < length; i2++) {
+            if (listeners[i2].fn !== fn || once && !listeners[i2].once || context && listeners[i2].context !== context) {
+              events.push(listeners[i2]);
+            }
+          }
+          if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+          else clearEvent(this, evt);
+        }
+        return this;
+      };
+      EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) {
+        var evt;
+        if (event) {
+          evt = prefix ? prefix + event : event;
+          if (this._events[evt]) clearEvent(this, evt);
+        } else {
+          this._events = new Events();
+          this._eventsCount = 0;
+        }
+        return this;
+      };
+      EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+      EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
+      EventEmitter2.prefixed = prefix;
+      EventEmitter2.EventEmitter = EventEmitter2;
+      {
+        module2.exports = EventEmitter2;
+      }
+    })(eventemitter3);
+    return eventemitter3.exports;
+  }
+  var eventemitter3Exports = requireEventemitter3();
+  const EventEmitter = /* @__PURE__ */ getDefaultExportFromCjs(eventemitter3Exports);
+  class TimeoutError extends Error {
+    name = "TimeoutError";
+    constructor(message, options) {
+      super(message, options);
+      Error.captureStackTrace?.(this, TimeoutError);
+    }
+  }
+  const getAbortedReason = (signal) => signal.reason ?? new DOMException("This operation was aborted.", "AbortError");
+  function pTimeout(promise, options) {
+    const {
+      milliseconds,
+      fallback,
+      message,
+      customTimers = { setTimeout, clearTimeout },
+      signal
+    } = options;
+    let timer2;
+    let abortHandler;
+    const wrappedPromise = new Promise((resolve, reject) => {
+      if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
+        throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
+      }
+      if (signal?.aborted) {
+        reject(getAbortedReason(signal));
+        return;
+      }
+      if (signal) {
+        abortHandler = () => {
+          reject(getAbortedReason(signal));
+        };
+        signal.addEventListener("abort", abortHandler, { once: true });
+      }
+      promise.then(resolve, reject);
+      if (milliseconds === Number.POSITIVE_INFINITY) {
+        return;
+      }
+      const timeoutError = new TimeoutError();
+      timer2 = customTimers.setTimeout.call(void 0, () => {
+        if (fallback) {
+          try {
+            resolve(fallback());
+          } catch (error) {
+            reject(error);
+          }
+          return;
+        }
+        if (typeof promise.cancel === "function") {
+          promise.cancel();
+        }
+        if (message === false) {
+          resolve();
+        } else if (message instanceof Error) {
+          reject(message);
+        } else {
+          timeoutError.message = message ?? `Promise timed out after ${milliseconds} milliseconds`;
+          reject(timeoutError);
+        }
+      }, milliseconds);
+    });
+    const cancelablePromise = wrappedPromise.finally(() => {
+      cancelablePromise.clear();
+      if (abortHandler && signal) {
+        signal.removeEventListener("abort", abortHandler);
+      }
+    });
+    cancelablePromise.clear = () => {
+      customTimers.clearTimeout.call(void 0, timer2);
+      timer2 = void 0;
+    };
+    return cancelablePromise;
+  }
+  function lowerBound(array2, value, comparator) {
+    let first = 0;
+    let count2 = array2.length;
+    while (count2 > 0) {
+      const step = Math.trunc(count2 / 2);
+      let it2 = first + step;
+      if (comparator(array2[it2], value) <= 0) {
+        first = ++it2;
+        count2 -= step + 1;
+      } else {
+        count2 = step;
+      }
+    }
+    return first;
+  }
+  class PriorityQueue {
+    #queue = [];
+    enqueue(run2, options) {
+      const { priority = 0, id } = options ?? {};
+      const element = {
+        priority,
+        id,
+        run: run2
+      };
+      if (this.size === 0 || this.#queue[this.size - 1].priority >= priority) {
+        this.#queue.push(element);
+        return;
+      }
+      const index2 = lowerBound(this.#queue, element, (a2, b2) => b2.priority - a2.priority);
+      this.#queue.splice(index2, 0, element);
+    }
+    setPriority(id, priority) {
+      const index2 = this.#queue.findIndex((element) => element.id === id);
+      if (index2 === -1) {
+        throw new ReferenceError(`No promise function with the id "${id}" exists in the queue.`);
+      }
+      const [item] = this.#queue.splice(index2, 1);
+      this.enqueue(item.run, { priority, id });
+    }
+    dequeue() {
+      const item = this.#queue.shift();
+      return item?.run;
+    }
+    filter(options) {
+      return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
+    }
+    get size() {
+      return this.#queue.length;
+    }
+  }
+  class PQueue extends EventEmitter {
+    #carryoverIntervalCount;
+    #isIntervalIgnored;
+    #intervalCount = 0;
+    #intervalCap;
+    #rateLimitedInInterval = false;
+    #rateLimitFlushScheduled = false;
+    #interval;
+    #intervalEnd = 0;
+    #lastExecutionTime = 0;
+    #intervalId;
+    #timeoutId;
+    #strict;
+    // Circular buffer implementation for better performance
+    #strictTicks = [];
+    #strictTicksStartIndex = 0;
+    #queue;
+    #queueClass;
+    #pending = 0;
+    // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
+    #concurrency;
+    #isPaused;
+    // Use to assign a unique identifier to a promise function, if not explicitly specified
+    #idAssigner = 1n;
+    // Track currently running tasks for debugging
+    #runningTasks = /* @__PURE__ */ new Map();
+    /**
+    	    Get or set the default timeout for all tasks. Can be changed at runtime.
+    
+    	    Operations will throw a `TimeoutError` if they don't complete within the specified time.
+    
+    	    The timeout begins when the operation is dequeued and starts execution, not while it's waiting in the queue.
+    
+    	    @example
+    	    ```
+    	    const queue = new PQueue({timeout: 5000});
+    
+    	    // Change timeout for all future tasks
+    	    queue.timeout = 10000;
+    	    ```
+    	    */
+    timeout;
+    constructor(options) {
+      super();
+      options = {
+        carryoverIntervalCount: false,
+        intervalCap: Number.POSITIVE_INFINITY,
+        interval: 0,
+        concurrency: Number.POSITIVE_INFINITY,
+        autoStart: true,
+        queueClass: PriorityQueue,
+        strict: false,
+        ...options
+      };
+      if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
+        throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${options.intervalCap?.toString() ?? ""}\` (${typeof options.intervalCap})`);
+      }
+      if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
+        throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${options.interval?.toString() ?? ""}\` (${typeof options.interval})`);
+      }
+      if (options.strict && options.interval === 0) {
+        throw new TypeError("The `strict` option requires a non-zero `interval`");
+      }
+      if (options.strict && options.intervalCap === Number.POSITIVE_INFINITY) {
+        throw new TypeError("The `strict` option requires a finite `intervalCap`");
+      }
+      this.#carryoverIntervalCount = options.carryoverIntervalCount ?? options.carryoverConcurrencyCount ?? false;
+      this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
+      this.#intervalCap = options.intervalCap;
+      this.#interval = options.interval;
+      this.#strict = options.strict;
+      this.#queue = new options.queueClass();
+      this.#queueClass = options.queueClass;
+      this.concurrency = options.concurrency;
+      if (options.timeout !== void 0 && !(Number.isFinite(options.timeout) && options.timeout > 0)) {
+        throw new TypeError(`Expected \`timeout\` to be a positive finite number, got \`${options.timeout}\` (${typeof options.timeout})`);
+      }
+      this.timeout = options.timeout;
+      this.#isPaused = options.autoStart === false;
+      this.#setupRateLimitTracking();
+    }
+    #cleanupStrictTicks(now2) {
+      while (this.#strictTicksStartIndex < this.#strictTicks.length) {
+        const oldestTick = this.#strictTicks[this.#strictTicksStartIndex];
+        if (oldestTick !== void 0 && now2 - oldestTick >= this.#interval) {
+          this.#strictTicksStartIndex++;
+        } else {
+          break;
+        }
+      }
+      const shouldCompact = this.#strictTicksStartIndex > 100 && this.#strictTicksStartIndex > this.#strictTicks.length / 2 || this.#strictTicksStartIndex === this.#strictTicks.length;
+      if (shouldCompact) {
+        this.#strictTicks = this.#strictTicks.slice(this.#strictTicksStartIndex);
+        this.#strictTicksStartIndex = 0;
+      }
+    }
+    // Helper methods for interval consumption
+    #consumeIntervalSlot(now2) {
+      if (this.#strict) {
+        this.#strictTicks.push(now2);
+      } else {
+        this.#intervalCount++;
+      }
+    }
+    #rollbackIntervalSlot() {
+      if (this.#strict) {
+        if (this.#strictTicks.length > this.#strictTicksStartIndex) {
+          this.#strictTicks.pop();
+        }
+      } else if (this.#intervalCount > 0) {
+        this.#intervalCount--;
+      }
+    }
+    #getActiveTicksCount() {
+      return this.#strictTicks.length - this.#strictTicksStartIndex;
+    }
+    get #doesIntervalAllowAnother() {
+      if (this.#isIntervalIgnored) {
+        return true;
+      }
+      if (this.#strict) {
+        return this.#getActiveTicksCount() < this.#intervalCap;
+      }
+      return this.#intervalCount < this.#intervalCap;
+    }
+    get #doesConcurrentAllowAnother() {
+      return this.#pending < this.#concurrency;
+    }
+    #next() {
+      this.#pending--;
+      if (this.#pending === 0) {
+        this.emit("pendingZero");
+      }
+      this.#tryToStartAnother();
+      this.emit("next");
+    }
+    #onResumeInterval() {
+      this.#timeoutId = void 0;
+      this.#onInterval();
+      this.#initializeIntervalIfNeeded();
+    }
+    #isIntervalPausedAt(now2) {
+      if (this.#strict) {
+        this.#cleanupStrictTicks(now2);
+        const activeTicksCount = this.#getActiveTicksCount();
+        if (activeTicksCount >= this.#intervalCap) {
+          const oldestTick = this.#strictTicks[this.#strictTicksStartIndex];
+          const delay2 = this.#interval - (now2 - oldestTick);
+          this.#createIntervalTimeout(delay2);
+          return true;
+        }
+        return false;
+      }
+      if (this.#intervalId === void 0) {
+        const delay2 = this.#intervalEnd - now2;
+        if (delay2 < 0) {
+          if (this.#lastExecutionTime > 0) {
+            const timeSinceLastExecution = now2 - this.#lastExecutionTime;
+            if (timeSinceLastExecution < this.#interval) {
+              this.#createIntervalTimeout(this.#interval - timeSinceLastExecution);
+              return true;
+            }
+          }
+          this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
+        } else {
+          this.#createIntervalTimeout(delay2);
+          return true;
+        }
+      }
+      return false;
+    }
+    #createIntervalTimeout(delay2) {
+      if (this.#timeoutId !== void 0) {
+        return;
+      }
+      this.#timeoutId = setTimeout(() => {
+        this.#onResumeInterval();
+      }, delay2);
+    }
+    #clearIntervalTimer() {
+      if (this.#intervalId) {
+        clearInterval(this.#intervalId);
+        this.#intervalId = void 0;
+      }
+    }
+    #clearTimeoutTimer() {
+      if (this.#timeoutId) {
+        clearTimeout(this.#timeoutId);
+        this.#timeoutId = void 0;
+      }
+    }
+    #tryToStartAnother() {
+      if (this.#queue.size === 0) {
+        this.#clearIntervalTimer();
+        this.emit("empty");
+        if (this.#pending === 0) {
+          this.#clearTimeoutTimer();
+          if (this.#strict && this.#strictTicksStartIndex > 0) {
+            const now2 = Date.now();
+            this.#cleanupStrictTicks(now2);
+          }
+          this.emit("idle");
+        }
+        return false;
+      }
+      let taskStarted = false;
+      if (!this.#isPaused) {
+        const now2 = Date.now();
+        const canInitializeInterval = !this.#isIntervalPausedAt(now2);
+        if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {
+          const job = this.#queue.dequeue();
+          if (!this.#isIntervalIgnored) {
+            this.#consumeIntervalSlot(now2);
+            this.#scheduleRateLimitUpdate();
+          }
+          this.emit("active");
+          job();
+          if (canInitializeInterval) {
+            this.#initializeIntervalIfNeeded();
+          }
+          taskStarted = true;
+        }
+      }
+      return taskStarted;
+    }
+    #initializeIntervalIfNeeded() {
+      if (this.#isIntervalIgnored || this.#intervalId !== void 0) {
+        return;
+      }
+      if (this.#strict) {
+        return;
+      }
+      this.#intervalId = setInterval(() => {
+        this.#onInterval();
+      }, this.#interval);
+      this.#intervalEnd = Date.now() + this.#interval;
+    }
+    #onInterval() {
+      if (!this.#strict) {
+        if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
+          this.#clearIntervalTimer();
+        }
+        this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
+      }
+      this.#processQueue();
+      this.#scheduleRateLimitUpdate();
+    }
+    /**
+    Executes all queued functions until it reaches the limit.
+    */
+    #processQueue() {
+      while (this.#tryToStartAnother()) {
+      }
+    }
+    get concurrency() {
+      return this.#concurrency;
+    }
+    set concurrency(newConcurrency) {
+      if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
+        throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
+      }
+      this.#concurrency = newConcurrency;
+      this.#processQueue();
+    }
+    /**
+    	    Updates the priority of a promise function by its id, affecting its execution order. Requires a defined concurrency limit to take effect.
+    
+    	    For example, this can be used to prioritize a promise function to run earlier.
+    
+    	    ```js
+    	    import PQueue from 'p-queue';
+    
+    	    const queue = new PQueue({concurrency: 1});
+    
+    	    queue.add(async () => '🦄', {priority: 1});
+    	    queue.add(async () => '🦀', {priority: 0, id: '🦀'});
+    	    queue.add(async () => '🦄', {priority: 1});
+    	    queue.add(async () => '🦄', {priority: 1});
+    
+    	    queue.setPriority('🦀', 2);
+    	    ```
+    
+    	    In this case, the promise function with `id: '🦀'` runs second.
+    
+    	    You can also deprioritize a promise function to delay its execution:
+    
+    	    ```js
+    	    import PQueue from 'p-queue';
+    
+    	    const queue = new PQueue({concurrency: 1});
+    
+    	    queue.add(async () => '🦄', {priority: 1});
+    	    queue.add(async () => '🦀', {priority: 1, id: '🦀'});
+    	    queue.add(async () => '🦄');
+    	    queue.add(async () => '🦄', {priority: 0});
+    
+    	    queue.setPriority('🦀', -1);
+    	    ```
+    	    Here, the promise function with `id: '🦀'` executes last.
+    	    */
+    setPriority(id, priority) {
+      if (typeof priority !== "number" || !Number.isFinite(priority)) {
+        throw new TypeError(`Expected \`priority\` to be a finite number, got \`${priority}\` (${typeof priority})`);
+      }
+      this.#queue.setPriority(id, priority);
+    }
+    async add(function_, options = {}) {
+      options = {
+        timeout: this.timeout,
+        ...options,
+        // Assign unique ID if not provided
+        id: options.id ?? (this.#idAssigner++).toString()
+      };
+      return new Promise((resolve, reject) => {
+        const taskSymbol = Symbol(`task-${options.id}`);
+        this.#queue.enqueue(async () => {
+          this.#pending++;
+          this.#runningTasks.set(taskSymbol, {
+            id: options.id,
+            priority: options.priority ?? 0,
+            // Match priority-queue default
+            startTime: Date.now(),
+            timeout: options.timeout
+          });
+          let eventListener;
+          try {
+            try {
+              options.signal?.throwIfAborted();
+            } catch (error) {
+              this.#rollbackIntervalConsumption();
+              this.#runningTasks.delete(taskSymbol);
+              throw error;
+            }
+            this.#lastExecutionTime = Date.now();
+            let operation = function_({ signal: options.signal });
+            if (options.timeout) {
+              operation = pTimeout(Promise.resolve(operation), {
+                milliseconds: options.timeout,
+                message: `Task timed out after ${options.timeout}ms (queue has ${this.#pending} running, ${this.#queue.size} waiting)`
+              });
+            }
+            if (options.signal) {
+              const { signal } = options;
+              operation = Promise.race([operation, new Promise((_resolve, reject2) => {
+                eventListener = () => {
+                  reject2(signal.reason);
+                };
+                signal.addEventListener("abort", eventListener, { once: true });
+              })]);
+            }
+            const result = await operation;
+            resolve(result);
+            this.emit("completed", result);
+          } catch (error) {
+            reject(error);
+            this.emit("error", error);
+          } finally {
+            if (eventListener) {
+              options.signal?.removeEventListener("abort", eventListener);
+            }
+            this.#runningTasks.delete(taskSymbol);
+            queueMicrotask(() => {
+              this.#next();
+            });
+          }
+        }, options);
+        this.emit("add");
+        this.#tryToStartAnother();
+      });
+    }
+    async addAll(functions2, options) {
+      return Promise.all(functions2.map(async (function_) => this.add(function_, options)));
+    }
+    /**
+    Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
+    */
+    start() {
+      if (!this.#isPaused) {
+        return this;
+      }
+      this.#isPaused = false;
+      this.#processQueue();
+      return this;
+    }
+    /**
+    Put queue execution on hold.
+    */
+    pause() {
+      this.#isPaused = true;
+    }
+    /**
+    Clear the queue.
+    */
+    clear() {
+      this.#queue = new this.#queueClass();
+      this.#clearIntervalTimer();
+      this.#updateRateLimitState();
+      this.emit("empty");
+      if (this.#pending === 0) {
+        this.#clearTimeoutTimer();
+        this.emit("idle");
+      }
+      this.emit("next");
+    }
+    /**
+    	    Can be called multiple times. Useful if you for example add additional items at a later time.
+    
+    	    @returns A promise that settles when the queue becomes empty.
+    	    */
+    async onEmpty() {
+      if (this.#queue.size === 0) {
+        return;
+      }
+      await this.#onEvent("empty");
+    }
+    /**
+    	    @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
+    
+    	    If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.
+    
+    	    Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.
+    	    */
+    async onSizeLessThan(limit) {
+      if (this.#queue.size < limit) {
+        return;
+      }
+      await this.#onEvent("next", () => this.#queue.size < limit);
+    }
+    /**
+    	    The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
+    
+    	    @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
+    	    */
+    async onIdle() {
+      if (this.#pending === 0 && this.#queue.size === 0) {
+        return;
+      }
+      await this.#onEvent("idle");
+    }
+    /**
+    	    The difference with `.onIdle` is that `.onPendingZero` only waits for currently running tasks to finish, ignoring queued tasks.
+    
+    	    @returns A promise that settles when all currently running tasks have completed; `queue.pending === 0`.
+    	    */
+    async onPendingZero() {
+      if (this.#pending === 0) {
+        return;
+      }
+      await this.#onEvent("pendingZero");
+    }
+    /**
+    @returns A promise that settles when the queue becomes rate-limited due to intervalCap.
+    */
+    async onRateLimit() {
+      if (this.isRateLimited) {
+        return;
+      }
+      await this.#onEvent("rateLimit");
+    }
+    /**
+    @returns A promise that settles when the queue is no longer rate-limited.
+    */
+    async onRateLimitCleared() {
+      if (!this.isRateLimited) {
+        return;
+      }
+      await this.#onEvent("rateLimitCleared");
+    }
+    /**
+    	    @returns A promise that rejects when any task in the queue errors.
+    
+    	    Use with `Promise.race([queue.onError(), queue.onIdle()])` to fail fast on the first error while still resolving normally when the queue goes idle.
+    
+    	    Important: The promise returned by `add()` still rejects. You must handle each `add()` promise (for example, `.catch(() => {})`) to avoid unhandled rejections.
+    
+    	    @example
+    	    ```
+    	    import PQueue from 'p-queue';
+    
+    	    const queue = new PQueue({concurrency: 2});
+    
+    	    queue.add(() => fetchData(1)).catch(() => {});
+    	    queue.add(() => fetchData(2)).catch(() => {});
+    	    queue.add(() => fetchData(3)).catch(() => {});
+    
+    	    // Stop processing on first error
+    	    try {
+    	        await Promise.race([
+    	            queue.onError(),
+    	            queue.onIdle()
+    	        ]);
+    	    } catch (error) {
+    	        queue.pause(); // Stop processing remaining tasks
+    	        console.error('Queue failed:', error);
+    	    }
+    	    ```
+    	    */
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    onError() {
+      return new Promise((_resolve, reject) => {
+        const handleError = (error) => {
+          this.off("error", handleError);
+          reject(error);
+        };
+        this.on("error", handleError);
+      });
+    }
+    async #onEvent(event, filter2) {
+      return new Promise((resolve) => {
+        const listener2 = () => {
+          if (filter2 && !filter2()) {
+            return;
+          }
+          this.off(event, listener2);
+          resolve();
+        };
+        this.on(event, listener2);
+      });
+    }
+    /**
+    Size of the queue, the number of queued items waiting to run.
+    */
+    get size() {
+      return this.#queue.size;
+    }
+    /**
+    	    Size of the queue, filtered by the given options.
+    
+    	    For example, this can be used to find the number of items remaining in the queue with a specific priority level.
+    	    */
+    sizeBy(options) {
+      return this.#queue.filter(options).length;
+    }
+    /**
+    Number of running items (no longer in the queue).
+    */
+    get pending() {
+      return this.#pending;
+    }
+    /**
+    Whether the queue is currently paused.
+    */
+    get isPaused() {
+      return this.#isPaused;
+    }
+    #setupRateLimitTracking() {
+      if (this.#isIntervalIgnored) {
+        return;
+      }
+      this.on("add", () => {
+        if (this.#queue.size > 0) {
+          this.#scheduleRateLimitUpdate();
+        }
+      });
+      this.on("next", () => {
+        this.#scheduleRateLimitUpdate();
+      });
+    }
+    #scheduleRateLimitUpdate() {
+      if (this.#isIntervalIgnored || this.#rateLimitFlushScheduled) {
+        return;
+      }
+      this.#rateLimitFlushScheduled = true;
+      queueMicrotask(() => {
+        this.#rateLimitFlushScheduled = false;
+        this.#updateRateLimitState();
+      });
+    }
+    #rollbackIntervalConsumption() {
+      if (this.#isIntervalIgnored) {
+        return;
+      }
+      this.#rollbackIntervalSlot();
+      this.#scheduleRateLimitUpdate();
+    }
+    #updateRateLimitState() {
+      const previous = this.#rateLimitedInInterval;
+      if (this.#isIntervalIgnored || this.#queue.size === 0) {
+        if (previous) {
+          this.#rateLimitedInInterval = false;
+          this.emit("rateLimitCleared");
+        }
+        return;
+      }
+      let count2;
+      if (this.#strict) {
+        const now2 = Date.now();
+        this.#cleanupStrictTicks(now2);
+        count2 = this.#getActiveTicksCount();
+      } else {
+        count2 = this.#intervalCount;
+      }
+      const shouldBeRateLimited = count2 >= this.#intervalCap;
+      if (shouldBeRateLimited !== previous) {
+        this.#rateLimitedInInterval = shouldBeRateLimited;
+        this.emit(shouldBeRateLimited ? "rateLimit" : "rateLimitCleared");
+      }
+    }
+    /**
+    Whether the queue is currently rate-limited due to intervalCap.
+    */
+    get isRateLimited() {
+      return this.#rateLimitedInInterval;
+    }
+    /**
+    	    Whether the queue is saturated. Returns `true` when:
+    	    - All concurrency slots are occupied and tasks are waiting, OR
+    	    - The queue is rate-limited and tasks are waiting
+    
+    	    Useful for detecting backpressure and potential hanging tasks.
+    
+    	    ```js
+    	    import PQueue from 'p-queue';
+    
+    	    const queue = new PQueue({concurrency: 2});
+    
+    	    // Backpressure handling
+    	    if (queue.isSaturated) {
+    	        console.log('Queue is saturated, waiting for capacity...');
+    	        await queue.onSizeLessThan(queue.concurrency);
+    	    }
+    
+    	    // Monitoring for stuck tasks
+    	    setInterval(() => {
+    	        if (queue.isSaturated) {
+    	            console.warn(`Queue saturated: ${queue.pending} running, ${queue.size} waiting`);
+    	        }
+    	    }, 60000);
+    	    ```
+    	    */
+    get isSaturated() {
+      return this.#pending === this.#concurrency && this.#queue.size > 0 || this.isRateLimited && this.#queue.size > 0;
+    }
+    /**
+    	    The tasks currently being executed. Each task includes its `id`, `priority`, `startTime`, and `timeout` (if set).
+    
+    	    Returns an array of task info objects.
+    
+    	    ```js
+    	    import PQueue from 'p-queue';
+    
+    	    const queue = new PQueue({concurrency: 2});
+    
+    	    // Add tasks with IDs for better debugging
+    	    queue.add(() => fetchUser(123), {id: 'user-123'});
+    	    queue.add(() => fetchPosts(456), {id: 'posts-456', priority: 1});
+    
+    	    // Check what's running
+    	    console.log(queue.runningTasks);
+    	    // => [{
+    	    //   id: 'user-123',
+    	    //   priority: 0,
+    	    //   startTime: 1759253001716,
+    	    //   timeout: undefined
+    	    // }, {
+    	    //   id: 'posts-456',
+    	    //   priority: 1,
+    	    //   startTime: 1759253001916,
+    	    //   timeout: undefined
+    	    // }]
+    	    ```
+    	    */
+    get runningTasks() {
+      return [...this.#runningTasks.values()].map((task) => ({ ...task }));
+    }
+  }
   function cleanSessionCache(sessionIdentifier2) {
     for (const storage of [sessionStorage, localStorage]) {
       const keys = Object.keys(storage);
@@ -72312,7 +73308,7 @@ Inferred class string: "${iconClasses}."`
             }
             comparison = aTime - bTime;
           } else {
-            comparison = String(aVal).localeCompare(String(bVal));
+            comparison = String(aVal).localeCompare(String(bVal), void 0, { sensitivity: "base" });
           }
           return desc ? -comparison : comparison;
         });
@@ -74757,6 +75753,25 @@ Inferred class string: "${iconClasses}."`
   const STORE_VARIABLE_MAP = /* @__PURE__ */ new Map();
   const STORE_SEQUENCE_MAP = /* @__PURE__ */ new Map();
   const STORE_LATEST_VALUE_MAP = /* @__PURE__ */ new Map();
+  const STORE_RECOVERY_IN_PROGRESS = /* @__PURE__ */ new Set();
+  class PatchQueue {
+    constructor() {
+      this.queues = /* @__PURE__ */ new Map();
+    }
+    getQueue(storeUid) {
+      let queue = this.queues.get(storeUid);
+      if (!queue) {
+        queue = new PQueue({ concurrency: 1 });
+        this.queues.set(storeUid, queue);
+      }
+      return queue;
+    }
+    enqueue(storeUid, patches, sequenceNumber, applyFn) {
+      const queue = this.getQueue(storeUid);
+      queue.add(() => applyFn(storeUid, patches, sequenceNumber));
+    }
+  }
+  const PATCH_QUEUE = new PatchQueue();
   const ROUTE_MATCHES_KEY = "__route_matches";
   function BackendStoreSync({ children }) {
     const { client: client2 } = React__namespace.useContext(websocketCtx);
@@ -74774,7 +75789,7 @@ Inferred class string: "${iconClasses}."`
       async ({ diff }) => {
         const extrasMap = /* @__PURE__ */ new Map();
         Array.from(diff.entries()).filter(
-          ([itemKey, value]) => !STORE_LATEST_VALUE_MAP.has(itemKey) || STORE_LATEST_VALUE_MAP.get(itemKey) !== value
+          ([itemKey, value]) => !STORE_LATEST_VALUE_MAP.has(itemKey) || !isEqual$4(STORE_LATEST_VALUE_MAP.get(itemKey), value)
         ).forEach(([itemKey, value]) => {
           STORE_LATEST_VALUE_MAP.set(itemKey, value);
           const extras = STORE_EXTRAS_MAP.get(itemKey);
@@ -74810,9 +75825,42 @@ Inferred class string: "${iconClasses}."`
       ({ snapshot, set: set2 }) => async (storeUid, patches, sequenceNumber) => {
         const expectedSequence = STORE_SEQUENCE_MAP.get(storeUid) || 0;
         if (sequenceNumber !== expectedSequence + 1) {
+          if (sequenceNumber <= expectedSequence) {
+            return;
+          }
           console.warn(
-            `Sequence number mismatch for store ${storeUid}. Expected: ${expectedSequence + 1}, Got: ${sequenceNumber}. Rejecting patch.`
+            `Sequence number mismatch for store ${storeUid}. Expected: ${expectedSequence + 1}, Got: ${sequenceNumber}.`
           );
+          if (!STORE_RECOVERY_IN_PROGRESS.has(storeUid)) {
+            STORE_RECOVERY_IN_PROGRESS.add(storeUid);
+            console.warn(`Fetching full state for store ${storeUid} to recover.`);
+            try {
+              const fullValue = await getStoreValue(storeUid);
+              const variableUids2 = STORE_VARIABLE_MAP.get(storeUid);
+              if (variableUids2) {
+                for (const variableUid of variableUids2) {
+                  const directAtom = atomRegistry.get(variableUid);
+                  if (directAtom) {
+                    set2(directAtom, fullValue);
+                    continue;
+                  }
+                  const atomFamily2 = atomFamilyRegistry.get(variableUid);
+                  if (atomFamily2) {
+                    const familyMembers = atomFamilyMembersRegistry.get(atomFamily2);
+                    if (familyMembers) {
+                      for (const [, atomInstance] of familyMembers) {
+                        set2(atomInstance, fullValue);
+                      }
+                    }
+                  }
+                }
+              }
+            } catch (e2) {
+              console.error(`Failed to recover store ${storeUid} after sequence mismatch:`, e2);
+            } finally {
+              STORE_RECOVERY_IN_PROGRESS.delete(storeUid);
+            }
+          }
           return;
         }
         STORE_SEQUENCE_MAP.set(storeUid, sequenceNumber);
@@ -74887,7 +75935,7 @@ Inferred class string: "${iconClasses}."`
           STORE_LATEST_VALUE_MAP.set(message.store_uid, message.value);
         });
         const patchSub = client2.backendStorePatchMessages$().subscribe((message) => {
-          applyPatchesToAtoms(message.store_uid, message.patches, message.sequence_number);
+          PATCH_QUEUE.enqueue(message.store_uid, message.patches, message.sequence_number, applyPatchesToAtoms);
         });
         return () => {
           valueSub.unsubscribe();