bmlt-query-client 1.0.3 → 1.0.5

package/dist/app.js

@@ -1,463 +1,411 @@
-var Ie = Object.defineProperty;
-var ue = (r) => {
+var De = Object.defineProperty;
+var be = (r) => {
   throw TypeError(r);
 };
-var Ce = (r, e, t) => e in r ? Ie(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
-var ce = (r, e, t) => Ce(r, typeof e != "symbol" ? e + "" : e, t), te = (r, e, t) => e.has(r) || ue("Cannot " + t);
-var l = (r, e, t) => (te(r, e, "read from private field"), t ? t.call(r) : e.get(r)), T = (r, e, t) => e.has(r) ? ue("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(r) : e.set(r, t), v = (r, e, t, i) => (te(r, e, "write to private field"), i ? i.call(r, t) : e.set(r, t), t), S = (r, e, t) => (te(r, e, "access private method"), t);
+var $e = (r, e, t) => e in r ? De(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var R = (r, e, t) => $e(r, typeof e != "symbol" ? e + "" : e, t), me = (r, e, t) => e.has(r) || be("Cannot " + t);
+var n = (r, e, t) => (me(r, e, "read from private field"), t ? t.call(r) : e.get(r)), p = (r, e, t) => e.has(r) ? be("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(r) : e.set(r, t), w = (r, e, t, i) => (me(r, e, "write to private field"), i ? i.call(r, t) : e.set(r, t), t), m = (r, e, t) => (me(r, e, "access private method"), t);
 var H = (r, e, t, i) => ({
-  set _(n) {
-    v(r, e, n, t);
+  set _(s) {
+    w(r, e, s, t);
   },
   get _() {
-    return l(r, e, i);
+    return n(r, e, i);
   }
 });
-function ve(r) {
-  return r && r.__esModule && Object.prototype.hasOwnProperty.call(r, "default") ? r.default : r;
-}
-var re = {}, ie, he;
-function Pe() {
-  if (he) return ie;
-  he = 1;
-  function r(e, t) {
-    typeof t == "boolean" && (t = { forever: t }), this._originalTimeouts = JSON.parse(JSON.stringify(e)), this._timeouts = e, this._options = t || {}, this._maxRetryTime = t && t.maxRetryTime || 1 / 0, this._fn = null, this._errors = [], this._attempts = 1, this._operationTimeout = null, this._operationTimeoutCb = null, this._timeout = null, this._operationStart = null, this._timer = null, this._options.forever && (this._cachedTimeouts = this._timeouts.slice(0));
-  }
-  return ie = r, r.prototype.reset = function() {
-    this._attempts = 1, this._timeouts = this._originalTimeouts.slice(0);
-  }, r.prototype.stop = function() {
-    this._timeout && clearTimeout(this._timeout), this._timer && clearTimeout(this._timer), this._timeouts = [], this._cachedTimeouts = null;
-  }, r.prototype.retry = function(e) {
-    if (this._timeout && clearTimeout(this._timeout), !e)
-      return !1;
-    var t = (/* @__PURE__ */ new Date()).getTime();
-    if (e && t - this._operationStart >= this._maxRetryTime)
-      return this._errors.push(e), this._errors.unshift(new Error("RetryOperation timeout occurred")), !1;
-    this._errors.push(e);
-    var i = this._timeouts.shift();
-    if (i === void 0)
-      if (this._cachedTimeouts)
-        this._errors.splice(0, this._errors.length - 1), i = this._cachedTimeouts.slice(-1);
-      else
-        return !1;
-    var n = this;
-    return this._timer = setTimeout(function() {
-      n._attempts++, n._operationTimeoutCb && (n._timeout = setTimeout(function() {
-        n._operationTimeoutCb(n._attempts);
-      }, n._operationTimeout), n._options.unref && n._timeout.unref()), n._fn(n._attempts);
-    }, i), this._options.unref && this._timer.unref(), !0;
-  }, r.prototype.attempt = function(e, t) {
-    this._fn = e, t && (t.timeout && (this._operationTimeout = t.timeout), t.cb && (this._operationTimeoutCb = t.cb));
-    var i = this;
-    this._operationTimeoutCb && (this._timeout = setTimeout(function() {
-      i._operationTimeoutCb();
-    }, i._operationTimeout)), this._operationStart = (/* @__PURE__ */ new Date()).getTime(), this._fn(this._attempts);
-  }, r.prototype.try = function(e) {
-    console.log("Using RetryOperation.try() is deprecated"), this.attempt(e);
-  }, r.prototype.start = function(e) {
-    console.log("Using RetryOperation.start() is deprecated"), this.attempt(e);
-  }, r.prototype.start = r.prototype.try, r.prototype.errors = function() {
-    return this._errors;
-  }, r.prototype.attempts = function() {
-    return this._attempts;
-  }, r.prototype.mainError = function() {
-    if (this._errors.length === 0)
-      return null;
-    for (var e = {}, t = null, i = 0, n = 0; n < this._errors.length; n++) {
-      var a = this._errors[n], s = a.message, o = (e[s] || 0) + 1;
-      e[s] = o, o >= i && (t = a, i = o);
-    }
-    return t;
-  }, ie;
-}
-var le;
-function Ge() {
-  return le || (le = 1, (function(r) {
-    var e = Pe();
-    r.operation = function(t) {
-      var i = r.timeouts(t);
-      return new e(i, {
-        forever: t && (t.forever || t.retries === 1 / 0),
-        unref: t && t.unref,
-        maxRetryTime: t && t.maxRetryTime
-      });
-    }, r.timeouts = function(t) {
-      if (t instanceof Array)
-        return [].concat(t);
-      var i = {
-        retries: 10,
-        factor: 2,
-        minTimeout: 1 * 1e3,
-        maxTimeout: 1 / 0,
-        randomize: !1
-      };
-      for (var n in t)
-        i[n] = t[n];
-      if (i.minTimeout > i.maxTimeout)
-        throw new Error("minTimeout is greater than maxTimeout");
-      for (var a = [], s = 0; s < i.retries; s++)
-        a.push(this.createTimeout(s, i));
-      return t && t.forever && !a.length && a.push(this.createTimeout(s, i)), a.sort(function(o, u) {
-        return o - u;
-      }), a;
-    }, r.createTimeout = function(t, i) {
-      var n = i.randomize ? Math.random() + 1 : 1, a = Math.round(n * Math.max(i.minTimeout, 1) * Math.pow(i.factor, t));
-      return a = Math.min(a, i.maxTimeout), a;
-    }, r.wrap = function(t, i, n) {
-      if (i instanceof Array && (n = i, i = null), !n) {
-        n = [];
-        for (var a in t)
-          typeof t[a] == "function" && n.push(a);
-      }
-      for (var s = 0; s < n.length; s++) {
-        var o = n[s], u = t[o];
-        t[o] = function(h) {
-          var f = r.operation(i), p = Array.prototype.slice.call(arguments, 1), E = p.pop();
-          p.push(function(y) {
-            f.retry(y) || (y && (arguments[0] = f.mainError()), E.apply(this, arguments));
-          }), f.attempt(function() {
-            h.apply(t, p);
-          });
-        }.bind(t, u), t[o].options = i;
-      }
-    };
-  })(re)), re;
-}
-var ne, fe;
-function Le() {
-  return fe || (fe = 1, ne = Ge()), ne;
-}
-var Ue = Le();
-const xe = /* @__PURE__ */ ve(Ue), De = Object.prototype.toString, Fe = (r) => De.call(r) === "[object Error]", ke = /* @__PURE__ */ new Set([
+const Me = Object.prototype.toString, qe = (r) => Me.call(r) === "[object Error]", Ve = /* @__PURE__ */ new Set([
   "network error",
   // Chrome
-  "Failed to fetch",
-  // Chrome
   "NetworkError when attempting to fetch resource.",
   // Firefox
   "The Internet connection appears to be offline.",
   // Safari 16
-  "Load failed",
-  // Safari 17+
   "Network request failed",
   // `cross-fetch`
   "fetch failed",
   // Undici (Node.js)
-  "terminated"
+  "terminated",
   // Undici (Node.js)
+  " A network error occurred.",
+  // Bun (WebKit)
+  "Network connection lost"
+  // Cloudflare Workers (fetch)
 ]);
-function $e(r) {
-  return r && Fe(r) && r.name === "TypeError" && typeof r.message == "string" ? r.message === "Load failed" ? r.stack === void 0 : ke.has(r.message) : !1;
+function Ye(r) {
+  if (!(r && qe(r) && r.name === "TypeError" && typeof r.message == "string"))
+    return !1;
+  const { message: t, stack: i } = r;
+  return t === "Load failed" ? i === void 0 || "__sentry_captured__" in r : t.startsWith("error sending request for url") || t === "Failed to fetch" || t.startsWith("Failed to fetch (") && t.endsWith(")") ? !0 : Ve.has(t);
+}
+function ze(r) {
+  if (typeof r == "number") {
+    if (r < 0)
+      throw new TypeError("Expected `retries` to be a non-negative number.");
+    if (Number.isNaN(r))
+      throw new TypeError("Expected `retries` to be a valid number or Infinity, got NaN.");
+  } else if (r !== void 0)
+    throw new TypeError("Expected `retries` to be a number or Infinity.");
 }
-let Me = class extends Error {
+function ne(r, e, { min: t = 0, allowInfinity: i = !1 } = {}) {
+  if (e !== void 0) {
+    if (typeof e != "number" || Number.isNaN(e))
+      throw new TypeError(`Expected \`${r}\` to be a number${i ? " or Infinity" : ""}.`);
+    if (!i && !Number.isFinite(e))
+      throw new TypeError(`Expected \`${r}\` to be a finite number.`);
+    if (e < t)
+      throw new TypeError(`Expected \`${r}\` to be ≥ ${t}.`);
+  }
+}
+class He extends Error {
   constructor(e) {
     super(), e instanceof Error ? (this.originalError = e, { message: e } = e) : (this.originalError = new Error(e), this.originalError.stack = this.stack), this.name = "AbortError", this.message = e;
   }
-};
-const de = (r, e, t) => {
-  const i = t.retries - (e - 1);
-  return r.attemptNumber = e, r.retriesLeft = i, r;
-};
-async function me(r, e) {
-  return new Promise((t, i) => {
-    e = { ...e }, e.onFailedAttempt ?? (e.onFailedAttempt = () => {
-    }), e.shouldRetry ?? (e.shouldRetry = () => !0), e.retries ?? (e.retries = 10);
-    const n = xe.operation(e), a = () => {
-      n.stop(), i(e.signal?.reason);
-    };
-    e.signal && !e.signal.aborted && e.signal.addEventListener("abort", a, { once: !0 });
-    const s = () => {
-      e.signal?.removeEventListener("abort", a), n.stop();
-    };
-    n.attempt(async (o) => {
-      try {
-        const u = await r(o);
-        s(), t(u);
-      } catch (u) {
-        try {
-          if (!(u instanceof Error))
-            throw new TypeError(`Non-error was thrown: "${u}". You should only throw errors.`);
-          if (u instanceof Me)
-            throw u.originalError;
-          if (u instanceof TypeError && !$e(u))
-            throw u;
-          if (de(u, o, e), await e.shouldRetry(u) || (n.stop(), i(u)), await e.onFailedAttempt(u), !n.retry(u))
-            throw n.mainError();
-        } catch (c) {
-          de(c, o, e), s(), i(c);
-        }
-      }
-    });
+}
+function Je(r, e) {
+  const t = Math.max(1, r + 1), i = e.randomize ? Math.random() + 1 : 1;
+  let s = Math.round(i * e.minTimeout * e.factor ** (t - 1));
+  return s = Math.min(s, e.maxTimeout), s;
+}
+function Te(r, e) {
+  return Number.isFinite(e) ? e - (performance.now() - r) : e;
+}
+async function je({ error: r, attemptNumber: e, retriesConsumed: t, startTime: i, options: s }) {
+  const a = r instanceof Error ? r : new TypeError(`Non-error was thrown: "${r}". You should only throw errors.`);
+  if (a instanceof He)
+    throw a.originalError;
+  const c = Number.isFinite(s.retries) ? Math.max(0, s.retries - t) : s.retries, u = s.maxRetryTime ?? Number.POSITIVE_INFINITY, o = Object.freeze({
+    error: a,
+    attemptNumber: e,
+    retriesLeft: c,
+    retriesConsumed: t
   });
+  if (await s.onFailedAttempt(o), Te(i, u) <= 0)
+    throw a;
+  const l = await s.shouldConsumeRetry(o), d = Te(i, u);
+  if (d <= 0 || c <= 0)
+    throw a;
+  if (a instanceof TypeError && !Ye(a)) {
+    if (l)
+      throw a;
+    return s.signal?.throwIfAborted(), !1;
+  }
+  if (!await s.shouldRetry(o))
+    throw a;
+  if (!l)
+    return s.signal?.throwIfAborted(), !1;
+  const f = Je(t, s), g = Math.min(f, d);
+  return s.signal?.throwIfAborted(), g > 0 && await new Promise((b, y) => {
+    const O = () => {
+      clearTimeout(E), s.signal?.removeEventListener("abort", O), y(s.signal.reason);
+    }, E = setTimeout(() => {
+      s.signal?.removeEventListener("abort", O), b();
+    }, g);
+    s.unref && E.unref?.(), s.signal?.addEventListener("abort", O, { once: !0 });
+  }), s.signal?.throwIfAborted(), !0;
+}
+async function Se(r, e = {}) {
+  if (e = { ...e }, ze(e.retries), Object.hasOwn(e, "forever"))
+    throw new Error("The `forever` option is no longer supported. For many use-cases, you can set `retries: Infinity` instead.");
+  e.retries ?? (e.retries = 10), e.factor ?? (e.factor = 2), e.minTimeout ?? (e.minTimeout = 1e3), e.maxTimeout ?? (e.maxTimeout = Number.POSITIVE_INFINITY), e.maxRetryTime ?? (e.maxRetryTime = Number.POSITIVE_INFINITY), e.randomize ?? (e.randomize = !1), e.onFailedAttempt ?? (e.onFailedAttempt = () => {
+  }), e.shouldRetry ?? (e.shouldRetry = () => !0), e.shouldConsumeRetry ?? (e.shouldConsumeRetry = () => !0), ne("factor", e.factor, { min: 0, allowInfinity: !1 }), ne("minTimeout", e.minTimeout, { min: 0, allowInfinity: !1 }), ne("maxTimeout", e.maxTimeout, { min: 0, allowInfinity: !0 }), ne("maxRetryTime", e.maxRetryTime, { min: 0, allowInfinity: !0 }), e.factor > 0 || (e.factor = 1), e.signal?.throwIfAborted();
+  let t = 0, i = 0;
+  const s = performance.now();
+  for (; !Number.isFinite(e.retries) || i <= e.retries; ) {
+    t++;
+    try {
+      e.signal?.throwIfAborted();
+      const a = await r(t);
+      return e.signal?.throwIfAborted(), a;
+    } catch (a) {
+      await je({
+        error: a,
+        attemptNumber: t,
+        retriesConsumed: i,
+        startTime: s,
+        options: e
+      }) && i++;
+    }
+  }
+  throw new Error("Retry attempts exhausted without throwing an error.");
 }
-var se = { exports: {} }, Ee;
-function qe() {
-  return Ee || (Ee = 1, (function(r) {
+function We(r) {
+  return r && r.__esModule && Object.prototype.hasOwnProperty.call(r, "default") ? r.default : r;
+}
+var Ee = { exports: {} }, Re;
+function Be() {
+  return Re || (Re = 1, (function(r) {
     var e = Object.prototype.hasOwnProperty, t = "~";
     function i() {
     }
     Object.create && (i.prototype = /* @__PURE__ */ Object.create(null), new i().__proto__ || (t = !1));
-    function n(u, c, h) {
-      this.fn = u, this.context = c, this.once = h || !1;
+    function s(o, l, d) {
+      this.fn = o, this.context = l, this.once = d || !1;
     }
-    function a(u, c, h, f, p) {
-      if (typeof h != "function")
+    function a(o, l, d, f, g) {
+      if (typeof d != "function")
         throw new TypeError("The listener must be a function");
-      var E = new n(h, f || u, p), y = t ? t + c : c;
-      return u._events[y] ? u._events[y].fn ? u._events[y] = [u._events[y], E] : u._events[y].push(E) : (u._events[y] = E, u._eventsCount++), u;
+      var b = new s(d, f || o, g), y = t ? t + l : l;
+      return o._events[y] ? o._events[y].fn ? o._events[y] = [o._events[y], b] : o._events[y].push(b) : (o._events[y] = b, o._eventsCount++), o;
     }
-    function s(u, c) {
-      --u._eventsCount === 0 ? u._events = new i() : delete u._events[c];
+    function c(o, l) {
+      --o._eventsCount === 0 ? o._events = new i() : delete o._events[l];
     }
-    function o() {
+    function u() {
       this._events = new i(), this._eventsCount = 0;
     }
-    o.prototype.eventNames = function() {
-      var c = [], h, f;
-      if (this._eventsCount === 0) return c;
-      for (f in h = this._events)
-        e.call(h, f) && c.push(t ? f.slice(1) : f);
-      return Object.getOwnPropertySymbols ? c.concat(Object.getOwnPropertySymbols(h)) : c;
-    }, o.prototype.listeners = function(c) {
-      var h = t ? t + c : c, f = this._events[h];
+    u.prototype.eventNames = function() {
+      var l = [], d, f;
+      if (this._eventsCount === 0) return l;
+      for (f in d = this._events)
+        e.call(d, f) && l.push(t ? f.slice(1) : f);
+      return Object.getOwnPropertySymbols ? l.concat(Object.getOwnPropertySymbols(d)) : l;
+    }, u.prototype.listeners = function(l) {
+      var d = t ? t + l : l, f = this._events[d];
       if (!f) return [];
       if (f.fn) return [f.fn];
-      for (var p = 0, E = f.length, y = new Array(E); p < E; p++)
-        y[p] = f[p].fn;
+      for (var g = 0, b = f.length, y = new Array(b); g < b; g++)
+        y[g] = f[g].fn;
       return y;
-    }, o.prototype.listenerCount = function(c) {
-      var h = t ? t + c : c, f = this._events[h];
+    }, u.prototype.listenerCount = function(l) {
+      var d = t ? t + l : l, f = this._events[d];
       return f ? f.fn ? 1 : f.length : 0;
-    }, o.prototype.emit = function(c, h, f, p, E, y) {
-      var P = t ? t + c : c;
-      if (!this._events[P]) return !1;
-      var d = this._events[P], U = arguments.length, D, w;
-      if (d.fn) {
-        switch (d.once && this.removeListener(c, d.fn, void 0, !0), U) {
+    }, u.prototype.emit = function(l, d, f, g, b, y) {
+      var O = t ? t + l : l;
+      if (!this._events[O]) return !1;
+      var E = this._events[O], V = arguments.length, z, T;
+      if (E.fn) {
+        switch (E.once && this.removeListener(l, E.fn, void 0, !0), V) {
           case 1:
-            return d.fn.call(d.context), !0;
+            return E.fn.call(E.context), !0;
           case 2:
-            return d.fn.call(d.context, h), !0;
+            return E.fn.call(E.context, d), !0;
           case 3:
-            return d.fn.call(d.context, h, f), !0;
+            return E.fn.call(E.context, d, f), !0;
           case 4:
-            return d.fn.call(d.context, h, f, p), !0;
+            return E.fn.call(E.context, d, f, g), !0;
           case 5:
-            return d.fn.call(d.context, h, f, p, E), !0;
+            return E.fn.call(E.context, d, f, g, b), !0;
           case 6:
-            return d.fn.call(d.context, h, f, p, E, y), !0;
+            return E.fn.call(E.context, d, f, g, b, y), !0;
         }
-        for (w = 1, D = new Array(U - 1); w < U; w++)
-          D[w - 1] = arguments[w];
-        d.fn.apply(d.context, D);
+        for (T = 1, z = new Array(V - 1); T < V; T++)
+          z[T - 1] = arguments[T];
+        E.fn.apply(E.context, z);
       } else {
-        var Oe = d.length, Y;
-        for (w = 0; w < Oe; w++)
-          switch (d[w].once && this.removeListener(c, d[w].fn, void 0, !0), U) {
+        var Ue = E.length, te;
+        for (T = 0; T < Ue; T++)
+          switch (E[T].once && this.removeListener(l, E[T].fn, void 0, !0), V) {
             case 1:
-              d[w].fn.call(d[w].context);
+              E[T].fn.call(E[T].context);
               break;
             case 2:
-              d[w].fn.call(d[w].context, h);
+              E[T].fn.call(E[T].context, d);
               break;
             case 3:
-              d[w].fn.call(d[w].context, h, f);
+              E[T].fn.call(E[T].context, d, f);
               break;
             case 4:
-              d[w].fn.call(d[w].context, h, f, p);
+              E[T].fn.call(E[T].context, d, f, g);
               break;
             default:
-              if (!D) for (Y = 1, D = new Array(U - 1); Y < U; Y++)
-                D[Y - 1] = arguments[Y];
-              d[w].fn.apply(d[w].context, D);
+              if (!z) for (te = 1, z = new Array(V - 1); te < V; te++)
+                z[te - 1] = arguments[te];
+              E[T].fn.apply(E[T].context, z);
           }
       }
       return !0;
-    }, o.prototype.on = function(c, h, f) {
-      return a(this, c, h, f, !1);
-    }, o.prototype.once = function(c, h, f) {
-      return a(this, c, h, f, !0);
-    }, o.prototype.removeListener = function(c, h, f, p) {
-      var E = t ? t + c : c;
-      if (!this._events[E]) return this;
-      if (!h)
-        return s(this, E), this;
-      var y = this._events[E];
+    }, u.prototype.on = function(l, d, f) {
+      return a(this, l, d, f, !1);
+    }, u.prototype.once = function(l, d, f) {
+      return a(this, l, d, f, !0);
+    }, u.prototype.removeListener = function(l, d, f, g) {
+      var b = t ? t + l : l;
+      if (!this._events[b]) return this;
+      if (!d)
+        return c(this, b), this;
+      var y = this._events[b];
       if (y.fn)
-        y.fn === h && (!p || y.once) && (!f || y.context === f) && s(this, E);
+        y.fn === d && (!g || y.once) && (!f || y.context === f) && c(this, b);
       else {
-        for (var P = 0, d = [], U = y.length; P < U; P++)
-          (y[P].fn !== h || p && !y[P].once || f && y[P].context !== f) && d.push(y[P]);
-        d.length ? this._events[E] = d.length === 1 ? d[0] : d : s(this, E);
+        for (var O = 0, E = [], V = y.length; O < V; O++)
+          (y[O].fn !== d || g && !y[O].once || f && y[O].context !== f) && E.push(y[O]);
+        E.length ? this._events[b] = E.length === 1 ? E[0] : E : c(this, b);
       }
       return this;
-    }, o.prototype.removeAllListeners = function(c) {
-      var h;
-      return c ? (h = t ? t + c : c, this._events[h] && s(this, h)) : (this._events = new i(), this._eventsCount = 0), this;
-    }, o.prototype.off = o.prototype.removeListener, o.prototype.addListener = o.prototype.on, o.prefixed = t, o.EventEmitter = o, r.exports = o;
-  })(se)), se.exports;
+    }, u.prototype.removeAllListeners = function(l) {
+      var d;
+      return l ? (d = t ? t + l : l, this._events[d] && c(this, d)) : (this._events = new i(), this._eventsCount = 0), this;
+    }, u.prototype.off = u.prototype.removeListener, u.prototype.addListener = u.prototype.on, u.prefixed = t, u.EventEmitter = u, r.exports = u;
+  })(Ee)), Ee.exports;
 }
-var Ve = qe();
-const Ye = /* @__PURE__ */ ve(Ve);
-class we extends Error {
-  constructor(e) {
-    super(e), this.name = "TimeoutError";
+var Qe = Be();
+const Ke = /* @__PURE__ */ We(Qe);
+class pe extends Error {
+  constructor(t, i) {
+    super(t, i);
+    R(this, "name", "TimeoutError");
+    Error.captureStackTrace?.(this, pe);
   }
 }
-class He extends Error {
-  constructor(e) {
-    super(), this.name = "AbortError", this.message = e;
-  }
-}
-const pe = (r) => globalThis.DOMException === void 0 ? new He(r) : new DOMException(r), ge = (r) => {
-  const e = r.reason === void 0 ? pe("This operation was aborted.") : r.reason;
-  return e instanceof Error ? e : pe(e);
-};
-function Je(r, e) {
+const _e = (r) => r.reason ?? new DOMException("This operation was aborted.", "AbortError");
+function Ze(r, e) {
   const {
     milliseconds: t,
     fallback: i,
-    message: n,
-    customTimers: a = { setTimeout, clearTimeout }
+    message: s,
+    customTimers: a = { setTimeout, clearTimeout },
+    signal: c
   } = e;
-  let s, o;
-  const c = new Promise((h, f) => {
+  let u, o;
+  const d = new Promise((f, g) => {
     if (typeof t != "number" || Math.sign(t) !== 1)
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${t}\``);
-    if (e.signal) {
-      const { signal: E } = e;
-      E.aborted && f(ge(E)), o = () => {
-        f(ge(E));
-      }, E.addEventListener("abort", o, { once: !0 });
-    }
-    if (t === Number.POSITIVE_INFINITY) {
-      r.then(h, f);
+    if (c?.aborted) {
+      g(_e(c));
       return;
     }
-    const p = new we();
-    s = a.setTimeout.call(void 0, () => {
+    if (c && (o = () => {
+      g(_e(c));
+    }, c.addEventListener("abort", o, { once: !0 })), r.then(f, g), t === Number.POSITIVE_INFINITY)
+      return;
+    const b = new pe();
+    u = a.setTimeout.call(void 0, () => {
       if (i) {
         try {
-          h(i());
-        } catch (E) {
-          f(E);
+          f(i());
+        } catch (y) {
+          g(y);
         }
         return;
       }
-      typeof r.cancel == "function" && r.cancel(), n === !1 ? h() : n instanceof Error ? f(n) : (p.message = n ?? `Promise timed out after ${t} milliseconds`, f(p));
-    }, t), (async () => {
-      try {
-        h(await r);
-      } catch (E) {
-        f(E);
-      }
-    })();
+      typeof r.cancel == "function" && r.cancel(), s === !1 ? f() : s instanceof Error ? g(s) : (b.message = s ?? `Promise timed out after ${t} milliseconds`, g(b));
+    }, t);
   }).finally(() => {
-    c.clear(), o && e.signal && e.signal.removeEventListener("abort", o);
+    d.clear(), o && c && c.removeEventListener("abort", o);
   });
-  return c.clear = () => {
-    a.clearTimeout.call(void 0, s), s = void 0;
-  }, c;
+  return d.clear = () => {
+    a.clearTimeout.call(void 0, u), u = void 0;
+  }, d;
 }
-function ze(r, e, t) {
-  let i = 0, n = r.length;
-  for (; n > 0; ) {
-    const a = Math.trunc(n / 2);
-    let s = i + a;
-    t(r[s], e) <= 0 ? (i = ++s, n -= a + 1) : n = a;
+function Xe(r, e, t) {
+  let i = 0, s = r.length;
+  for (; s > 0; ) {
+    const a = Math.trunc(s / 2);
+    let c = i + a;
+    t(r[c], e) <= 0 ? (i = ++c, s -= a + 1) : s = a;
   }
   return i;
 }
-var A;
-class We {
+var L;
+class et {
   constructor() {
-    T(this, A, []);
+    p(this, L, []);
   }
   enqueue(e, t) {
-    t = {
-      priority: 0,
-      ...t
-    };
-    const i = {
-      priority: t.priority,
-      id: t.id,
+    const { priority: i = 0, id: s } = t ?? {}, a = {
+      priority: i,
+      id: s,
       run: e
     };
-    if (this.size === 0 || l(this, A)[this.size - 1].priority >= t.priority) {
-      l(this, A).push(i);
+    if (this.size === 0 || n(this, L)[this.size - 1].priority >= i) {
+      n(this, L).push(a);
       return;
     }
-    const n = ze(l(this, A), i, (a, s) => s.priority - a.priority);
-    l(this, A).splice(n, 0, i);
+    const c = Xe(n(this, L), a, (u, o) => o.priority - u.priority);
+    n(this, L).splice(c, 0, a);
   }
   setPriority(e, t) {
-    const i = l(this, A).findIndex((a) => a.id === e);
+    const i = n(this, L).findIndex((a) => a.id === e);
     if (i === -1)
       throw new ReferenceError(`No promise function with the id "${e}" exists in the queue.`);
-    const [n] = l(this, A).splice(i, 1);
-    this.enqueue(n.run, { priority: t, id: e });
+    const [s] = n(this, L).splice(i, 1);
+    this.enqueue(s.run, { priority: t, id: e });
   }
   dequeue() {
-    return l(this, A).shift()?.run;
+    return n(this, L).shift()?.run;
   }
   filter(e) {
-    return l(this, A).filter((t) => t.priority === e.priority).map((t) => t.run);
+    return n(this, L).filter((t) => t.priority === e.priority).map((t) => t.run);
   }
   get size() {
-    return l(this, A).length;
+    return n(this, L).length;
   }
 }
-A = new WeakMap();
-var k, $, x, z, M, W, N, q, R, Q, O, V, L, j, ee, m, _e, Te, Se, Re, be, K, oe, ae, X, Ae, Z;
-class Qe extends Ye {
-  // TODO: The `throwOnTimeout` option should affect the return types of `add()` and `addAll()`
+L = new WeakMap();
+var Z, x, k, Y, j, X, U, ie, ee, D, M, P, I, N, S, se, A, W, q, fe, B, h, oe, Ne, Ie, ue, Oe, Ce, Le, Pe, xe, ce, he, ge, le, we, ye, de, J, ke, Q, Ge, ve;
+class tt extends Ke {
   constructor(t) {
     super();
-    T(this, m);
-    T(this, k);
-    T(this, $);
-    T(this, x, 0);
-    T(this, z);
-    T(this, M);
-    T(this, W, 0);
-    T(this, N);
-    T(this, q);
-    T(this, R);
-    T(this, Q);
-    T(this, O, 0);
+    p(this, h);
+    p(this, Z);
+    p(this, x);
+    p(this, k, 0);
+    p(this, Y);
+    p(this, j, !1);
+    p(this, X, !1);
+    p(this, U);
+    p(this, ie, 0);
+    p(this, ee, 0);
+    p(this, D);
+    p(this, M);
+    p(this, P);
+    // Circular buffer implementation for better performance
+    p(this, I, []);
+    p(this, N, 0);
+    p(this, S);
+    p(this, se);
+    p(this, A, 0);
     // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
-    T(this, V);
-    T(this, L);
-    T(this, j);
+    p(this, W);
+    p(this, q);
     // Use to assign a unique identifier to a promise function, if not explicitly specified
-    T(this, ee, 1n);
+    p(this, fe, 1n);
+    // Track currently running tasks for debugging
+    p(this, B, /* @__PURE__ */ new Map());
     /**
-        Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
+        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.
     
-        Applies to each future operation.
+        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;
+        ```
         */
-    ce(this, "timeout");
+    R(this, "timeout");
     if (t = {
-      carryoverConcurrencyCount: !1,
+      carryoverIntervalCount: !1,
       intervalCap: Number.POSITIVE_INFINITY,
       interval: 0,
       concurrency: Number.POSITIVE_INFINITY,
       autoStart: !0,
-      queueClass: We,
+      queueClass: et,
+      strict: !1,
       ...t
     }, !(typeof t.intervalCap == "number" && t.intervalCap >= 1))
       throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${t.intervalCap?.toString() ?? ""}\` (${typeof t.intervalCap})`);
     if (t.interval === void 0 || !(Number.isFinite(t.interval) && t.interval >= 0))
       throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${t.interval?.toString() ?? ""}\` (${typeof t.interval})`);
-    v(this, k, t.carryoverConcurrencyCount), v(this, $, t.intervalCap === Number.POSITIVE_INFINITY || t.interval === 0), v(this, z, t.intervalCap), v(this, M, t.interval), v(this, R, new t.queueClass()), v(this, Q, t.queueClass), this.concurrency = t.concurrency, this.timeout = t.timeout, v(this, j, t.throwOnTimeout === !0), v(this, L, t.autoStart === !1);
+    if (t.strict && t.interval === 0)
+      throw new TypeError("The `strict` option requires a non-zero `interval`");
+    if (t.strict && t.intervalCap === Number.POSITIVE_INFINITY)
+      throw new TypeError("The `strict` option requires a finite `intervalCap`");
+    if (w(this, Z, t.carryoverIntervalCount ?? t.carryoverConcurrencyCount ?? !1), w(this, x, t.intervalCap === Number.POSITIVE_INFINITY || t.interval === 0), w(this, Y, t.intervalCap), w(this, U, t.interval), w(this, P, t.strict), w(this, S, new t.queueClass()), w(this, se, t.queueClass), this.concurrency = t.concurrency, t.timeout !== void 0 && !(Number.isFinite(t.timeout) && t.timeout > 0))
+      throw new TypeError(`Expected \`timeout\` to be a positive finite number, got \`${t.timeout}\` (${typeof t.timeout})`);
+    this.timeout = t.timeout, w(this, q, t.autoStart === !1), m(this, h, ke).call(this);
   }
   get concurrency() {
-    return l(this, V);
+    return n(this, W);
   }
   set concurrency(t) {
     if (!(typeof t == "number" && t >= 1))
       throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${t}\` (${typeof t})`);
-    v(this, V, t), S(this, m, X).call(this);
+    w(this, W, t), m(this, h, de).call(this);
   }
   /**
       Updates the priority of a promise function by its id, affecting its execution order. Requires a defined concurrency limit to take effect.
@@ -496,54 +444,78 @@ class Qe extends Ye {
       Here, the promise function with `id: '🦀'` executes last.
       */
   setPriority(t, i) {
-    l(this, R).setPriority(t, i);
+    if (typeof i != "number" || !Number.isFinite(i))
+      throw new TypeError(`Expected \`priority\` to be a finite number, got \`${i}\` (${typeof i})`);
+    n(this, S).setPriority(t, i);
   }
   async add(t, i = {}) {
-    return i.id ?? (i.id = (H(this, ee)._++).toString()), i = {
+    return i = {
       timeout: this.timeout,
-      throwOnTimeout: l(this, j),
-      ...i
-    }, new Promise((n, a) => {
-      l(this, R).enqueue(async () => {
-        H(this, O)._++, H(this, x)._++;
+      ...i,
+      // Assign unique ID if not provided
+      id: i.id ?? (H(this, fe)._++).toString()
+    }, new Promise((s, a) => {
+      const c = /* @__PURE__ */ Symbol(`task-${i.id}`);
+      n(this, S).enqueue(async () => {
+        H(this, A)._++, n(this, B).set(c, {
+          id: i.id,
+          priority: i.priority ?? 0,
+          // Match priority-queue default
+          startTime: Date.now(),
+          timeout: i.timeout
+        });
+        let u;
         try {
-          i.signal?.throwIfAborted();
-          let s = t({ signal: i.signal });
-          i.timeout && (s = Je(Promise.resolve(s), { milliseconds: i.timeout })), i.signal && (s = Promise.race([s, S(this, m, Ae).call(this, i.signal)]));
-          const o = await s;
-          n(o), this.emit("completed", o);
-        } catch (s) {
-          if (s instanceof we && !i.throwOnTimeout) {
-            n();
-            return;
+          try {
+            i.signal?.throwIfAborted();
+          } catch (d) {
+            throw m(this, h, Ge).call(this), n(this, B).delete(c), d;
           }
-          a(s), this.emit("error", s);
+          w(this, ee, Date.now());
+          let o = t({ signal: i.signal });
+          if (i.timeout && (o = Ze(Promise.resolve(o), {
+            milliseconds: i.timeout,
+            message: `Task timed out after ${i.timeout}ms (queue has ${n(this, A)} running, ${n(this, S).size} waiting)`
+          })), i.signal) {
+            const { signal: d } = i;
+            o = Promise.race([o, new Promise((f, g) => {
+              u = () => {
+                g(d.reason);
+              }, d.addEventListener("abort", u, { once: !0 });
+            })]);
+          }
+          const l = await o;
+          s(l), this.emit("completed", l);
+        } catch (o) {
+          a(o), this.emit("error", o);
         } finally {
-          S(this, m, Se).call(this);
+          u && i.signal?.removeEventListener("abort", u), n(this, B).delete(c), queueMicrotask(() => {
+            m(this, h, Le).call(this);
+          });
         }
-      }, i), this.emit("add"), S(this, m, K).call(this);
+      }, i), this.emit("add"), m(this, h, le).call(this);
     });
   }
   async addAll(t, i) {
-    return Promise.all(t.map(async (n) => this.add(n, i)));
+    return Promise.all(t.map(async (s) => this.add(s, i)));
   }
   /**
   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() {
-    return l(this, L) ? (v(this, L, !1), S(this, m, X).call(this), this) : this;
+    return n(this, q) ? (w(this, q, !1), m(this, h, de).call(this), this) : this;
   }
   /**
   Put queue execution on hold.
   */
   pause() {
-    v(this, L, !0);
+    w(this, q, !0);
   }
   /**
   Clear the queue.
   */
   clear() {
-    v(this, R, new (l(this, Q))());
+    w(this, S, new (n(this, se))()), m(this, h, he).call(this), m(this, h, ve).call(this), this.emit("empty"), n(this, A) === 0 && (m(this, h, ge).call(this), this.emit("idle")), this.emit("next");
   }
   /**
       Can be called multiple times. Useful if you for example add additional items at a later time.
@@ -551,7 +523,7 @@ class Qe extends Ye {
       @returns A promise that settles when the queue becomes empty.
       */
   async onEmpty() {
-    l(this, R).size !== 0 && await S(this, m, Z).call(this, "empty");
+    n(this, S).size !== 0 && await m(this, h, J).call(this, "empty");
   }
   /**
       @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
@@ -561,7 +533,7 @@ class Qe extends Ye {
       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(t) {
-    l(this, R).size < t || await S(this, m, Z).call(this, "next", () => l(this, R).size < t);
+    n(this, S).size < t || await m(this, h, J).call(this, "next", () => n(this, S).size < t);
   }
   /**
       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.
@@ -569,13 +541,71 @@ class Qe extends Ye {
       @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
       */
   async onIdle() {
-    l(this, O) === 0 && l(this, R).size === 0 || await S(this, m, Z).call(this, "idle");
+    n(this, A) === 0 && n(this, S).size === 0 || await m(this, h, J).call(this, "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() {
+    n(this, A) !== 0 && await m(this, h, J).call(this, "pendingZero");
+  }
+  /**
+  @returns A promise that settles when the queue becomes rate-limited due to intervalCap.
+  */
+  async onRateLimit() {
+    this.isRateLimited || await m(this, h, J).call(this, "rateLimit");
+  }
+  /**
+  @returns A promise that settles when the queue is no longer rate-limited.
+  */
+  async onRateLimitCleared() {
+    this.isRateLimited && await m(this, h, J).call(this, "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((t, i) => {
+      const s = (a) => {
+        this.off("error", s), i(a);
+      };
+      this.on("error", s);
+    });
   }
   /**
   Size of the queue, the number of queued items waiting to run.
   */
   get size() {
-    return l(this, R).size;
+    return n(this, S).size;
   }
   /**
       Size of the queue, filtered by the given options.
@@ -583,88 +613,223 @@ class Qe extends Ye {
       For example, this can be used to find the number of items remaining in the queue with a specific priority level.
       */
   sizeBy(t) {
-    return l(this, R).filter(t).length;
+    return n(this, S).filter(t).length;
   }
   /**
   Number of running items (no longer in the queue).
   */
   get pending() {
-    return l(this, O);
+    return n(this, A);
   }
   /**
   Whether the queue is currently paused.
   */
   get isPaused() {
-    return l(this, L);
+    return n(this, q);
+  }
+  /**
+  Whether the queue is currently rate-limited due to intervalCap.
+  */
+  get isRateLimited() {
+    return n(this, j);
+  }
+  /**
+      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 n(this, A) === n(this, W) && n(this, S).size > 0 || this.isRateLimited && n(this, S).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 [...n(this, B).values()].map((t) => ({ ...t }));
   }
 }
-k = new WeakMap(), $ = new WeakMap(), x = new WeakMap(), z = new WeakMap(), M = new WeakMap(), W = new WeakMap(), N = new WeakMap(), q = new WeakMap(), R = new WeakMap(), Q = new WeakMap(), O = new WeakMap(), V = new WeakMap(), L = new WeakMap(), j = new WeakMap(), ee = new WeakMap(), m = new WeakSet(), _e = function() {
-  return l(this, $) || l(this, x) < l(this, z);
-}, Te = function() {
-  return l(this, O) < l(this, V);
-}, Se = function() {
-  H(this, O)._--, S(this, m, K).call(this), this.emit("next");
-}, Re = function() {
-  S(this, m, ae).call(this), S(this, m, oe).call(this), v(this, q, void 0);
-}, be = function() {
-  const t = Date.now();
-  if (l(this, N) === void 0) {
-    const i = l(this, W) - t;
-    if (i < 0)
-      v(this, x, l(this, k) ? l(this, O) : 0);
+Z = new WeakMap(), x = new WeakMap(), k = new WeakMap(), Y = new WeakMap(), j = new WeakMap(), X = new WeakMap(), U = new WeakMap(), ie = new WeakMap(), ee = new WeakMap(), D = new WeakMap(), M = new WeakMap(), P = new WeakMap(), I = new WeakMap(), N = new WeakMap(), S = new WeakMap(), se = new WeakMap(), A = new WeakMap(), W = new WeakMap(), q = new WeakMap(), fe = new WeakMap(), B = new WeakMap(), h = new WeakSet(), oe = function(t) {
+  for (; n(this, N) < n(this, I).length; ) {
+    const s = n(this, I)[n(this, N)];
+    if (s !== void 0 && t - s >= n(this, U))
+      H(this, N)._++;
     else
-      return l(this, q) === void 0 && v(this, q, setTimeout(() => {
-        S(this, m, Re).call(this);
-      }, i)), !0;
+      break;
+  }
+  (n(this, N) > 100 && n(this, N) > n(this, I).length / 2 || n(this, N) === n(this, I).length) && (w(this, I, n(this, I).slice(n(this, N))), w(this, N, 0));
+}, // Helper methods for interval consumption
+Ne = function(t) {
+  n(this, P) ? n(this, I).push(t) : H(this, k)._++;
+}, Ie = function() {
+  n(this, P) ? n(this, I).length > n(this, N) && n(this, I).pop() : n(this, k) > 0 && H(this, k)._--;
+}, ue = function() {
+  return n(this, I).length - n(this, N);
+}, Oe = function() {
+  return n(this, x) ? !0 : n(this, P) ? m(this, h, ue).call(this) < n(this, Y) : n(this, k) < n(this, Y);
+}, Ce = function() {
+  return n(this, A) < n(this, W);
+}, Le = function() {
+  H(this, A)._--, n(this, A) === 0 && this.emit("pendingZero"), m(this, h, le).call(this), this.emit("next");
+}, Pe = function() {
+  w(this, M, void 0), m(this, h, ye).call(this), m(this, h, we).call(this);
+}, xe = function(t) {
+  if (n(this, P)) {
+    if (m(this, h, oe).call(this, t), m(this, h, ue).call(this) >= n(this, Y)) {
+      const s = n(this, I)[n(this, N)], a = n(this, U) - (t - s);
+      return m(this, h, ce).call(this, a), !0;
+    }
+    return !1;
+  }
+  if (n(this, D) === void 0) {
+    const i = n(this, ie) - t;
+    if (i < 0) {
+      if (n(this, ee) > 0) {
+        const s = t - n(this, ee);
+        if (s < n(this, U))
+          return m(this, h, ce).call(this, n(this, U) - s), !0;
+      }
+      w(this, k, n(this, Z) ? n(this, A) : 0);
+    } else
+      return m(this, h, ce).call(this, i), !0;
   }
   return !1;
-}, K = function() {
-  if (l(this, R).size === 0)
-    return l(this, N) && clearInterval(l(this, N)), v(this, N, void 0), this.emit("empty"), l(this, O) === 0 && this.emit("idle"), !1;
-  if (!l(this, L)) {
-    const t = !l(this, m, be);
-    if (l(this, m, _e) && l(this, m, Te)) {
-      const i = l(this, R).dequeue();
-      return i ? (this.emit("active"), i(), t && S(this, m, oe).call(this), !0) : !1;
+}, ce = function(t) {
+  n(this, M) === void 0 && w(this, M, setTimeout(() => {
+    m(this, h, Pe).call(this);
+  }, t));
+}, he = function() {
+  n(this, D) && (clearInterval(n(this, D)), w(this, D, void 0));
+}, ge = function() {
+  n(this, M) && (clearTimeout(n(this, M)), w(this, M, void 0));
+}, le = function() {
+  if (n(this, S).size === 0) {
+    if (m(this, h, he).call(this), this.emit("empty"), n(this, A) === 0) {
+      if (m(this, h, ge).call(this), n(this, P) && n(this, N) > 0) {
+        const i = Date.now();
+        m(this, h, oe).call(this, i);
+      }
+      this.emit("idle");
+    }
+    return !1;
+  }
+  let t = !1;
+  if (!n(this, q)) {
+    const i = Date.now(), s = !m(this, h, xe).call(this, i);
+    if (n(this, h, Oe) && n(this, h, Ce)) {
+      const a = n(this, S).dequeue();
+      n(this, x) || (m(this, h, Ne).call(this, i), m(this, h, Q).call(this)), this.emit("active"), a(), s && m(this, h, we).call(this), t = !0;
     }
   }
-  return !1;
-}, oe = function() {
-  l(this, $) || l(this, N) !== void 0 || (v(this, N, setInterval(() => {
-    S(this, m, ae).call(this);
-  }, l(this, M))), v(this, W, Date.now() + l(this, M)));
-}, ae = function() {
-  l(this, x) === 0 && l(this, O) === 0 && l(this, N) && (clearInterval(l(this, N)), v(this, N, void 0)), v(this, x, l(this, k) ? l(this, O) : 0), S(this, m, X).call(this);
+  return t;
+}, we = function() {
+  n(this, x) || n(this, D) !== void 0 || n(this, P) || (w(this, D, setInterval(() => {
+    m(this, h, ye).call(this);
+  }, n(this, U))), w(this, ie, Date.now() + n(this, U)));
+}, ye = function() {
+  n(this, P) || (n(this, k) === 0 && n(this, A) === 0 && n(this, D) && m(this, h, he).call(this), w(this, k, n(this, Z) ? n(this, A) : 0)), m(this, h, de).call(this), m(this, h, Q).call(this);
 }, /**
 Executes all queued functions until it reaches the limit.
 */
-X = function() {
-  for (; S(this, m, K).call(this); )
+de = function() {
+  for (; m(this, h, le).call(this); )
     ;
-}, Ae = async function(t) {
-  return new Promise((i, n) => {
-    t.addEventListener("abort", () => {
-      n(t.reason);
-    }, { once: !0 });
-  });
-}, Z = async function(t, i) {
-  return new Promise((n) => {
+}, J = async function(t, i) {
+  return new Promise((s) => {
     const a = () => {
-      i && !i() || (this.off(t, a), n());
+      i && !i() || (this.off(t, a), s());
     };
     this.on(t, a);
   });
+}, ke = function() {
+  n(this, x) || (this.on("add", () => {
+    n(this, S).size > 0 && m(this, h, Q).call(this);
+  }), this.on("next", () => {
+    m(this, h, Q).call(this);
+  }));
+}, Q = function() {
+  n(this, x) || n(this, X) || (w(this, X, !0), queueMicrotask(() => {
+    w(this, X, !1), m(this, h, ve).call(this);
+  }));
+}, Ge = function() {
+  n(this, x) || (m(this, h, Ie).call(this), m(this, h, Q).call(this));
+}, ve = function() {
+  const t = n(this, j);
+  if (n(this, x) || n(this, S).size === 0) {
+    t && (w(this, j, !1), this.emit("rateLimitCleared"));
+    return;
+  }
+  let i;
+  if (n(this, P)) {
+    const a = Date.now();
+    m(this, h, oe).call(this, a), i = m(this, h, ue).call(this);
+  } else
+    i = n(this, k);
+  const s = i >= n(this, Y);
+  s !== t && (w(this, j, s), this.emit(s ? "rateLimit" : "rateLimitCleared"));
 };
-var Ne = /* @__PURE__ */ ((r) => (r.API_ERROR = "ApiError", r.NETWORK_ERROR = "NetworkError", r.VALIDATION_ERROR = "ValidationError", r.GEOCODING_ERROR = "GeocodingError", r.RATE_LIMIT_ERROR = "RateLimitError", r.TIMEOUT_ERROR = "TimeoutError", r.AUTHENTICATION_ERROR = "AuthenticationError", r.SERVER_ERROR = "ServerError", r.CLIENT_ERROR = "ClientError", r.CONFIGURATION_ERROR = "ConfigurationError", r))(Ne || {});
-class b extends Error {
-  constructor(e, t, i = {}) {
-    super(t), this.name = "BmltQueryError", this.type = e, this.statusCode = i.statusCode, this.response = i.response, this.originalError = i.originalError, this.context = i.context, Object.setPrototypeOf(this, b.prototype);
+var Fe = /* @__PURE__ */ ((r) => (r.API_ERROR = "ApiError", r.NETWORK_ERROR = "NetworkError", r.VALIDATION_ERROR = "ValidationError", r.GEOCODING_ERROR = "GeocodingError", r.RATE_LIMIT_ERROR = "RateLimitError", r.TIMEOUT_ERROR = "TimeoutError", r.AUTHENTICATION_ERROR = "AuthenticationError", r.SERVER_ERROR = "ServerError", r.CLIENT_ERROR = "ClientError", r.CONFIGURATION_ERROR = "ConfigurationError", r))(Fe || {});
+class C extends Error {
+  constructor(t, i, s = {}) {
+    super(i);
+    R(this, "type");
+    R(this, "statusCode");
+    R(this, "response");
+    R(this, "originalError");
+    R(this, "context");
+    this.name = "BmltQueryError", this.type = t, this.statusCode = s.statusCode, this.response = s.response, this.originalError = s.originalError, this.context = s.context, Object.setPrototypeOf(this, C.prototype);
   }
   /**
    * Check if error is of a specific type
    */
-  isType(e) {
-    return this.type === e;
+  isType(t) {
+    return this.type === t;
   }
   /**
    * Check if error is retryable
@@ -737,62 +902,62 @@ class b extends Error {
     };
   }
 }
-class I {
-  static createApiError(e, t, i, n) {
+class G {
+  static createApiError(e, t, i, s) {
     let a;
-    return t ? t >= 500 ? a = "ServerError" : t === 401 || t === 403 ? a = "AuthenticationError" : t === 429 ? a = "RateLimitError" : t >= 400 ? a = "ClientError" : a = "ApiError" : a = "ApiError", new b(a, e, {
+    return t ? t >= 500 ? a = "ServerError" : t === 401 || t === 403 ? a = "AuthenticationError" : t === 429 ? a = "RateLimitError" : t >= 400 ? a = "ClientError" : a = "ApiError" : a = "ApiError", new C(a, e, {
       statusCode: t,
       response: i,
-      originalError: n
+      originalError: s
     });
   }
   static createNetworkError(e, t) {
-    return new b("NetworkError", e, {
+    return new C("NetworkError", e, {
       originalError: t
     });
   }
   static createTimeoutError(e, t) {
-    return new b("TimeoutError", e, {
+    return new C("TimeoutError", e, {
       originalError: t
     });
   }
   static createValidationError(e, t) {
-    return new b("ValidationError", e, {
+    return new C("ValidationError", e, {
       context: t
     });
   }
   static createGeocodingError(e, t, i) {
-    return new b("GeocodingError", e, {
+    return new C("GeocodingError", e, {
       originalError: t,
       context: i
     });
   }
   static createRateLimitError(e, t, i) {
-    return new b("RateLimitError", e, {
+    return new C("RateLimitError", e, {
       statusCode: t,
       response: i
     });
   }
   static createConfigurationError(e, t) {
-    return new b("ConfigurationError", e, {
+    return new C("ConfigurationError", e, {
       context: t
     });
   }
 }
-class J {
+class re {
   /**
    * Handle and transform fetch errors
    */
   static handleFetchError(e, t) {
     if (e instanceof Error && e.name === "AbortError")
-      return I.createTimeoutError("Request timeout", e);
+      return G.createTimeoutError("Request timeout", e);
     if (e instanceof TypeError)
-      return I.createNetworkError("Network connection failed", e);
+      return G.createNetworkError("Network connection failed", e);
     if (t && !t.ok) {
       const i = `HTTP ${t.status}: ${t.statusText}`;
-      return I.createApiError(i, t.status, void 0, e);
+      return G.createApiError(i, t.status, void 0, e);
     }
-    return e instanceof Error ? I.createApiError(e.message, void 0, void 0, e) : I.createApiError(
+    return e instanceof Error ? G.createApiError(e.message, void 0, void 0, e) : G.createApiError(
       "Unknown error occurred",
       void 0,
       void 0,
@@ -803,18 +968,18 @@ class J {
    * @deprecated Use handleFetchError instead
    */
   static handleAxiosError(e) {
-    return J.handleFetchError(e);
+    return re.handleFetchError(e);
   }
   /**
    * Handle validation errors with detailed context
    */
-  static handleValidationError(e, t, i, n) {
+  static handleValidationError(e, t, i, s) {
     let a = `Invalid ${e}: expected ${i}`;
-    return n && n.length > 0 && (a += ` (${n.join(", ")})`), I.createValidationError(a, {
+    return s && s.length > 0 && (a += ` (${s.join(", ")})`), G.createValidationError(a, {
       field: e,
       value: t,
       expectedType: i,
-      constraints: n
+      constraints: s
     });
   }
   /**
@@ -822,7 +987,7 @@ class J {
    */
   static handleEndpointError(e, t) {
     const i = `Invalid endpoint/format combination: ${e} with ${t}`;
-    return I.createValidationError(i, {
+    return G.createValidationError(i, {
       endpoint: e,
       format: t
     });
@@ -832,7 +997,7 @@ class J {
    */
   static handleUrlError(e, t) {
     const i = `Invalid URL: ${t}`;
-    return I.createValidationError(i, {
+    return G.createValidationError(i, {
       url: e,
       reason: t
     });
@@ -841,8 +1006,8 @@ class J {
    * Handle coordinate validation errors
    */
   static handleCoordinateError(e, t, i) {
-    const n = i || "Invalid coordinates provided";
-    return I.createValidationError(n, {
+    const s = i || "Invalid coordinates provided";
+    return G.createValidationError(s, {
       latitude: e,
       longitude: t,
       reason: i
@@ -852,8 +1017,8 @@ class J {
    * Wrap and enhance existing errors
    */
   static wrapError(e, t, i) {
-    const n = `${t}: ${e.message}`;
-    return e instanceof b ? new b(e.type, n, {
+    const s = `${t}: ${e.message}`;
+    return e instanceof C ? new C(e.type, s, {
       statusCode: e.statusCode,
       response: e.response,
       originalError: e.originalError || e,
@@ -861,93 +1026,96 @@ class J {
         ...e.context,
         ...i
       }
-    }) : I.createApiError(n, void 0, void 0, e);
+    }) : G.createApiError(s, void 0, void 0, e);
   }
 }
-class it {
+class ct {
   static async withRetry(e, t) {
-    const { maxRetries: i, baseDelay: n, maxDelay: a, factor: s, onRetry: o } = t;
-    let u;
-    for (let c = 0; c <= i; c++)
+    const { maxRetries: i, baseDelay: s, maxDelay: a, factor: c, onRetry: u } = t;
+    let o;
+    for (let l = 0; l <= i; l++)
       try {
         return await e();
-      } catch (h) {
-        const f = h instanceof b ? h : J.wrapError(h, "Operation failed");
-        if (u = f, c === i || !f.isRetryable())
+      } catch (d) {
+        const f = d instanceof C ? d : re.wrapError(d, "Operation failed");
+        if (o = f, l === i || !f.isRetryable())
           throw f;
-        const p = Math.min(n * Math.pow(s, c), a);
-        o && o(f, c + 1), await new Promise((E) => setTimeout(E, p));
+        const g = Math.min(s * Math.pow(c, l), a);
+        u && u(f, l + 1), await new Promise((b) => setTimeout(b, g));
       }
-    throw u;
+    throw o;
   }
 }
-class je {
+class rt {
   constructor(e = {}) {
+    R(this, "baseURL");
+    R(this, "queue");
+    R(this, "defaultOptions");
     const {
       retryCount: t = 3,
       timeout: i = 1e4,
-      userAgent: n = "bmlt-query-client/1.0.0",
+      userAgent: s = "bmlt-query-client/1.0.0",
       countryCode: a = "us",
-      viewbox: s,
-      bounded: o = !1,
-      intervalCap: u = 1,
-      interval: c = 1e3,
+      viewbox: c,
+      bounded: u = !1,
+      intervalCap: o = 1,
+      interval: l = 1e3,
       // 1 second between requests
-      concurrency: h = 1,
+      concurrency: d = 1,
       carryoverConcurrencyCount: f = !1,
-      ...p
+      ...g
     } = e;
     this.defaultOptions = {
       retryCount: t,
       timeout: i,
-      userAgent: n,
+      userAgent: s,
       countryCode: a,
-      viewbox: s,
-      bounded: o
-    }, this.baseURL = "https://nominatim.openstreetmap.org", this.queue = new Qe({
-      intervalCap: u,
-      interval: c,
-      concurrency: h,
+      viewbox: c,
+      bounded: u
+    }, this.baseURL = "https://nominatim.openstreetmap.org", this.queue = new tt({
+      intervalCap: o,
+      interval: l,
+      concurrency: d,
       carryoverConcurrencyCount: f,
-      ...p
+      ...g
     });
   }
   /**
    * Make a fetch request with timeout and error handling
    */
   async fetchWithTimeout(e, t, i) {
-    const n = new AbortController(), a = setTimeout(() => n.abort(), t);
+    const s = new AbortController(), a = setTimeout(() => s.abort(), t);
     try {
-      const s = await fetch(e, {
+      const c = await fetch(e, {
         method: "GET",
         headers: {
           "User-Agent": i
         },
-        signal: n.signal
+        signal: s.signal
       });
-      if (!s.ok) {
-        if (s.status === 429) {
-          const u = new Error("Rate limit exceeded for geocoding service");
-          throw u.name = "RateLimitError", u.statusCode = 429, u;
+      if (!c.ok) {
+        if (c.status === 429) {
+          const o = new Error("Rate limit exceeded for geocoding service");
+          throw o.name = "RateLimitError", o.statusCode = 429, o;
         }
-        if (s.status >= 400) {
-          const u = new Error(
-            `Geocoding service error: ${s.status} ${s.statusText}`
+        if (c.status >= 400) {
+          const o = new Error(
+            `Geocoding service error: ${c.status} ${c.statusText}`
           );
-          throw u.name = "GeocodingError", u.statusCode = s.status, u;
+          throw o.name = "GeocodingError", o.statusCode = c.status, o;
         }
       }
-      return await s.json();
-    } catch (s) {
-      if (s instanceof Error && s.name === "AbortError") {
-        const o = new Error("Request timeout during geocoding");
-        throw o.name = "TimeoutError", o;
+      return await c.json();
+    } catch (c) {
+      if (c instanceof Error && c.name === "AbortError") {
+        const u = new Error("Request timeout during geocoding");
+        throw u.name = "TimeoutError", u;
       }
-      if (s instanceof TypeError) {
-        const o = new Error("Network error occurred during geocoding");
-        throw o.name = "NetworkError", o;
+      if (c instanceof TypeError) {
+        const u = new Error("Network error occurred during geocoding");
+        throw u.name = "NetworkError", u;
       }
-      throw s;
+      throw c;
     } finally {
       clearTimeout(a);
     }
@@ -957,63 +1125,63 @@ class je {
    */
   async geocode(e, t = {}) {
     const i = { ...this.defaultOptions, ...t };
-    return this.queue.add(async () => me(
+    return this.queue.add(async () => Se(
       async () => {
         try {
-          const n = {
+          const s = {
             q: e,
             format: "json",
             addressdetails: 1,
             limit: 1,
             dedupe: 1
           };
-          i.countryCode && (n.countrycodes = i.countryCode), i.viewbox && (n.viewbox = i.viewbox.join(","), i.bounded && (n.bounded = 1));
+          i.countryCode && (s.countrycodes = i.countryCode), i.viewbox && (s.viewbox = i.viewbox.join(","), i.bounded && (s.bounded = 1));
           const a = new URL(`${this.baseURL}/search`);
-          Object.entries(n).forEach(([c, h]) => {
-            a.searchParams.append(c, String(h));
+          Object.entries(s).forEach(([l, d]) => {
+            a.searchParams.append(l, String(d));
           });
-          const s = await this.fetchWithTimeout(
+          const c = await this.fetchWithTimeout(
             a.toString(),
             i.timeout,
             i.userAgent
           );
-          if (!s || s.length === 0)
-            throw new b(
-              Ne.GEOCODING_ERROR,
+          if (!c || c.length === 0)
+            throw new C(
+              Fe.GEOCODING_ERROR,
               `No results found for address: ${e}`
             );
-          const o = s[0], u = {
-            latitude: parseFloat(o.lat),
-            longitude: parseFloat(o.lon)
+          const u = c[0], o = {
+            latitude: parseFloat(u.lat),
+            longitude: parseFloat(u.lon)
           };
-          if (isNaN(u.latitude) || isNaN(u.longitude)) {
-            const c = new Error(
+          if (isNaN(o.latitude) || isNaN(o.longitude)) {
+            const l = new Error(
               "Invalid coordinates received from geocoding service"
             );
-            throw c.name = "GeocodingError", c;
+            throw l.name = "GeocodingError", l;
           }
-          if (u.latitude < -90 || u.latitude > 90 || u.longitude < -180 || u.longitude > 180) {
-            const c = new Error("Coordinates out of valid range");
-            throw c.name = "GeocodingError", c;
+          if (o.latitude < -90 || o.latitude > 90 || o.longitude < -180 || o.longitude > 180) {
+            const l = new Error("Coordinates out of valid range");
+            throw l.name = "GeocodingError", l;
           }
           return {
-            coordinates: u,
-            display_name: o.display_name,
-            confidence: o.importance,
-            address: o.address ? {
-              house_number: o.address.house_number,
-              road: o.address.road,
-              neighbourhood: o.address.neighbourhood,
-              suburb: o.address.suburb,
-              city: o.address.city || o.address.town || o.address.village,
-              county: o.address.county,
-              state: o.address.state,
-              postcode: o.address.postcode,
-              country: o.address.country
+            coordinates: o,
+            display_name: u.display_name,
+            confidence: u.importance,
+            address: u.address ? {
+              house_number: u.address.house_number,
+              road: u.address.road,
+              neighbourhood: u.address.neighbourhood,
+              suburb: u.address.suburb,
+              city: u.address.city || u.address.town || u.address.village,
+              county: u.address.county,
+              state: u.address.state,
+              postcode: u.address.postcode,
+              country: u.address.country
             } : void 0
           };
-        } catch (n) {
-          throw n;
+        } catch (s) {
+          throw s;
         }
       },
       {
@@ -1021,9 +1189,9 @@ class je {
         factor: 2,
         minTimeout: 1e3,
         maxTimeout: 1e4,
-        onFailedAttempt: (n) => {
+        onFailedAttempt: (s) => {
           console.warn(
-            `Geocoding attempt ${n.attemptNumber} failed. ${n.retriesLeft} retries left. Error: ${n.message}`
+            `Geocoding attempt ${s.attemptNumber} failed. ${s.retriesLeft} retries left. Error: ${s.error.message}`
           );
         }
       }
@@ -1034,7 +1202,7 @@ class je {
    */
   async batchGeocode(e, t = {}) {
     const i = e.map(
-      (a) => this.geocode(a, t).catch((s) => (console.warn(`Failed to geocode address "${a}":`, s.message), null))
+      (a) => this.geocode(a, t).catch((c) => (console.warn(`Failed to geocode address "${a}":`, c.message), null))
     );
     return (await Promise.all(i)).filter((a) => a !== null);
   }
@@ -1043,44 +1211,44 @@ class je {
    */
   async reverseGeocode(e, t = {}) {
     const i = { ...this.defaultOptions, ...t };
-    return this.queue.add(async () => me(
+    return this.queue.add(async () => Se(
       async () => {
         try {
-          const n = new URL(`${this.baseURL}/reverse`);
-          n.searchParams.append("lat", String(e.latitude)), n.searchParams.append("lon", String(e.longitude)), n.searchParams.append("format", "json"), n.searchParams.append("addressdetails", "1");
+          const s = new URL(`${this.baseURL}/reverse`);
+          s.searchParams.append("lat", String(e.latitude)), s.searchParams.append("lon", String(e.longitude)), s.searchParams.append("format", "json"), s.searchParams.append("addressdetails", "1");
           const a = await this.fetchWithTimeout(
-            n.toString(),
+            s.toString(),
             i.timeout,
             i.userAgent
           );
           if (!a) {
-            const o = new Error(
+            const u = new Error(
               `No results found for coordinates: ${e.latitude}, ${e.longitude}`
             );
-            throw o.name = "GeocodingError", o;
+            throw u.name = "GeocodingError", u;
           }
-          const s = a;
+          const c = a;
           return {
             coordinates: {
-              latitude: parseFloat(s.lat),
-              longitude: parseFloat(s.lon)
+              latitude: parseFloat(c.lat),
+              longitude: parseFloat(c.lon)
             },
-            display_name: s.display_name,
-            confidence: s.importance,
-            address: s.address ? {
-              house_number: s.address.house_number,
-              road: s.address.road,
-              neighbourhood: s.address.neighbourhood,
-              suburb: s.address.suburb,
-              city: s.address.city || s.address.town || s.address.village,
-              county: s.address.county,
-              state: s.address.state,
-              postcode: s.address.postcode,
-              country: s.address.country
+            display_name: c.display_name,
+            confidence: c.importance,
+            address: c.address ? {
+              house_number: c.address.house_number,
+              road: c.address.road,
+              neighbourhood: c.address.neighbourhood,
+              suburb: c.address.suburb,
+              city: c.address.city || c.address.town || c.address.village,
+              county: c.address.county,
+              state: c.address.state,
+              postcode: c.address.postcode,
+              country: c.address.country
             } : void 0
           };
-        } catch (n) {
-          throw n;
+        } catch (s) {
+          throw s;
         }
       },
       {
@@ -1125,78 +1293,79 @@ class je {
    * Set the user agent string for geocoding requests
    */
   setUserAgent(e) {
-    if (!e || typeof e != "string" || e.trim().length === 0)
+    if (!e || e.trim().length === 0)
       throw new Error("User agent must be a non-empty string");
     this.defaultOptions.userAgent = e.trim();
   }
 }
-var g = /* @__PURE__ */ ((r) => (r.JSON = "json", r.JSONP = "jsonp", r.TSML = "tsml", r.CSV = "csv", r))(g || {}), _ = /* @__PURE__ */ ((r) => (r.GET_SEARCH_RESULTS = "GetSearchResults", r.GET_FORMATS = "GetFormats", r.GET_SERVICE_BODIES = "GetServiceBodies", r.GET_CHANGES = "GetChanges", r.GET_FIELD_KEYS = "GetFieldKeys", r.GET_FIELD_VALUES = "GetFieldValues", r.GET_NAWS_DUMP = "GetNAWSDump", r.GET_SERVER_INFO = "GetServerInfo", r.GET_COVERAGE_AREA = "GetCoverageArea", r))(_ || {}), G = /* @__PURE__ */ ((r) => (r[r.SUNDAY = 1] = "SUNDAY", r[r.MONDAY = 2] = "MONDAY", r[r.TUESDAY = 3] = "TUESDAY", r[r.WEDNESDAY = 4] = "WEDNESDAY", r[r.THURSDAY = 5] = "THURSDAY", r[r.FRIDAY = 6] = "FRIDAY", r[r.SATURDAY = 7] = "SATURDAY", r))(G || {}), F = /* @__PURE__ */ ((r) => (r[r.IN_PERSON = 1] = "IN_PERSON", r[r.VIRTUAL = 2] = "VIRTUAL", r[r.HYBRID = 3] = "HYBRID", r))(F || {}), Be = /* @__PURE__ */ ((r) => (r.WEEKDAY = "weekday", r.TIME = "time", r.TOWN = "town", r.STATE = "state", r.WEEKDAY_STATE = "weekday_state", r))(Be || {}), Ke = /* @__PURE__ */ ((r) => (r.ENGLISH = "en", r.GERMAN = "de", r.DANISH = "dk", r.SPANISH = "es", r.PERSIAN = "fa", r.FRENCH = "fr", r.ITALIAN = "it", r.POLISH = "pl", r.PORTUGUESE = "pt", r.SWEDISH = "sv", r))(Ke || {});
-function Xe(r) {
-  const { rootServerURL: e, format: t, endpoint: i, parameters: n = {} } = r, s = `${e.endsWith("/") ? e : `${e}/`}client_interface/${t}/`, o = new URLSearchParams();
-  return o.set("switcher", i), Object.entries(n).forEach(([u, c]) => {
-    c != null && (Array.isArray(c) ? c.forEach((h, f) => {
-      (typeof h == "number" || typeof h == "string") && o.append(`${u}[]`, h.toString());
-    }) : typeof c == "boolean" ? o.set(u, c ? "1" : "0") : o.set(u, c.toString()));
-  }), `${s}?${o.toString()}`;
-}
+var v = /* @__PURE__ */ ((r) => (r.JSON = "json", r.JSONP = "jsonp", r.TSML = "tsml", r.CSV = "csv", r))(v || {}), _ = /* @__PURE__ */ ((r) => (r.GET_SEARCH_RESULTS = "GetSearchResults", r.GET_FORMATS = "GetFormats", r.GET_SERVICE_BODIES = "GetServiceBodies", r.GET_CHANGES = "GetChanges", r.GET_FIELD_KEYS = "GetFieldKeys", r.GET_FIELD_VALUES = "GetFieldValues", r.GET_NAWS_DUMP = "GetNAWSDump", r.GET_SERVER_INFO = "GetServerInfo", r.GET_COVERAGE_AREA = "GetCoverageArea", r))(_ || {}), $ = /* @__PURE__ */ ((r) => (r[r.SUNDAY = 1] = "SUNDAY", r[r.MONDAY = 2] = "MONDAY", r[r.TUESDAY = 3] = "TUESDAY", r[r.WEDNESDAY = 4] = "WEDNESDAY", r[r.THURSDAY = 5] = "THURSDAY", r[r.FRIDAY = 6] = "FRIDAY", r[r.SATURDAY = 7] = "SATURDAY", r))($ || {}), K = /* @__PURE__ */ ((r) => (r[r.IN_PERSON = 1] = "IN_PERSON", r[r.VIRTUAL = 2] = "VIRTUAL", r[r.HYBRID = 3] = "HYBRID", r))(K || {}), it = /* @__PURE__ */ ((r) => (r.WEEKDAY = "weekday", r.TIME = "time", r.TOWN = "town", r.STATE = "state", r.WEEKDAY_STATE = "weekday_state", r))(it || {}), st = /* @__PURE__ */ ((r) => (r.ENGLISH = "en", r.GERMAN = "de", r.DANISH = "dk", r.SPANISH = "es", r.PERSIAN = "fa", r.FRENCH = "fr", r.ITALIAN = "it", r.POLISH = "pl", r.PORTUGUESE = "pt", r.SWEDISH = "sv", r))(st || {});
 function nt(r) {
+  const { rootServerURL: e, format: t, endpoint: i, parameters: s = {} } = r, c = `${e.endsWith("/") ? e : `${e}/`}client_interface/${t}/`, u = new URLSearchParams();
+  return u.set("switcher", i), Object.entries(s).forEach(([o, l]) => {
+    l != null && (Array.isArray(l) ? l.forEach((d, f) => {
+      (typeof d == "number" || typeof d == "string") && u.append(`${o}[]`, d.toString());
+    }) : typeof l == "boolean" ? u.set(o, l ? "1" : "0") : u.set(o, l.toString()));
+  }), `${c}?${u.toString()}`;
+}
+function ht(r) {
   const e = {};
   return Object.entries(r).forEach(([t, i]) => {
     if (i != null)
       if (Array.isArray(i))
-        e[t] = i.map((n) => {
-          if (typeof n == "number")
-            return n;
-          if (typeof n == "string") {
-            const a = parseFloat(n);
-            return isNaN(a) ? n : a;
+        e[t] = i.map((s) => {
+          if (typeof s == "number")
+            return s;
+          if (typeof s == "string") {
+            const a = parseFloat(s);
+            return isNaN(a) ? s : a;
           }
-          return n;
+          return s;
         });
       else if (typeof i == "boolean")
         e[t] = i;
       else if (typeof i == "string") {
-        const n = parseFloat(i);
-        !isNaN(n) && isFinite(n) ? e[t] = n : e[t] = i;
+        const s = parseFloat(i);
+        !isNaN(s) && isFinite(s) ? e[t] = s : e[t] = i;
       } else
         e[t] = i;
   }), e;
 }
-function Ze(r, e) {
+function at(r, e) {
   const i = {
     [_.GET_SEARCH_RESULTS]: [
-      g.JSON,
-      g.JSONP,
-      g.TSML
+      v.JSON,
+      v.JSONP,
+      v.TSML
     ],
-    [_.GET_FORMATS]: [g.JSON, g.JSONP],
-    [_.GET_SERVICE_BODIES]: [g.JSON, g.JSONP],
-    [_.GET_CHANGES]: [g.JSON, g.JSONP],
-    [_.GET_FIELD_KEYS]: [g.JSON, g.JSONP],
-    [_.GET_FIELD_VALUES]: [g.JSON, g.JSONP],
-    [_.GET_NAWS_DUMP]: [g.CSV],
-    [_.GET_SERVER_INFO]: [g.JSON, g.JSONP],
-    [_.GET_COVERAGE_AREA]: [g.JSON, g.JSONP]
+    [_.GET_FORMATS]: [v.JSON, v.JSONP],
+    [_.GET_SERVICE_BODIES]: [v.JSON, v.JSONP],
+    [_.GET_CHANGES]: [v.JSON, v.JSONP],
+    [_.GET_FIELD_KEYS]: [v.JSON, v.JSONP],
+    [_.GET_FIELD_VALUES]: [v.JSON, v.JSONP],
+    [_.GET_NAWS_DUMP]: [v.CSV],
+    [_.GET_SERVER_INFO]: [v.JSON, v.JSONP],
+    [_.GET_COVERAGE_AREA]: [v.JSON, v.JSONP]
   }[r];
   if (!i.includes(e))
     throw new Error(
       `Invalid format '${e}' for endpoint '${r}'. Valid formats: ${i.join(", ")}`
     );
 }
-function ye(r) {
+function Ae(r) {
   try {
     const e = new URL(r);
     if (!["http:", "https:"].includes(e.protocol))
       throw new Error("Root server URL must use http or https protocol");
     return e.href.replace(/\/$/, "");
-  } catch {
-    throw new Error(`Invalid root server URL: ${r}`);
+  } catch (e) {
+    const t = new Error(`Invalid root server URL: ${r}`);
+    throw t.cause = e, t;
   }
 }
-function st(r) {
+function lt(r) {
   return typeof r == "number" ? [r] : typeof r == "string" ? r.split(",").map((e) => parseInt(e.trim(), 10)).filter((e) => !isNaN(e)) : Array.isArray(r) ? r.map((e) => typeof e == "number" ? e : parseInt(String(e), 10)).filter((e) => !isNaN(e)) : [];
 }
-function ot(r, e) {
+function dt(r, e) {
   const t = {};
   if (typeof r == "number") {
     if (r < 0 || r > 23)
@@ -1210,7 +1379,7 @@ function ot(r, e) {
   }
   return t;
 }
-function et(r, e) {
+function ot(r, e) {
   if (typeof r != "number" || isNaN(r))
     throw new Error("Latitude must be a valid number");
   if (typeof e != "number" || isNaN(e))
@@ -1220,71 +1389,76 @@ function et(r, e) {
   if (e < -180 || e > 180)
     throw new Error("Longitude must be between -180 and 180 degrees");
 }
-function B(r) {
+function ae(r) {
   if (typeof r != "number" || isNaN(r))
     throw new Error("Radius must be a valid number");
   if (r <= 0)
     throw new Error("Radius must be greater than 0");
 }
-function at(r) {
+function ft(r) {
   return r * 1.60934;
 }
-function ut(r) {
+function mt(r) {
   return r / 1.60934;
 }
-class ct {
+class Et {
   constructor(e) {
+    R(this, "timeout");
+    R(this, "userAgent");
+    R(this, "geocodingService");
+    R(this, "rootServerURL");
+    R(this, "defaultFormat");
     const {
       rootServerURL: t,
-      defaultFormat: i = g.JSON,
-      timeout: n = 3e4,
+      defaultFormat: i = v.JSON,
+      timeout: s = 3e4,
       userAgent: a = "bmlt-query-client/1.0.0",
-      geocodingOptions: s = {},
-      enableGeocoding: o = !0
+      geocodingOptions: c = {},
+      enableGeocoding: u = !0
     } = e;
-    this.rootServerURL = ye(t), this.defaultFormat = i, this.timeout = n, this.userAgent = a, o && (this.geocodingService = new je(s));
+    this.rootServerURL = Ae(t), this.defaultFormat = i, this.timeout = s, this.userAgent = a, u && (this.geocodingService = new rt(c));
   }
   /**
    * Make a request to the BMLT API
    */
   async makeRequest(e, t = {}, i = this.defaultFormat) {
-    let n;
+    let s;
     try {
-      Ze(e, i);
-      const a = Xe({
+      at(e, i);
+      const a = nt({
         rootServerURL: this.rootServerURL,
         format: i,
         endpoint: e,
         parameters: t
-      }), s = new AbortController(), o = setTimeout(() => s.abort(), this.timeout);
+      }), c = new AbortController(), u = setTimeout(() => c.abort(), this.timeout);
       try {
-        n = await fetch(a, {
+        s = await fetch(a, {
           method: "GET",
           headers: {
             "User-Agent": this.userAgent
           },
-          signal: s.signal
+          signal: c.signal
         });
       } finally {
-        clearTimeout(o);
+        clearTimeout(u);
       }
-      if (!n.ok)
-        throw J.handleFetchError(
-          new Error(`HTTP ${n.status}: ${n.statusText}`),
-          n
+      if (!s.ok)
+        throw re.handleFetchError(
+          new Error(`HTTP ${s.status}: ${s.statusText}`),
+          s
         );
-      const u = await n.text();
-      if (i === g.CSV)
-        return u;
-      if (i === g.JSONP) {
-        const c = t.callback || "callback", h = u.match(new RegExp(`${c}\\((.+)\\);?$`));
-        if (!h)
+      const o = await s.text();
+      if (i === v.CSV)
+        return o;
+      if (i === v.JSONP) {
+        const l = t.callback || "callback", d = o.match(new RegExp(`${l}\\((.+)\\);?$`));
+        if (!d)
           throw new Error("Invalid JSONP response format");
-        return JSON.parse(h[1]);
+        return JSON.parse(d[1]);
       }
-      return i === g.JSON || i === g.TSML ? JSON.parse(u) : u;
+      return i === v.JSON || i === v.TSML ? JSON.parse(o) : o;
     } catch (a) {
-      throw J.handleFetchError(a, n);
+      throw re.handleFetchError(a, s);
     }
   }
   /**
@@ -1300,26 +1474,26 @@ class ct {
   async searchMeetingsByAddress(e) {
     if (!this.geocodingService)
       throw new Error("Geocoding is not enabled. Initialize client with enableGeocoding: true");
-    const { address: t, radiusMiles: i, radiusKm: n, sortByDistance: a = !0, searchParams: s = {} } = e, o = await this.geocodingService.geocode(t), u = {
-      ...s,
-      lat_val: o.coordinates.latitude,
-      long_val: o.coordinates.longitude,
+    const { address: t, radiusMiles: i, radiusKm: s, sortByDistance: a = !0, searchParams: c = {} } = e, u = await this.geocodingService.geocode(t), o = {
+      ...c,
+      lat_val: u.coordinates.latitude,
+      long_val: u.coordinates.longitude,
       sort_results_by_distance: a
     };
-    return i !== void 0 ? (B(i), u.geo_width = i) : n !== void 0 && (B(n), u.geo_width_km = n), this.searchMeetings(u);
+    return i !== void 0 ? (ae(i), o.geo_width = i) : s !== void 0 && (ae(s), o.geo_width_km = s), this.searchMeetings(o);
   }
   /**
    * Search for meetings by coordinates
    */
-  async searchMeetingsByCoordinates(e, t, i, n = {}) {
-    et(e.latitude, e.longitude);
+  async searchMeetingsByCoordinates(e, t, i, s = {}) {
+    ot(e.latitude, e.longitude);
     const a = {
-      ...n,
+      ...s,
       lat_val: e.latitude,
       long_val: e.longitude,
       sort_results_by_distance: !0
     };
-    return t !== void 0 ? (B(t), a.geo_width = t) : i !== void 0 && (B(i), a.geo_width_km = i), this.searchMeetings(a);
+    return t !== void 0 ? (ae(t), a.geo_width = t) : i !== void 0 && (ae(i), a.geo_width_km = i), this.searchMeetings(a);
   }
   /**
    * Get available meeting formats
@@ -1359,7 +1533,7 @@ class ct {
    * Get NAWS dump for a service body (CSV format only)
    */
   async getNAWSDump(e) {
-    return this.makeRequest(_.GET_NAWS_DUMP, e, g.CSV);
+    return this.makeRequest(_.GET_NAWS_DUMP, e, v.CSV);
   }
   /**
    * Get server information
@@ -1399,7 +1573,7 @@ class ct {
    * Update the root server URL
    */
   setRootServerURL(e) {
-    this.rootServerURL = ye(e);
+    this.rootServerURL = Ae(e);
   }
   /**
    * Get the default data format
@@ -1438,7 +1612,7 @@ class ct {
    * Set the user agent string for HTTP requests
    */
   setUserAgent(e) {
-    if (!e || typeof e != "string" || e.trim().length === 0)
+    if (!e || e.trim().length === 0)
       throw new Error("User agent must be a non-empty string");
     this.userAgent = e.trim(), this.geocodingService && this.geocodingService.setUserAgent(this.userAgent);
   }
@@ -1457,9 +1631,11 @@ class ct {
     this.timeout = e;
   }
 }
-class C {
+class F {
   constructor(e) {
-    this.params = {}, this.client = e;
+    R(this, "params", {});
+    R(this, "client");
+    this.client = e;
   }
   /**
    * Include or exclude specific meeting IDs
@@ -1490,25 +1666,25 @@ class C {
    * Include only in-person meetings
    */
   inPersonOnly() {
-    return this.venueTypes(F.IN_PERSON);
+    return this.venueTypes(K.IN_PERSON);
   }
   /**
    * Include only virtual meetings
    */
   virtualOnly() {
-    return this.venueTypes(F.VIRTUAL);
+    return this.venueTypes(K.VIRTUAL);
   }
   /**
    * Include only hybrid meetings
    */
   hybridOnly() {
-    return this.venueTypes(F.HYBRID);
+    return this.venueTypes(K.HYBRID);
   }
   /**
    * Include virtual and hybrid meetings
    */
   virtualOrHybrid() {
-    return this.venueTypes(F.VIRTUAL, F.HYBRID);
+    return this.venueTypes(K.VIRTUAL, K.HYBRID);
   }
   /**
    * Filter by meeting formats
@@ -1670,7 +1846,7 @@ class C {
    * Clone the current query builder
    */
   clone() {
-    const e = new C(this.client);
+    const e = new F(this.client);
     return e.params = { ...this.params }, e;
   }
   /**
@@ -1682,101 +1858,102 @@ class C {
   /**
    * Execute the search by geocoding an address first
    */
-  async executeNearAddress(e, t, i, n = !0) {
+  async executeNearAddress(e, t, i, s = !0) {
     return this.client.searchMeetingsByAddress({
       address: e,
       radiusMiles: t,
       radiusKm: i,
-      sortByDistance: n,
+      sortByDistance: s,
       searchParams: this.params
     });
   }
 }
-class ht {
+class gt {
   constructor(e) {
+    R(this, "client");
     this.client = e;
   }
   /**
    * Search for today's meetings
    */
   today() {
-    const e = (/* @__PURE__ */ new Date()).getDay(), t = e === 0 ? G.SUNDAY : e;
-    return new C(this.client).onWeekdays(t);
+    const e = (/* @__PURE__ */ new Date()).getDay(), t = e === 0 ? $.SUNDAY : e;
+    return new F(this.client).onWeekdays(t);
   }
   /**
    * Search for weekend meetings
    */
   weekend() {
-    return new C(this.client).onWeekdays(G.SATURDAY, G.SUNDAY);
+    return new F(this.client).onWeekdays($.SATURDAY, $.SUNDAY);
   }
   /**
    * Search for weekday meetings
    */
   weekdays() {
-    return new C(this.client).onWeekdays(
-      G.MONDAY,
-      G.TUESDAY,
-      G.WEDNESDAY,
-      G.THURSDAY,
-      G.FRIDAY
+    return new F(this.client).onWeekdays(
+      $.MONDAY,
+      $.TUESDAY,
+      $.WEDNESDAY,
+      $.THURSDAY,
+      $.FRIDAY
     );
   }
   /**
    * Search for evening meetings (after 5 PM)
    */
   evening() {
-    return new C(this.client).startingAfter(17);
+    return new F(this.client).startingAfter(17);
   }
   /**
    * Search for morning meetings (before 12 PM)
    */
   morning() {
-    return new C(this.client).startingBefore(12);
+    return new F(this.client).startingBefore(12);
   }
   /**
    * Search for virtual meetings only
    */
   virtual() {
-    return new C(this.client).virtualOnly();
+    return new F(this.client).virtualOnly();
   }
   /**
    * Search for in-person meetings only
    */
   inPerson() {
-    return new C(this.client).inPersonOnly();
+    return new F(this.client).inPersonOnly();
   }
   /**
    * Search by meeting name or location
    */
   byText(e) {
-    return new C(this.client).searchText(e);
+    return new F(this.client).searchText(e);
   }
 }
 export {
-  ct as BmltClient,
-  g as BmltDataFormat,
+  Et as BmltClient,
+  v as BmltDataFormat,
   _ as BmltEndpoint,
-  Ne as BmltErrorType,
-  b as BmltQueryError,
-  I as ErrorFactory,
-  J as ErrorHandler,
-  je as GeocodingService,
-  Ke as Language,
-  C as MeetingQueryBuilder,
-  ht as QuickSearch,
-  it as RetryHandler,
-  Be as SortKey,
-  F as VenueType,
-  G as Weekday,
-  Xe as buildBmltURL,
-  st as extractIds,
-  ot as formatTimeValue,
-  ut as kilometersToMiles,
-  at as milesToKilometers,
-  nt as normalizeParameters,
-  et as validateCoordinates,
-  Ze as validateEndpointFormat,
-  B as validateRadius,
-  ye as validateRootServerURL
+  Fe as BmltErrorType,
+  C as BmltQueryError,
+  G as ErrorFactory,
+  re as ErrorHandler,
+  rt as GeocodingService,
+  st as Language,
+  F as MeetingQueryBuilder,
+  gt as QuickSearch,
+  ct as RetryHandler,
+  it as SortKey,
+  K as VenueType,
+  $ as Weekday,
+  nt as buildBmltURL,
+  lt as extractIds,
+  dt as formatTimeValue,
+  mt as kilometersToMiles,
+  ft as milesToKilometers,
+  ht as normalizeParameters,
+  ot as validateCoordinates,
+  at as validateEndpointFormat,
+  ae as validateRadius,
+  Ae as validateRootServerURL
 };
 //# sourceMappingURL=app.js.map