@cendarsoss/pusher-js 8.4.17 → 8.4.18

package/dist/web/pusher.mjs

@@ -286,9 +286,9 @@ function encode(s) {
 }
 var fromCharCode = String.fromCharCode;
 var b64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-var cb_utob = function(c) {
-  var cc = c.charCodeAt(0);
-  return cc < 128 ? c : cc < 2048 ? fromCharCode(192 | cc >>> 6) + fromCharCode(128 | cc & 63) : fromCharCode(224 | cc >>> 12 & 15) + fromCharCode(128 | cc >>> 6 & 63) + fromCharCode(128 | cc & 63);
+var cb_utob = function(c3) {
+  var cc = c3.charCodeAt(0);
+  return cc < 128 ? c3 : cc < 2048 ? fromCharCode(192 | cc >>> 6) + fromCharCode(128 | cc & 63) : fromCharCode(224 | cc >>> 12 & 15) + fromCharCode(128 | cc >>> 6 & 63) + fromCharCode(128 | cc & 63);
 };
 var utob = function(u) {
   return u.replace(/[^\x00-\x7F]/g, cb_utob);
@@ -331,7 +331,7 @@ class Timer {
     }
   }
 }
-function clearTimeout(timer) {
+function clearTimeout$1(timer) {
   window.clearTimeout(timer);
 }
 function clearInterval(timer) {
@@ -339,7 +339,7 @@ function clearInterval(timer) {
 }
 class OneOffTimer extends Timer {
   constructor(delay, callback) {
-    super(setTimeout, clearTimeout, delay, function(timer) {
+    super(setTimeout, clearTimeout$1, delay, function(timer) {
       callback();
       return null;
     });
@@ -848,7 +848,7 @@ class Dispatcher {
     }
     this.global_callbacks = filter(
       this.global_callbacks || [],
-      (c) => c !== callback
+      (c3) => c3 !== callback
     );
     return this;
   }
@@ -1900,25 +1900,25 @@ function requireUtf8() {
     var arr = new Uint8Array(encodedLength(s));
     var pos = 0;
     for (var i = 0; i < s.length; i++) {
-      var c = s.charCodeAt(i);
-      if (c < 128) {
-        arr[pos++] = c;
-      } else if (c < 2048) {
-        arr[pos++] = 192 | c >> 6;
-        arr[pos++] = 128 | c & 63;
-      } else if (c < 55296) {
-        arr[pos++] = 224 | c >> 12;
-        arr[pos++] = 128 | c >> 6 & 63;
-        arr[pos++] = 128 | c & 63;
+      var c3 = s.charCodeAt(i);
+      if (c3 < 128) {
+        arr[pos++] = c3;
+      } else if (c3 < 2048) {
+        arr[pos++] = 192 | c3 >> 6;
+        arr[pos++] = 128 | c3 & 63;
+      } else if (c3 < 55296) {
+        arr[pos++] = 224 | c3 >> 12;
+        arr[pos++] = 128 | c3 >> 6 & 63;
+        arr[pos++] = 128 | c3 & 63;
       } else {
         i++;
-        c = (c & 1023) << 10;
-        c |= s.charCodeAt(i) & 1023;
-        c += 65536;
-        arr[pos++] = 240 | c >> 18;
-        arr[pos++] = 128 | c >> 12 & 63;
-        arr[pos++] = 128 | c >> 6 & 63;
-        arr[pos++] = 128 | c & 63;
+        c3 = (c3 & 1023) << 10;
+        c3 |= s.charCodeAt(i) & 1023;
+        c3 += 65536;
+        arr[pos++] = 240 | c3 >> 18;
+        arr[pos++] = 128 | c3 >> 12 & 63;
+        arr[pos++] = 128 | c3 >> 6 & 63;
+        arr[pos++] = 128 | c3 & 63;
       }
     }
     return arr;
@@ -1927,14 +1927,14 @@ function requireUtf8() {
   function encodedLength(s) {
     var result = 0;
     for (var i = 0; i < s.length; i++) {
-      var c = s.charCodeAt(i);
-      if (c < 128) {
+      var c3 = s.charCodeAt(i);
+      if (c3 < 128) {
         result += 1;
-      } else if (c < 2048) {
+      } else if (c3 < 2048) {
         result += 2;
-      } else if (c < 55296) {
+      } else if (c3 < 55296) {
         result += 3;
-      } else if (c <= 57343) {
+      } else if (c3 <= 57343) {
         if (i >= s.length - 1) {
           throw new Error(INVALID_UTF16);
         }
@@ -2052,19 +2052,19 @@ function requireBase64() {
         var out = "";
         var i = 0;
         for (; i < data.length - 2; i += 3) {
-          var c = data[i] << 16 | data[i + 1] << 8 | data[i + 2];
-          out += this._encodeByte(c >>> 3 * 6 & 63);
-          out += this._encodeByte(c >>> 2 * 6 & 63);
-          out += this._encodeByte(c >>> 1 * 6 & 63);
-          out += this._encodeByte(c >>> 0 * 6 & 63);
+          var c3 = data[i] << 16 | data[i + 1] << 8 | data[i + 2];
+          out += this._encodeByte(c3 >>> 3 * 6 & 63);
+          out += this._encodeByte(c3 >>> 2 * 6 & 63);
+          out += this._encodeByte(c3 >>> 1 * 6 & 63);
+          out += this._encodeByte(c3 >>> 0 * 6 & 63);
         }
         var left = data.length - i;
         if (left > 0) {
-          var c = data[i] << 16 | (left === 2 ? data[i + 1] << 8 : 0);
-          out += this._encodeByte(c >>> 3 * 6 & 63);
-          out += this._encodeByte(c >>> 2 * 6 & 63);
+          var c3 = data[i] << 16 | (left === 2 ? data[i + 1] << 8 : 0);
+          out += this._encodeByte(c3 >>> 3 * 6 & 63);
+          out += this._encodeByte(c3 >>> 2 * 6 & 63);
           if (left === 2) {
-            out += this._encodeByte(c >>> 1 * 6 & 63);
+            out += this._encodeByte(c3 >>> 1 * 6 & 63);
           } else {
             out += this._paddingCharacter || "";
           }
@@ -2136,13 +2136,13 @@ function requireBase64() {
         result += 62 - b >>> 8 & 62 - 43 - 63 + 47;
         return String.fromCharCode(result);
       };
-      Coder2.prototype._decodeChar = function(c) {
+      Coder2.prototype._decodeChar = function(c3) {
         var result = INVALID_BYTE;
-        result += (42 - c & c - 44) >>> 8 & -INVALID_BYTE + c - 43 + 62;
-        result += (46 - c & c - 48) >>> 8 & -INVALID_BYTE + c - 47 + 63;
-        result += (47 - c & c - 58) >>> 8 & -INVALID_BYTE + c - 48 + 52;
-        result += (64 - c & c - 91) >>> 8 & -INVALID_BYTE + c - 65 + 0;
-        result += (96 - c & c - 123) >>> 8 & -INVALID_BYTE + c - 97 + 26;
+        result += (42 - c3 & c3 - 44) >>> 8 & -INVALID_BYTE + c3 - 43 + 62;
+        result += (46 - c3 & c3 - 48) >>> 8 & -INVALID_BYTE + c3 - 47 + 63;
+        result += (47 - c3 & c3 - 58) >>> 8 & -INVALID_BYTE + c3 - 48 + 52;
+        result += (64 - c3 & c3 - 91) >>> 8 & -INVALID_BYTE + c3 - 65 + 0;
+        result += (96 - c3 & c3 - 123) >>> 8 & -INVALID_BYTE + c3 - 97 + 26;
         return result;
       };
       Coder2.prototype._getPaddingLength = function(s) {
@@ -2189,13 +2189,13 @@ function requireBase64() {
         result += 62 - b >>> 8 & 62 - 45 - 63 + 95;
         return String.fromCharCode(result);
       };
-      URLSafeCoder2.prototype._decodeChar = function(c) {
+      URLSafeCoder2.prototype._decodeChar = function(c3) {
         var result = INVALID_BYTE;
-        result += (44 - c & c - 46) >>> 8 & -INVALID_BYTE + c - 45 + 62;
-        result += (94 - c & c - 96) >>> 8 & -INVALID_BYTE + c - 95 + 63;
-        result += (47 - c & c - 58) >>> 8 & -INVALID_BYTE + c - 48 + 52;
-        result += (64 - c & c - 91) >>> 8 & -INVALID_BYTE + c - 65 + 0;
-        result += (96 - c & c - 123) >>> 8 & -INVALID_BYTE + c - 97 + 26;
+        result += (44 - c3 & c3 - 46) >>> 8 & -INVALID_BYTE + c3 - 45 + 62;
+        result += (94 - c3 & c3 - 96) >>> 8 & -INVALID_BYTE + c3 - 95 + 63;
+        result += (47 - c3 & c3 - 58) >>> 8 & -INVALID_BYTE + c3 - 48 + 52;
+        result += (64 - c3 & c3 - 91) >>> 8 & -INVALID_BYTE + c3 - 65 + 0;
+        result += (96 - c3 & c3 - 123) >>> 8 & -INVALID_BYTE + c3 - 97 + 26;
         return result;
       };
       return URLSafeCoder2;
@@ -4276,12 +4276,551 @@ class UserFacade extends Dispatcher {
     this._signinDoneResolve = resolve;
   }
 }
+var x = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date, I = /* @__PURE__ */ new Set(), R = typeof process == "object" && process ? process : {}, U = (c3, t, e, i) => {
+  typeof R.emitWarning == "function" ? R.emitWarning(c3, t, e, i) : console.error(`[${e}] ${t}: ${c3}`);
+}, C = globalThis.AbortController, D = globalThis.AbortSignal;
+if (typeof C > "u") {
+  D = class {
+    onabort;
+    _onabort = [];
+    reason;
+    aborted = false;
+    addEventListener(i, s) {
+      this._onabort.push(s);
+    }
+  }, C = class {
+    constructor() {
+      t();
+    }
+    signal = new D();
+    abort(i) {
+      if (!this.signal.aborted) {
+        this.signal.reason = i, this.signal.aborted = true;
+        for (let s of this.signal._onabort) s(i);
+        this.signal.onabort?.(i);
+      }
+    }
+  };
+  let c3 = R.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1", t = () => {
+    c3 && (c3 = false, U("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", t));
+  };
+}
+var G = (c3) => !I.has(c3), y = (c3) => c3 && c3 === Math.floor(c3) && c3 > 0 && isFinite(c3), M = (c3) => y(c3) ? c3 <= Math.pow(2, 8) ? Uint8Array : c3 <= Math.pow(2, 16) ? Uint16Array : c3 <= Math.pow(2, 32) ? Uint32Array : c3 <= Number.MAX_SAFE_INTEGER ? z : null : null, z = class extends Array {
+  constructor(t) {
+    super(t), this.fill(0);
+  }
+}, W = class c {
+  heap;
+  length;
+  static #o = false;
+  static create(t) {
+    let e = M(t);
+    if (!e) return [];
+    c.#o = true;
+    let i = new c(t, e);
+    return c.#o = false, i;
+  }
+  constructor(t, e) {
+    if (!c.#o) throw new TypeError("instantiate Stack using Stack.create(n)");
+    this.heap = new e(t), this.length = 0;
+  }
+  push(t) {
+    this.heap[this.length++] = t;
+  }
+  pop() {
+    return this.heap[--this.length];
+  }
+}, L = class c2 {
+  #o;
+  #c;
+  #w;
+  #C;
+  #S;
+  #L;
+  #I;
+  #m;
+  get perf() {
+    return this.#m;
+  }
+  ttl;
+  ttlResolution;
+  ttlAutopurge;
+  updateAgeOnGet;
+  updateAgeOnHas;
+  allowStale;
+  noDisposeOnSet;
+  noUpdateTTL;
+  maxEntrySize;
+  sizeCalculation;
+  noDeleteOnFetchRejection;
+  noDeleteOnStaleGet;
+  allowStaleOnFetchAbort;
+  allowStaleOnFetchRejection;
+  ignoreFetchAbort;
+  #n;
+  #_;
+  #s;
+  #i;
+  #t;
+  #a;
+  #u;
+  #l;
+  #h;
+  #b;
+  #r;
+  #y;
+  #A;
+  #d;
+  #g;
+  #T;
+  #v;
+  #f;
+  #U;
+  static unsafeExposeInternals(t) {
+    return { starts: t.#A, ttls: t.#d, autopurgeTimers: t.#g, sizes: t.#y, keyMap: t.#s, keyList: t.#i, valList: t.#t, next: t.#a, prev: t.#u, get head() {
+      return t.#l;
+    }, get tail() {
+      return t.#h;
+    }, free: t.#b, isBackgroundFetch: (e) => t.#e(e), backgroundFetch: (e, i, s, n) => t.#G(e, i, s, n), moveToTail: (e) => t.#D(e), indexes: (e) => t.#F(e), rindexes: (e) => t.#O(e), isStale: (e) => t.#p(e) };
+  }
+  get max() {
+    return this.#o;
+  }
+  get maxSize() {
+    return this.#c;
+  }
+  get calculatedSize() {
+    return this.#_;
+  }
+  get size() {
+    return this.#n;
+  }
+  get fetchMethod() {
+    return this.#L;
+  }
+  get memoMethod() {
+    return this.#I;
+  }
+  get dispose() {
+    return this.#w;
+  }
+  get onInsert() {
+    return this.#C;
+  }
+  get disposeAfter() {
+    return this.#S;
+  }
+  constructor(t) {
+    let { max: e = 0, ttl: i, ttlResolution: s = 1, ttlAutopurge: n, updateAgeOnGet: o, updateAgeOnHas: h, allowStale: r, dispose: a, onInsert: w, disposeAfter: f, noDisposeOnSet: d, noUpdateTTL: g, maxSize: A = 0, maxEntrySize: p = 0, sizeCalculation: _, fetchMethod: l, memoMethod: S, noDeleteOnFetchRejection: b, noDeleteOnStaleGet: m, allowStaleOnFetchRejection: u, allowStaleOnFetchAbort: T, ignoreFetchAbort: F, perf: v } = t;
+    if (v !== void 0 && typeof v?.now != "function") throw new TypeError("perf option must have a now() method if specified");
+    if (this.#m = v ?? x, e !== 0 && !y(e)) throw new TypeError("max option must be a nonnegative integer");
+    let O = e ? M(e) : Array;
+    if (!O) throw new Error("invalid max value: " + e);
+    if (this.#o = e, this.#c = A, this.maxEntrySize = p || this.#c, this.sizeCalculation = _, this.sizeCalculation) {
+      if (!this.#c && !this.maxEntrySize) throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+      if (typeof this.sizeCalculation != "function") throw new TypeError("sizeCalculation set to non-function");
+    }
+    if (S !== void 0 && typeof S != "function") throw new TypeError("memoMethod must be a function if defined");
+    if (this.#I = S, l !== void 0 && typeof l != "function") throw new TypeError("fetchMethod must be a function if specified");
+    if (this.#L = l, this.#v = !!l, this.#s = /* @__PURE__ */ new Map(), this.#i = new Array(e).fill(void 0), this.#t = new Array(e).fill(void 0), this.#a = new O(e), this.#u = new O(e), this.#l = 0, this.#h = 0, this.#b = W.create(e), this.#n = 0, this.#_ = 0, typeof a == "function" && (this.#w = a), typeof w == "function" && (this.#C = w), typeof f == "function" ? (this.#S = f, this.#r = []) : (this.#S = void 0, this.#r = void 0), this.#T = !!this.#w, this.#U = !!this.#C, this.#f = !!this.#S, this.noDisposeOnSet = !!d, this.noUpdateTTL = !!g, this.noDeleteOnFetchRejection = !!b, this.allowStaleOnFetchRejection = !!u, this.allowStaleOnFetchAbort = !!T, this.ignoreFetchAbort = !!F, this.maxEntrySize !== 0) {
+      if (this.#c !== 0 && !y(this.#c)) throw new TypeError("maxSize must be a positive integer if specified");
+      if (!y(this.maxEntrySize)) throw new TypeError("maxEntrySize must be a positive integer if specified");
+      this.#B();
+    }
+    if (this.allowStale = !!r, this.noDeleteOnStaleGet = !!m, this.updateAgeOnGet = !!o, this.updateAgeOnHas = !!h, this.ttlResolution = y(s) || s === 0 ? s : 1, this.ttlAutopurge = !!n, this.ttl = i || 0, this.ttl) {
+      if (!y(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
+      this.#j();
+    }
+    if (this.#o === 0 && this.ttl === 0 && this.#c === 0) throw new TypeError("At least one of max, maxSize, or ttl is required");
+    if (!this.ttlAutopurge && !this.#o && !this.#c) {
+      let E = "LRU_CACHE_UNBOUNDED";
+      G(E) && (I.add(E), U("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", E, c2));
+    }
+  }
+  getRemainingTTL(t) {
+    return this.#s.has(t) ? 1 / 0 : 0;
+  }
+  #j() {
+    let t = new z(this.#o), e = new z(this.#o);
+    this.#d = t, this.#A = e;
+    let i = this.ttlAutopurge ? new Array(this.#o) : void 0;
+    this.#g = i, this.#N = (h, r, a = this.#m.now()) => {
+      e[h] = r !== 0 ? a : 0, t[h] = r, s(h, r);
+    }, this.#R = (h) => {
+      e[h] = t[h] !== 0 ? this.#m.now() : 0, s(h, t[h]);
+    };
+    let s = this.ttlAutopurge ? (h, r) => {
+      if (i?.[h] && (clearTimeout(i[h]), i[h] = void 0), r && r !== 0 && i) {
+        let a = setTimeout(() => {
+          this.#p(h) && this.#E(this.#i[h], "expire");
+        }, r + 1);
+        a.unref && a.unref(), i[h] = a;
+      }
+    } : () => {
+    };
+    this.#z = (h, r) => {
+      if (t[r]) {
+        let a = t[r], w = e[r];
+        if (!a || !w) return;
+        h.ttl = a, h.start = w, h.now = n || o();
+        let f = h.now - w;
+        h.remainingTTL = a - f;
+      }
+    };
+    let n = 0, o = () => {
+      let h = this.#m.now();
+      if (this.ttlResolution > 0) {
+        n = h;
+        let r = setTimeout(() => n = 0, this.ttlResolution);
+        r.unref && r.unref();
+      }
+      return h;
+    };
+    this.getRemainingTTL = (h) => {
+      let r = this.#s.get(h);
+      if (r === void 0) return 0;
+      let a = t[r], w = e[r];
+      if (!a || !w) return 1 / 0;
+      let f = (n || o()) - w;
+      return a - f;
+    }, this.#p = (h) => {
+      let r = e[h], a = t[h];
+      return !!a && !!r && (n || o()) - r > a;
+    };
+  }
+  #R = () => {
+  };
+  #z = () => {
+  };
+  #N = () => {
+  };
+  #p = () => false;
+  #B() {
+    let t = new z(this.#o);
+    this.#_ = 0, this.#y = t, this.#W = (e) => {
+      this.#_ -= t[e], t[e] = 0;
+    }, this.#P = (e, i, s, n) => {
+      if (this.#e(i)) return 0;
+      if (!y(s)) if (n) {
+        if (typeof n != "function") throw new TypeError("sizeCalculation must be a function");
+        if (s = n(i, e), !y(s)) throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+      } else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+      return s;
+    }, this.#M = (e, i, s) => {
+      if (t[e] = i, this.#c) {
+        let n = this.#c - t[e];
+        for (; this.#_ > n; ) this.#x(true);
+      }
+      this.#_ += t[e], s && (s.entrySize = i, s.totalCalculatedSize = this.#_);
+    };
+  }
+  #W = (t) => {
+  };
+  #M = (t, e, i) => {
+  };
+  #P = (t, e, i, s) => {
+    if (i || s) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+    return 0;
+  };
+  *#F({ allowStale: t = this.allowStale } = {}) {
+    if (this.#n) for (let e = this.#h; !(!this.#H(e) || ((t || !this.#p(e)) && (yield e), e === this.#l)); ) e = this.#u[e];
+  }
+  *#O({ allowStale: t = this.allowStale } = {}) {
+    if (this.#n) for (let e = this.#l; !(!this.#H(e) || ((t || !this.#p(e)) && (yield e), e === this.#h)); ) e = this.#a[e];
+  }
+  #H(t) {
+    return t !== void 0 && this.#s.get(this.#i[t]) === t;
+  }
+  *entries() {
+    for (let t of this.#F()) this.#t[t] !== void 0 && this.#i[t] !== void 0 && !this.#e(this.#t[t]) && (yield [this.#i[t], this.#t[t]]);
+  }
+  *rentries() {
+    for (let t of this.#O()) this.#t[t] !== void 0 && this.#i[t] !== void 0 && !this.#e(this.#t[t]) && (yield [this.#i[t], this.#t[t]]);
+  }
+  *keys() {
+    for (let t of this.#F()) {
+      let e = this.#i[t];
+      e !== void 0 && !this.#e(this.#t[t]) && (yield e);
+    }
+  }
+  *rkeys() {
+    for (let t of this.#O()) {
+      let e = this.#i[t];
+      e !== void 0 && !this.#e(this.#t[t]) && (yield e);
+    }
+  }
+  *values() {
+    for (let t of this.#F()) this.#t[t] !== void 0 && !this.#e(this.#t[t]) && (yield this.#t[t]);
+  }
+  *rvalues() {
+    for (let t of this.#O()) this.#t[t] !== void 0 && !this.#e(this.#t[t]) && (yield this.#t[t]);
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  [Symbol.toStringTag] = "LRUCache";
+  find(t, e = {}) {
+    for (let i of this.#F()) {
+      let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+      if (n !== void 0 && t(n, this.#i[i], this)) return this.get(this.#i[i], e);
+    }
+  }
+  forEach(t, e = this) {
+    for (let i of this.#F()) {
+      let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+      n !== void 0 && t.call(e, n, this.#i[i], this);
+    }
+  }
+  rforEach(t, e = this) {
+    for (let i of this.#O()) {
+      let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+      n !== void 0 && t.call(e, n, this.#i[i], this);
+    }
+  }
+  purgeStale() {
+    let t = false;
+    for (let e of this.#O({ allowStale: true })) this.#p(e) && (this.#E(this.#i[e], "expire"), t = true);
+    return t;
+  }
+  info(t) {
+    let e = this.#s.get(t);
+    if (e === void 0) return;
+    let i = this.#t[e], s = this.#e(i) ? i.__staleWhileFetching : i;
+    if (s === void 0) return;
+    let n = { value: s };
+    if (this.#d && this.#A) {
+      let o = this.#d[e], h = this.#A[e];
+      if (o && h) {
+        let r = o - (this.#m.now() - h);
+        n.ttl = r, n.start = Date.now();
+      }
+    }
+    return this.#y && (n.size = this.#y[e]), n;
+  }
+  dump() {
+    let t = [];
+    for (let e of this.#F({ allowStale: true })) {
+      let i = this.#i[e], s = this.#t[e], n = this.#e(s) ? s.__staleWhileFetching : s;
+      if (n === void 0 || i === void 0) continue;
+      let o = { value: n };
+      if (this.#d && this.#A) {
+        o.ttl = this.#d[e];
+        let h = this.#m.now() - this.#A[e];
+        o.start = Math.floor(Date.now() - h);
+      }
+      this.#y && (o.size = this.#y[e]), t.unshift([i, o]);
+    }
+    return t;
+  }
+  load(t) {
+    this.clear();
+    for (let [e, i] of t) {
+      if (i.start) {
+        let s = Date.now() - i.start;
+        i.start = this.#m.now() - s;
+      }
+      this.set(e, i.value, i);
+    }
+  }
+  set(t, e, i = {}) {
+    if (e === void 0) return this.delete(t), this;
+    let { ttl: s = this.ttl, start: n, noDisposeOnSet: o = this.noDisposeOnSet, sizeCalculation: h = this.sizeCalculation, status: r } = i, { noUpdateTTL: a = this.noUpdateTTL } = i, w = this.#P(t, e, i.size || 0, h);
+    if (this.maxEntrySize && w > this.maxEntrySize) return r && (r.set = "miss", r.maxEntrySizeExceeded = true), this.#E(t, "set"), this;
+    let f = this.#n === 0 ? void 0 : this.#s.get(t);
+    if (f === void 0) f = this.#n === 0 ? this.#h : this.#b.length !== 0 ? this.#b.pop() : this.#n === this.#o ? this.#x(false) : this.#n, this.#i[f] = t, this.#t[f] = e, this.#s.set(t, f), this.#a[this.#h] = f, this.#u[f] = this.#h, this.#h = f, this.#n++, this.#M(f, w, r), r && (r.set = "add"), a = false, this.#U && this.#C?.(e, t, "add");
+    else {
+      this.#D(f);
+      let d = this.#t[f];
+      if (e !== d) {
+        if (this.#v && this.#e(d)) {
+          d.__abortController.abort(new Error("replaced"));
+          let { __staleWhileFetching: g } = d;
+          g !== void 0 && !o && (this.#T && this.#w?.(g, t, "set"), this.#f && this.#r?.push([g, t, "set"]));
+        } else o || (this.#T && this.#w?.(d, t, "set"), this.#f && this.#r?.push([d, t, "set"]));
+        if (this.#W(f), this.#M(f, w, r), this.#t[f] = e, r) {
+          r.set = "replace";
+          let g = d && this.#e(d) ? d.__staleWhileFetching : d;
+          g !== void 0 && (r.oldValue = g);
+        }
+      } else r && (r.set = "update");
+      this.#U && this.onInsert?.(e, t, e === d ? "update" : "replace");
+    }
+    if (s !== 0 && !this.#d && this.#j(), this.#d && (a || this.#N(f, s, n), r && this.#z(r, f)), !o && this.#f && this.#r) {
+      let d = this.#r, g;
+      for (; g = d?.shift(); ) this.#S?.(...g);
+    }
+    return this;
+  }
+  pop() {
+    try {
+      for (; this.#n; ) {
+        let t = this.#t[this.#l];
+        if (this.#x(true), this.#e(t)) {
+          if (t.__staleWhileFetching) return t.__staleWhileFetching;
+        } else if (t !== void 0) return t;
+      }
+    } finally {
+      if (this.#f && this.#r) {
+        let t = this.#r, e;
+        for (; e = t?.shift(); ) this.#S?.(...e);
+      }
+    }
+  }
+  #x(t) {
+    let e = this.#l, i = this.#i[e], s = this.#t[e];
+    return this.#v && this.#e(s) ? s.__abortController.abort(new Error("evicted")) : (this.#T || this.#f) && (this.#T && this.#w?.(s, i, "evict"), this.#f && this.#r?.push([s, i, "evict"])), this.#W(e), this.#g?.[e] && (clearTimeout(this.#g[e]), this.#g[e] = void 0), t && (this.#i[e] = void 0, this.#t[e] = void 0, this.#b.push(e)), this.#n === 1 ? (this.#l = this.#h = 0, this.#b.length = 0) : this.#l = this.#a[e], this.#s.delete(i), this.#n--, e;
+  }
+  has(t, e = {}) {
+    let { updateAgeOnHas: i = this.updateAgeOnHas, status: s } = e, n = this.#s.get(t);
+    if (n !== void 0) {
+      let o = this.#t[n];
+      if (this.#e(o) && o.__staleWhileFetching === void 0) return false;
+      if (this.#p(n)) s && (s.has = "stale", this.#z(s, n));
+      else return i && this.#R(n), s && (s.has = "hit", this.#z(s, n)), true;
+    } else s && (s.has = "miss");
+    return false;
+  }
+  peek(t, e = {}) {
+    let { allowStale: i = this.allowStale } = e, s = this.#s.get(t);
+    if (s === void 0 || !i && this.#p(s)) return;
+    let n = this.#t[s];
+    return this.#e(n) ? n.__staleWhileFetching : n;
+  }
+  #G(t, e, i, s) {
+    let n = e === void 0 ? void 0 : this.#t[e];
+    if (this.#e(n)) return n;
+    let o = new C(), { signal: h } = i;
+    h?.addEventListener("abort", () => o.abort(h.reason), { signal: o.signal });
+    let r = { signal: o.signal, options: i, context: s }, a = (p, _ = false) => {
+      let { aborted: l } = o.signal, S = i.ignoreFetchAbort && p !== void 0, b = i.ignoreFetchAbort || !!(i.allowStaleOnFetchAbort && p !== void 0);
+      if (i.status && (l && !_ ? (i.status.fetchAborted = true, i.status.fetchError = o.signal.reason, S && (i.status.fetchAbortIgnored = true)) : i.status.fetchResolved = true), l && !S && !_) return f(o.signal.reason, b);
+      let m = g, u = this.#t[e];
+      return (u === g || S && _ && u === void 0) && (p === void 0 ? m.__staleWhileFetching !== void 0 ? this.#t[e] = m.__staleWhileFetching : this.#E(t, "fetch") : (i.status && (i.status.fetchUpdated = true), this.set(t, p, r.options))), p;
+    }, w = (p) => (i.status && (i.status.fetchRejected = true, i.status.fetchError = p), f(p, false)), f = (p, _) => {
+      let { aborted: l } = o.signal, S = l && i.allowStaleOnFetchAbort, b = S || i.allowStaleOnFetchRejection, m = b || i.noDeleteOnFetchRejection, u = g;
+      if (this.#t[e] === g && (!m || !_ && u.__staleWhileFetching === void 0 ? this.#E(t, "fetch") : S || (this.#t[e] = u.__staleWhileFetching)), b) return i.status && u.__staleWhileFetching !== void 0 && (i.status.returnedStale = true), u.__staleWhileFetching;
+      if (u.__returned === u) throw p;
+    }, d = (p, _) => {
+      let l = this.#L?.(t, n, r);
+      l && l instanceof Promise && l.then((S) => p(S === void 0 ? void 0 : S), _), o.signal.addEventListener("abort", () => {
+        (!i.ignoreFetchAbort || i.allowStaleOnFetchAbort) && (p(void 0), i.allowStaleOnFetchAbort && (p = (S) => a(S, true)));
+      });
+    };
+    i.status && (i.status.fetchDispatched = true);
+    let g = new Promise(d).then(a, w), A = Object.assign(g, { __abortController: o, __staleWhileFetching: n, __returned: void 0 });
+    return e === void 0 ? (this.set(t, A, { ...r.options, status: void 0 }), e = this.#s.get(t)) : this.#t[e] = A, A;
+  }
+  #e(t) {
+    if (!this.#v) return false;
+    let e = t;
+    return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof C;
+  }
+  async fetch(t, e = {}) {
+    let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, ttl: o = this.ttl, noDisposeOnSet: h = this.noDisposeOnSet, size: r = 0, sizeCalculation: a = this.sizeCalculation, noUpdateTTL: w = this.noUpdateTTL, noDeleteOnFetchRejection: f = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: d = this.allowStaleOnFetchRejection, ignoreFetchAbort: g = this.ignoreFetchAbort, allowStaleOnFetchAbort: A = this.allowStaleOnFetchAbort, context: p, forceRefresh: _ = false, status: l, signal: S } = e;
+    if (!this.#v) return l && (l.fetch = "get"), this.get(t, { allowStale: i, updateAgeOnGet: s, noDeleteOnStaleGet: n, status: l });
+    let b = { allowStale: i, updateAgeOnGet: s, noDeleteOnStaleGet: n, ttl: o, noDisposeOnSet: h, size: r, sizeCalculation: a, noUpdateTTL: w, noDeleteOnFetchRejection: f, allowStaleOnFetchRejection: d, allowStaleOnFetchAbort: A, ignoreFetchAbort: g, status: l, signal: S }, m = this.#s.get(t);
+    if (m === void 0) {
+      l && (l.fetch = "miss");
+      let u = this.#G(t, m, b, p);
+      return u.__returned = u;
+    } else {
+      let u = this.#t[m];
+      if (this.#e(u)) {
+        let E = i && u.__staleWhileFetching !== void 0;
+        return l && (l.fetch = "inflight", E && (l.returnedStale = true)), E ? u.__staleWhileFetching : u.__returned = u;
+      }
+      let T = this.#p(m);
+      if (!_ && !T) return l && (l.fetch = "hit"), this.#D(m), s && this.#R(m), l && this.#z(l, m), u;
+      let F = this.#G(t, m, b, p), O = F.__staleWhileFetching !== void 0 && i;
+      return l && (l.fetch = T ? "stale" : "refresh", O && T && (l.returnedStale = true)), O ? F.__staleWhileFetching : F.__returned = F;
+    }
+  }
+  async forceFetch(t, e = {}) {
+    let i = await this.fetch(t, e);
+    if (i === void 0) throw new Error("fetch() returned undefined");
+    return i;
+  }
+  memo(t, e = {}) {
+    let i = this.#I;
+    if (!i) throw new Error("no memoMethod provided to constructor");
+    let { context: s, forceRefresh: n, ...o } = e, h = this.get(t, o);
+    if (!n && h !== void 0) return h;
+    let r = i(t, h, { options: o, context: s });
+    return this.set(t, r, o), r;
+  }
+  get(t, e = {}) {
+    let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, status: o } = e, h = this.#s.get(t);
+    if (h !== void 0) {
+      let r = this.#t[h], a = this.#e(r);
+      return o && this.#z(o, h), this.#p(h) ? (o && (o.get = "stale"), a ? (o && i && r.__staleWhileFetching !== void 0 && (o.returnedStale = true), i ? r.__staleWhileFetching : void 0) : (n || this.#E(t, "expire"), o && i && (o.returnedStale = true), i ? r : void 0)) : (o && (o.get = "hit"), a ? r.__staleWhileFetching : (this.#D(h), s && this.#R(h), r));
+    } else o && (o.get = "miss");
+  }
+  #k(t, e) {
+    this.#u[e] = t, this.#a[t] = e;
+  }
+  #D(t) {
+    t !== this.#h && (t === this.#l ? this.#l = this.#a[t] : this.#k(this.#u[t], this.#a[t]), this.#k(this.#h, t), this.#h = t);
+  }
+  delete(t) {
+    return this.#E(t, "delete");
+  }
+  #E(t, e) {
+    let i = false;
+    if (this.#n !== 0) {
+      let s = this.#s.get(t);
+      if (s !== void 0) if (this.#g?.[s] && (clearTimeout(this.#g?.[s]), this.#g[s] = void 0), i = true, this.#n === 1) this.#V(e);
+      else {
+        this.#W(s);
+        let n = this.#t[s];
+        if (this.#e(n) ? n.__abortController.abort(new Error("deleted")) : (this.#T || this.#f) && (this.#T && this.#w?.(n, t, e), this.#f && this.#r?.push([n, t, e])), this.#s.delete(t), this.#i[s] = void 0, this.#t[s] = void 0, s === this.#h) this.#h = this.#u[s];
+        else if (s === this.#l) this.#l = this.#a[s];
+        else {
+          let o = this.#u[s];
+          this.#a[o] = this.#a[s];
+          let h = this.#a[s];
+          this.#u[h] = this.#u[s];
+        }
+        this.#n--, this.#b.push(s);
+      }
+    }
+    if (this.#f && this.#r?.length) {
+      let s = this.#r, n;
+      for (; n = s?.shift(); ) this.#S?.(...n);
+    }
+    return i;
+  }
+  clear() {
+    return this.#V("delete");
+  }
+  #V(t) {
+    for (let e of this.#O({ allowStale: true })) {
+      let i = this.#t[e];
+      if (this.#e(i)) i.__abortController.abort(new Error("deleted"));
+      else {
+        let s = this.#i[e];
+        this.#T && this.#w?.(i, s, t), this.#f && this.#r?.push([i, s, t]);
+      }
+    }
+    if (this.#s.clear(), this.#t.fill(void 0), this.#i.fill(void 0), this.#d && this.#A) {
+      this.#d.fill(0), this.#A.fill(0);
+      for (let e of this.#g ?? []) e !== void 0 && clearTimeout(e);
+      this.#g?.fill(void 0);
+    }
+    if (this.#y && this.#y.fill(0), this.#l = 0, this.#h = 0, this.#b.length = 0, this.#_ = 0, this.#n = 0, this.#f && this.#r) {
+      let e = this.#r, i;
+      for (; i = e?.shift(); ) this.#S?.(...i);
+    }
+  }
+};
+const MAX_CONFLATION_CACHE_KEYS = 2e3;
 class ChannelState {
   constructor(channelName) {
     this.channelName = channelName;
     this.conflationKey = null;
     this.maxMessagesPerKey = 30;
-    this.conflationCaches = /* @__PURE__ */ new Map();
+    this.conflationCaches = new L({
+      max: MAX_CONFLATION_CACHE_KEYS
+    });
     this.baseMessage = null;
     this.baseSequence = null;
     this.lastSequence = null;
@@ -4322,7 +4861,7 @@ class ChannelState {
       return this.baseMessage;
     }
     const key = conflationKeyValue || "";
-    const cache = this.conflationCaches.get(key);
+    const cache = this.conflationCaches.peek(key);
     if (!cache || baseIndex === void 0) {
       console.error("[ChannelState] No cache or baseIndex undefined", {
         hasCache: !!cache,
@@ -4342,6 +4881,7 @@ class ChannelState {
       });
       return null;
     }
+    this.conflationCaches.get(key);
     return message.content;
   }
   /**
@@ -4349,10 +4889,9 @@ class ChannelState {
    */
   updateConflationCache(conflationKeyValue, message, sequence) {
     const key = conflationKeyValue || "";
-    let cache = this.conflationCaches.get(key);
+    let cache = this.conflationCaches.peek(key);
     if (!cache) {
       cache = [];
-      this.conflationCaches.set(key, cache);
     }
     if (cache.length > 0) {
       const lastCacheItem = cache[cache.length - 1];
@@ -4364,6 +4903,7 @@ class ChannelState {
     while (cache.length > this.maxMessagesPerKey) {
       cache.shift();
     }
+    this.conflationCaches.set(key, cache);
   }
   /**
    * Check if we have a valid base
@@ -4415,8 +4955,8 @@ class ChannelState {
     };
   }
 }
-const zDigits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~".split("").map(function(x) {
-  return x.charCodeAt(0);
+const zDigits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~".split("").map(function(x2) {
+  return x2.charCodeAt(0);
 });
 const zValue = [
   -1,
@@ -4571,9 +5111,9 @@ class Reader {
   // Read base64-encoded unsigned integer.
   getInt() {
     let v = 0;
-    let c;
-    while (this.haveBytes() && (c = zValue[127 & this.getByte()]) >= 0) {
-      v = (v << 6) + c;
+    let c3;
+    while (this.haveBytes() && (c3 = zValue[127 & this.getByte()]) >= 0) {
+      v = (v << 6) + c3;
     }
     this.pos--;
     return v >>> 0;
@@ -4616,45 +5156,45 @@ class Writer {
   }
 }
 function checksum(arr) {
-  let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0, z = 0, N = arr.length;
+  let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0, z2 = 0, N = arr.length;
   while (N >= 16) {
-    sum0 = sum0 + arr[z + 0] | 0;
-    sum1 = sum1 + arr[z + 1] | 0;
-    sum2 = sum2 + arr[z + 2] | 0;
-    sum3 = sum3 + arr[z + 3] | 0;
-    sum0 = sum0 + arr[z + 4] | 0;
-    sum1 = sum1 + arr[z + 5] | 0;
-    sum2 = sum2 + arr[z + 6] | 0;
-    sum3 = sum3 + arr[z + 7] | 0;
-    sum0 = sum0 + arr[z + 8] | 0;
-    sum1 = sum1 + arr[z + 9] | 0;
-    sum2 = sum2 + arr[z + 10] | 0;
-    sum3 = sum3 + arr[z + 11] | 0;
-    sum0 = sum0 + arr[z + 12] | 0;
-    sum1 = sum1 + arr[z + 13] | 0;
-    sum2 = sum2 + arr[z + 14] | 0;
-    sum3 = sum3 + arr[z + 15] | 0;
-    z += 16;
+    sum0 = sum0 + arr[z2 + 0] | 0;
+    sum1 = sum1 + arr[z2 + 1] | 0;
+    sum2 = sum2 + arr[z2 + 2] | 0;
+    sum3 = sum3 + arr[z2 + 3] | 0;
+    sum0 = sum0 + arr[z2 + 4] | 0;
+    sum1 = sum1 + arr[z2 + 5] | 0;
+    sum2 = sum2 + arr[z2 + 6] | 0;
+    sum3 = sum3 + arr[z2 + 7] | 0;
+    sum0 = sum0 + arr[z2 + 8] | 0;
+    sum1 = sum1 + arr[z2 + 9] | 0;
+    sum2 = sum2 + arr[z2 + 10] | 0;
+    sum3 = sum3 + arr[z2 + 11] | 0;
+    sum0 = sum0 + arr[z2 + 12] | 0;
+    sum1 = sum1 + arr[z2 + 13] | 0;
+    sum2 = sum2 + arr[z2 + 14] | 0;
+    sum3 = sum3 + arr[z2 + 15] | 0;
+    z2 += 16;
     N -= 16;
   }
   while (N >= 4) {
-    sum0 = sum0 + arr[z + 0] | 0;
-    sum1 = sum1 + arr[z + 1] | 0;
-    sum2 = sum2 + arr[z + 2] | 0;
-    sum3 = sum3 + arr[z + 3] | 0;
-    z += 4;
+    sum0 = sum0 + arr[z2 + 0] | 0;
+    sum1 = sum1 + arr[z2 + 1] | 0;
+    sum2 = sum2 + arr[z2 + 2] | 0;
+    sum3 = sum3 + arr[z2 + 3] | 0;
+    z2 += 4;
     N -= 4;
   }
   sum3 = ((sum3 + (sum2 << 8) | 0) + (sum1 << 16) | 0) + (sum0 << 24) | 0;
   switch (N) {
     case 3:
-      sum3 = sum3 + (arr[z + 2] << 8) | 0;
+      sum3 = sum3 + (arr[z2 + 2] << 8) | 0;
     /* falls through */
     case 2:
-      sum3 = sum3 + (arr[z + 1] << 16) | 0;
+      sum3 = sum3 + (arr[z2 + 1] << 16) | 0;
     /* falls through */
     case 1:
-      sum3 = sum3 + (arr[z + 0] << 24) | 0;
+      sum3 = sum3 + (arr[z2 + 0] << 24) | 0;
   }
   return sum3 >>> 0;
 }
@@ -5110,15 +5650,15 @@ class VCDiff {
   _buildTargetWindow(position, sourceSegment) {
     let window2 = delta(this.delta, position);
     let T = new Uint8Array(window2.targetWindowLength);
-    let U = new TypedArrayList();
+    let U2 = new TypedArrayList();
     let uTargetPosition = 0;
     if (sourceSegment) {
-      U.add(sourceSegment);
+      U2.add(sourceSegment);
       uTargetPosition = sourceSegment.length;
     }
-    U.add(T);
+    U2.add(T);
     this.source.length;
-    let delta$1 = new Delta(U, uTargetPosition, window2.data, window2.addresses);
+    let delta$1 = new Delta(U2, uTargetPosition, window2.data, window2.addresses);
     window2.instructions.forEach((instruction) => {
       instruction.execute(delta$1);
     });
@@ -5126,8 +5666,8 @@ class VCDiff {
   }
 }
 class Delta {
-  constructor(U, UTargetPosition, data, addresses) {
-    this.U = U;
+  constructor(U2, UTargetPosition, data, addresses) {
+    this.U = U2;
     this.UTargetPosition = UTargetPosition;
     this.data = data;
     this.dataPosition = 0;