bmlt-query-client 1.0.1

package/dist/app.js

@@ -0,0 +1,1738 @@
+var Ie = Object.defineProperty;
+var ue = (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 H = (r, e, t, i) => ({
+  set _(n) {
+    v(r, e, n, t);
+  },
+  get _() {
+    return l(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(g) {
+            f.retry(g) || (g && (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 xe = Le();
+const De = /* @__PURE__ */ ve(xe), Ue = Object.prototype.toString, Fe = (r) => Ue.call(r) === "[object Error]", ke = /* @__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"
+  // Undici (Node.js)
+]);
+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;
+}
+let Me = class 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 = De.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);
+        }
+      }
+    });
+  });
+}
+var se = { exports: {} }, Ee;
+function qe() {
+  return Ee || (Ee = 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 a(u, c, h, f, p) {
+      if (typeof h != "function")
+        throw new TypeError("The listener must be a function");
+      var E = new n(h, f || u, p), g = t ? t + c : c;
+      return u._events[g] ? u._events[g].fn ? u._events[g] = [u._events[g], E] : u._events[g].push(E) : (u._events[g] = E, u._eventsCount++), u;
+    }
+    function s(u, c) {
+      --u._eventsCount === 0 ? u._events = new i() : delete u._events[c];
+    }
+    function o() {
+      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];
+      if (!f) return [];
+      if (f.fn) return [f.fn];
+      for (var p = 0, E = f.length, g = new Array(E); p < E; p++)
+        g[p] = f[p].fn;
+      return g;
+    }, o.prototype.listenerCount = function(c) {
+      var h = t ? t + c : c, f = this._events[h];
+      return f ? f.fn ? 1 : f.length : 0;
+    }, o.prototype.emit = function(c, h, f, p, E, g) {
+      var P = t ? t + c : c;
+      if (!this._events[P]) return !1;
+      var d = this._events[P], x = arguments.length, U, w;
+      if (d.fn) {
+        switch (d.once && this.removeListener(c, d.fn, void 0, !0), x) {
+          case 1:
+            return d.fn.call(d.context), !0;
+          case 2:
+            return d.fn.call(d.context, h), !0;
+          case 3:
+            return d.fn.call(d.context, h, f), !0;
+          case 4:
+            return d.fn.call(d.context, h, f, p), !0;
+          case 5:
+            return d.fn.call(d.context, h, f, p, E), !0;
+          case 6:
+            return d.fn.call(d.context, h, f, p, E, g), !0;
+        }
+        for (w = 1, U = new Array(x - 1); w < x; w++)
+          U[w - 1] = arguments[w];
+        d.fn.apply(d.context, U);
+      } 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), x) {
+            case 1:
+              d[w].fn.call(d[w].context);
+              break;
+            case 2:
+              d[w].fn.call(d[w].context, h);
+              break;
+            case 3:
+              d[w].fn.call(d[w].context, h, f);
+              break;
+            case 4:
+              d[w].fn.call(d[w].context, h, f, p);
+              break;
+            default:
+              if (!U) for (Y = 1, U = new Array(x - 1); Y < x; Y++)
+                U[Y - 1] = arguments[Y];
+              d[w].fn.apply(d[w].context, U);
+          }
+      }
+      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 g = this._events[E];
+      if (g.fn)
+        g.fn === h && (!p || g.once) && (!f || g.context === f) && s(this, E);
+      else {
+        for (var P = 0, d = [], x = g.length; P < x; P++)
+          (g[P].fn !== h || p && !g[P].once || f && g[P].context !== f) && d.push(g[P]);
+        d.length ? this._events[E] = d.length === 1 ? d[0] : d : s(this, E);
+      }
+      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;
+}
+var Ve = qe();
+const Ye = /* @__PURE__ */ ve(Ve);
+class we extends Error {
+  constructor(e) {
+    super(e), this.name = "TimeoutError";
+  }
+}
+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), ye = (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 {
+    milliseconds: t,
+    fallback: i,
+    message: n,
+    customTimers: a = { setTimeout, clearTimeout }
+  } = e;
+  let s, o;
+  const c = new Promise((h, f) => {
+    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(ye(E)), o = () => {
+        f(ye(E));
+      }, E.addEventListener("abort", o, { once: !0 });
+    }
+    if (t === Number.POSITIVE_INFINITY) {
+      r.then(h, f);
+      return;
+    }
+    const p = new we();
+    s = a.setTimeout.call(void 0, () => {
+      if (i) {
+        try {
+          h(i());
+        } catch (E) {
+          f(E);
+        }
+        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);
+      }
+    })();
+  }).finally(() => {
+    c.clear(), o && e.signal && e.signal.removeEventListener("abort", o);
+  });
+  return c.clear = () => {
+    a.clearTimeout.call(void 0, s), s = void 0;
+  }, c;
+}
+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;
+  }
+  return i;
+}
+var A;
+class We {
+  constructor() {
+    T(this, A, []);
+  }
+  enqueue(e, t) {
+    t = {
+      priority: 0,
+      ...t
+    };
+    const i = {
+      priority: t.priority,
+      id: t.id,
+      run: e
+    };
+    if (this.size === 0 || l(this, A)[this.size - 1].priority >= t.priority) {
+      l(this, A).push(i);
+      return;
+    }
+    const n = ze(l(this, A), i, (a, s) => s.priority - a.priority);
+    l(this, A).splice(n, 0, i);
+  }
+  setPriority(e, t) {
+    const i = l(this, A).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 });
+  }
+  dequeue() {
+    return l(this, A).shift()?.run;
+  }
+  filter(e) {
+    return l(this, A).filter((t) => t.priority === e.priority).map((t) => t.run);
+  }
+  get size() {
+    return l(this, A).length;
+  }
+}
+A = new WeakMap();
+var k, $, D, 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()`
+  constructor(t) {
+    super();
+    T(this, m);
+    T(this, k);
+    T(this, $);
+    T(this, D, 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);
+    // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
+    T(this, V);
+    T(this, L);
+    T(this, j);
+    // Use to assign a unique identifier to a promise function, if not explicitly specified
+    T(this, ee, 1n);
+    /**
+        Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
+    
+        Applies to each future operation.
+        */
+    ce(this, "timeout");
+    if (t = {
+      carryoverConcurrencyCount: !1,
+      intervalCap: Number.POSITIVE_INFINITY,
+      interval: 0,
+      concurrency: Number.POSITIVE_INFINITY,
+      autoStart: !0,
+      queueClass: We,
+      ...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);
+  }
+  get concurrency() {
+    return l(this, V);
+  }
+  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);
+  }
+  /**
+      Updates the priority of a promise function by its id, affecting its execution order. Requires a defined concurrency limit to take effect.
+  
+      For example, this can be used to prioritize a promise function to run earlier.
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 1});
+  
+      queue.add(async () => '🦄', {priority: 1});
+      queue.add(async () => '🦀', {priority: 0, id: '🦀'});
+      queue.add(async () => '🦄', {priority: 1});
+      queue.add(async () => '🦄', {priority: 1});
+  
+      queue.setPriority('🦀', 2);
+      ```
+  
+      In this case, the promise function with `id: '🦀'` runs second.
+  
+      You can also deprioritize a promise function to delay its execution:
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 1});
+  
+      queue.add(async () => '🦄', {priority: 1});
+      queue.add(async () => '🦀', {priority: 1, id: '🦀'});
+      queue.add(async () => '🦄');
+      queue.add(async () => '🦄', {priority: 0});
+  
+      queue.setPriority('🦀', -1);
+      ```
+      Here, the promise function with `id: '🦀'` executes last.
+      */
+  setPriority(t, i) {
+    l(this, R).setPriority(t, i);
+  }
+  async add(t, i = {}) {
+    return i.id ?? (i.id = (H(this, ee)._++).toString()), i = {
+      timeout: this.timeout,
+      throwOnTimeout: l(this, j),
+      ...i
+    }, new Promise((n, a) => {
+      l(this, R).enqueue(async () => {
+        H(this, O)._++, H(this, D)._++;
+        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;
+          }
+          a(s), this.emit("error", s);
+        } finally {
+          S(this, m, Se).call(this);
+        }
+      }, i), this.emit("add"), S(this, m, K).call(this);
+    });
+  }
+  async addAll(t, i) {
+    return Promise.all(t.map(async (n) => this.add(n, 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;
+  }
+  /**
+  Put queue execution on hold.
+  */
+  pause() {
+    v(this, L, !0);
+  }
+  /**
+  Clear the queue.
+  */
+  clear() {
+    v(this, R, new (l(this, Q))());
+  }
+  /**
+      Can be called multiple times. Useful if you for example add additional items at a later time.
+  
+      @returns A promise that settles when the queue becomes empty.
+      */
+  async onEmpty() {
+    l(this, R).size !== 0 && await S(this, m, Z).call(this, "empty");
+  }
+  /**
+      @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
+  
+      If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.
+  
+      Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.
+      */
+  async onSizeLessThan(t) {
+    l(this, R).size < t || await S(this, m, Z).call(this, "next", () => l(this, R).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.
+  
+      @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");
+  }
+  /**
+  Size of the queue, the number of queued items waiting to run.
+  */
+  get size() {
+    return l(this, R).size;
+  }
+  /**
+      Size of the queue, filtered by the given options.
+  
+      For example, this can be used to find the number of items remaining in the queue with a specific priority level.
+      */
+  sizeBy(t) {
+    return l(this, R).filter(t).length;
+  }
+  /**
+  Number of running items (no longer in the queue).
+  */
+  get pending() {
+    return l(this, O);
+  }
+  /**
+  Whether the queue is currently paused.
+  */
+  get isPaused() {
+    return l(this, L);
+  }
+}
+k = new WeakMap(), $ = new WeakMap(), D = 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, D) < 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, D, l(this, k) ? l(this, O) : 0);
+    else
+      return l(this, q) === void 0 && v(this, q, setTimeout(() => {
+        S(this, m, Re).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;
+    }
+  }
+  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, D) === 0 && l(this, O) === 0 && l(this, N) && (clearInterval(l(this, N)), v(this, N, void 0)), v(this, D, l(this, k) ? l(this, O) : 0), S(this, m, X).call(this);
+}, /**
+Executes all queued functions until it reaches the limit.
+*/
+X = function() {
+  for (; S(this, m, K).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) => {
+    const a = () => {
+      i && !i() || (this.off(t, a), n());
+    };
+    this.on(t, a);
+  });
+};
+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);
+  }
+  /**
+   * Check if error is of a specific type
+   */
+  isType(e) {
+    return this.type === e;
+  }
+  /**
+   * Check if error is retryable
+   */
+  isRetryable() {
+    return [
+      "NetworkError",
+      "TimeoutError",
+      "RateLimitError",
+      "ServerError"
+      /* SERVER_ERROR */
+    ].includes(this.type);
+  }
+  /**
+   * Check if error is a client-side error (4xx)
+   */
+  isClientError() {
+    return this.statusCode !== void 0 && this.statusCode >= 400 && this.statusCode < 500;
+  }
+  /**
+   * Check if error is a server-side error (5xx)
+   */
+  isServerError() {
+    return this.statusCode !== void 0 && this.statusCode >= 500;
+  }
+  /**
+   * Get a user-friendly error message
+   */
+  getUserMessage() {
+    switch (this.type) {
+      case "NetworkError":
+        return "Unable to connect to the BMLT server. Please check your internet connection and try again.";
+      case "TimeoutError":
+        return "The request timed out. Please try again later.";
+      case "RateLimitError":
+        return "Too many requests. Please wait a moment and try again.";
+      case "GeocodingError":
+        return "Unable to find the specified address. Please check the address and try again.";
+      case "ValidationError":
+        return "Invalid input provided. Please check your parameters and try again.";
+      case "AuthenticationError":
+        return "Authentication failed. Please check your credentials.";
+      case "ServerError":
+        return "The BMLT server encountered an error. Please try again later.";
+      case "ApiError":
+        return this.statusCode === 404 ? "The requested resource was not found." : "An error occurred while communicating with the BMLT server.";
+      case "ConfigurationError":
+        return "Invalid configuration. Please check your settings.";
+      default:
+        return this.message || "An unexpected error occurred.";
+    }
+  }
+  /**
+   * Convert error to JSON for logging
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      type: this.type,
+      message: this.message,
+      statusCode: this.statusCode,
+      response: this.response,
+      context: this.context,
+      stack: this.stack,
+      originalError: this.originalError ? {
+        name: this.originalError.name,
+        message: this.originalError.message,
+        stack: this.originalError.stack
+      } : void 0
+    };
+  }
+}
+class I {
+  static createApiError(e, t, i, n) {
+    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, {
+      statusCode: t,
+      response: i,
+      originalError: n
+    });
+  }
+  static createNetworkError(e, t) {
+    return new b("NetworkError", e, {
+      originalError: t
+    });
+  }
+  static createTimeoutError(e, t) {
+    return new b("TimeoutError", e, {
+      originalError: t
+    });
+  }
+  static createValidationError(e, t) {
+    return new b("ValidationError", e, {
+      context: t
+    });
+  }
+  static createGeocodingError(e, t, i) {
+    return new b("GeocodingError", e, {
+      originalError: t,
+      context: i
+    });
+  }
+  static createRateLimitError(e, t, i) {
+    return new b("RateLimitError", e, {
+      statusCode: t,
+      response: i
+    });
+  }
+  static createConfigurationError(e, t) {
+    return new b("ConfigurationError", e, {
+      context: t
+    });
+  }
+}
+class J {
+  /**
+   * Handle and transform fetch errors
+   */
+  static handleFetchError(e, t) {
+    if (e instanceof Error && e.name === "AbortError")
+      return I.createTimeoutError("Request timeout", e);
+    if (e instanceof TypeError)
+      return I.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 e instanceof Error ? I.createApiError(e.message, void 0, void 0, e) : I.createApiError("Unknown error occurred", void 0, void 0, new Error(String(e)));
+  }
+  /**
+   * @deprecated Use handleFetchError instead
+   */
+  static handleAxiosError(e) {
+    return J.handleFetchError(e);
+  }
+  /**
+   * Handle validation errors with detailed context
+   */
+  static handleValidationError(e, t, i, n) {
+    let a = `Invalid ${e}: expected ${i}`;
+    return n && n.length > 0 && (a += ` (${n.join(", ")})`), I.createValidationError(a, {
+      field: e,
+      value: t,
+      expectedType: i,
+      constraints: n
+    });
+  }
+  /**
+   * Handle endpoint validation errors
+   */
+  static handleEndpointError(e, t) {
+    const i = `Invalid endpoint/format combination: ${e} with ${t}`;
+    return I.createValidationError(i, {
+      endpoint: e,
+      format: t
+    });
+  }
+  /**
+   * Handle URL validation errors
+   */
+  static handleUrlError(e, t) {
+    const i = `Invalid URL: ${t}`;
+    return I.createValidationError(i, {
+      url: e,
+      reason: t
+    });
+  }
+  /**
+   * Handle coordinate validation errors
+   */
+  static handleCoordinateError(e, t, i) {
+    const n = i || "Invalid coordinates provided";
+    return I.createValidationError(n, {
+      latitude: e,
+      longitude: t,
+      reason: i
+    });
+  }
+  /**
+   * Wrap and enhance existing errors
+   */
+  static wrapError(e, t, i) {
+    const n = `${t}: ${e.message}`;
+    return e instanceof b ? new b(e.type, n, {
+      statusCode: e.statusCode,
+      response: e.response,
+      originalError: e.originalError || e,
+      context: {
+        ...e.context,
+        ...i
+      }
+    }) : I.createApiError(n, void 0, void 0, e);
+  }
+}
+class it {
+  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++)
+      try {
+        return await e();
+      } catch (h) {
+        const f = h instanceof b ? h : J.wrapError(h, "Operation failed");
+        if (u = f, c === 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));
+      }
+    throw u;
+  }
+}
+class je {
+  constructor(e = {}) {
+    const {
+      retryCount: t = 3,
+      timeout: i = 1e4,
+      userAgent: n = "bmlt-query-client/1.0.0",
+      countryCode: a = "us",
+      viewbox: s,
+      bounded: o = !1,
+      intervalCap: u = 1,
+      interval: c = 1e3,
+      // 1 second between requests
+      concurrency: h = 1,
+      carryoverConcurrencyCount: f = !1,
+      ...p
+    } = e;
+    this.defaultOptions = {
+      retryCount: t,
+      timeout: i,
+      userAgent: n,
+      countryCode: a,
+      viewbox: s,
+      bounded: o
+    }, this.baseURL = "https://nominatim.openstreetmap.org", this.queue = new Qe({
+      intervalCap: u,
+      interval: c,
+      concurrency: h,
+      carryoverConcurrencyCount: f,
+      ...p
+    });
+  }
+  /**
+   * Make a fetch request with timeout and error handling
+   */
+  async fetchWithTimeout(e, t, i) {
+    const n = new AbortController(), a = setTimeout(() => n.abort(), t);
+    try {
+      const s = await fetch(e, {
+        method: "GET",
+        headers: {
+          "User-Agent": i
+        },
+        signal: n.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 (s.status >= 400) {
+          const u = new Error(
+            `Geocoding service error: ${s.status} ${s.statusText}`
+          );
+          throw u.name = "GeocodingError", u.statusCode = s.status, u;
+        }
+      }
+      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;
+      }
+      if (s instanceof TypeError) {
+        const o = new Error("Network error occurred during geocoding");
+        throw o.name = "NetworkError", o;
+      }
+      throw s;
+    } finally {
+      clearTimeout(a);
+    }
+  }
+  /**
+   * Geocode an address using Nominatim
+   */
+  async geocode(e, t = {}) {
+    const i = { ...this.defaultOptions, ...t };
+    return this.queue.add(async () => me(
+      async () => {
+        try {
+          const n = {
+            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));
+          const a = new URL(`${this.baseURL}/search`);
+          Object.entries(n).forEach(([c, h]) => {
+            a.searchParams.append(c, String(h));
+          });
+          const s = await this.fetchWithTimeout(
+            a.toString(),
+            i.timeout,
+            i.userAgent
+          );
+          if (!s || s.length === 0)
+            throw new b(
+              Ne.GEOCODING_ERROR,
+              `No results found for address: ${e}`
+            );
+          const o = s[0], u = {
+            latitude: parseFloat(o.lat),
+            longitude: parseFloat(o.lon)
+          };
+          if (isNaN(u.latitude) || isNaN(u.longitude)) {
+            const c = new Error("Invalid coordinates received from geocoding service");
+            throw c.name = "GeocodingError", c;
+          }
+          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;
+          }
+          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
+            } : void 0
+          };
+        } catch (n) {
+          throw n;
+        }
+      },
+      {
+        retries: i.retryCount,
+        factor: 2,
+        minTimeout: 1e3,
+        maxTimeout: 1e4,
+        onFailedAttempt: (n) => {
+          console.warn(
+            `Geocoding attempt ${n.attemptNumber} failed. ${n.retriesLeft} retries left. Error: ${n.message}`
+          );
+        }
+      }
+    ));
+  }
+  /**
+   * Batch geocode multiple addresses
+   */
+  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))
+    );
+    return (await Promise.all(i)).filter((a) => a !== null);
+  }
+  /**
+   * Reverse geocode coordinates to an address
+   */
+  async reverseGeocode(e, t = {}) {
+    const i = { ...this.defaultOptions, ...t };
+    return this.queue.add(async () => me(
+      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 a = await this.fetchWithTimeout(
+            n.toString(),
+            i.timeout,
+            i.userAgent
+          );
+          if (!a) {
+            const o = new Error(
+              `No results found for coordinates: ${e.latitude}, ${e.longitude}`
+            );
+            throw o.name = "GeocodingError", o;
+          }
+          const s = a;
+          return {
+            coordinates: {
+              latitude: parseFloat(s.lat),
+              longitude: parseFloat(s.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
+            } : void 0
+          };
+        } catch (n) {
+          throw n;
+        }
+      },
+      {
+        retries: i.retryCount,
+        factor: 2,
+        minTimeout: 1e3,
+        maxTimeout: 1e4
+      }
+    ));
+  }
+  /**
+   * Get the current queue size
+   */
+  getQueueSize() {
+    return this.queue.size;
+  }
+  /**
+   * Get the number of pending operations
+   */
+  getPendingCount() {
+    return this.queue.pending;
+  }
+  /**
+   * Clear the queue
+   */
+  clearQueue() {
+    this.queue.clear();
+  }
+  /**
+   * Set concurrency limit
+   */
+  setConcurrency(e) {
+    this.queue.concurrency = e;
+  }
+}
+var y = /* @__PURE__ */ ((r) => (r.JSON = "json", r.JSONP = "jsonp", r.TSML = "tsml", r.CSV = "csv", r))(y || {}), _ = /* @__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()}`;
+}
+function nt(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;
+          }
+          return n;
+        });
+      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;
+      } else
+        e[t] = i;
+  }), e;
+}
+function Ze(r, e) {
+  const i = {
+    [_.GET_SEARCH_RESULTS]: [y.JSON, y.JSONP, y.TSML],
+    [_.GET_FORMATS]: [y.JSON, y.JSONP],
+    [_.GET_SERVICE_BODIES]: [y.JSON, y.JSONP],
+    [_.GET_CHANGES]: [y.JSON, y.JSONP],
+    [_.GET_FIELD_KEYS]: [y.JSON, y.JSONP],
+    [_.GET_FIELD_VALUES]: [y.JSON, y.JSONP],
+    [_.GET_NAWS_DUMP]: [y.CSV],
+    [_.GET_SERVER_INFO]: [y.JSON, y.JSONP],
+    [_.GET_COVERAGE_AREA]: [y.JSON, y.JSONP]
+  }[r];
+  if (!i.includes(e))
+    throw new Error(
+      `Invalid format '${e}' for endpoint '${r}'. Valid formats: ${i.join(", ")}`
+    );
+}
+function ge(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}`);
+  }
+}
+function st(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) {
+  const t = {};
+  if (typeof r == "number") {
+    if (r < 0 || r > 23)
+      throw new Error("Hours must be between 0 and 23");
+    t.hours = r;
+  }
+  if (typeof e == "number") {
+    if (e < 0 || e > 59)
+      throw new Error("Minutes must be between 0 and 59");
+    t.minutes = e;
+  }
+  return t;
+}
+function et(r, e) {
+  if (typeof r != "number" || isNaN(r))
+    throw new Error("Latitude must be a valid number");
+  if (typeof e != "number" || isNaN(e))
+    throw new Error("Longitude must be a valid number");
+  if (r < -90 || r > 90)
+    throw new Error("Latitude must be between -90 and 90 degrees");
+  if (e < -180 || e > 180)
+    throw new Error("Longitude must be between -180 and 180 degrees");
+}
+function B(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) {
+  return r * 1.60934;
+}
+function ut(r) {
+  return r / 1.60934;
+}
+class ct {
+  constructor(e) {
+    const {
+      rootServerURL: t,
+      defaultFormat: i = y.JSON,
+      timeout: n = 3e4,
+      userAgent: a = "bmlt-query-client/1.0.0",
+      geocodingOptions: s = {},
+      enableGeocoding: o = !0
+    } = e;
+    this.rootServerURL = ge(t), this.defaultFormat = i, this.timeout = n, this.userAgent = a, o && (this.geocodingService = new je(s));
+  }
+  /**
+   * Make a request to the BMLT API
+   */
+  async makeRequest(e, t = {}, i = this.defaultFormat) {
+    let n;
+    try {
+      Ze(e, i);
+      const a = Xe({
+        rootServerURL: this.rootServerURL,
+        format: i,
+        endpoint: e,
+        parameters: t
+      }), s = new AbortController(), o = setTimeout(() => s.abort(), this.timeout);
+      try {
+        n = await fetch(a, {
+          method: "GET",
+          headers: {
+            "User-Agent": this.userAgent
+          },
+          signal: s.signal
+        });
+      } finally {
+        clearTimeout(o);
+      }
+      if (!n.ok)
+        throw J.handleFetchError(
+          new Error(`HTTP ${n.status}: ${n.statusText}`),
+          n
+        );
+      const u = await n.text();
+      if (i === y.CSV)
+        return u;
+      if (i === y.JSONP) {
+        const c = t.callback || "callback", h = u.match(new RegExp(`${c}\\((.+)\\);?$`));
+        if (!h)
+          throw new Error("Invalid JSONP response format");
+        return JSON.parse(h[1]);
+      }
+      return i === y.JSON || i === y.TSML ? JSON.parse(u) : u;
+    } catch (a) {
+      throw J.handleFetchError(a, n);
+    }
+  }
+  /**
+   * Search for meetings
+   */
+  async searchMeetings(e = {}) {
+    const { format: t = this.defaultFormat, ...i } = e;
+    return this.makeRequest(_.GET_SEARCH_RESULTS, i, t);
+  }
+  /**
+   * Search for meetings by geographic location using geocoding
+   */
+  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,
+      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);
+  }
+  /**
+   * Search for meetings by coordinates
+   */
+  async searchMeetingsByCoordinates(e, t, i, n = {}) {
+    et(e.latitude, e.longitude);
+    const a = {
+      ...n,
+      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);
+  }
+  /**
+   * Get available meeting formats
+   */
+  async getFormats(e = {}) {
+    const { format: t = this.defaultFormat, ...i } = e;
+    return this.makeRequest(_.GET_FORMATS, i, t);
+  }
+  /**
+   * Get service bodies
+   */
+  async getServiceBodies(e = {}) {
+    const { format: t = this.defaultFormat, ...i } = e;
+    return this.makeRequest(_.GET_SERVICE_BODIES, i, t);
+  }
+  /**
+   * Get meeting changes within a date range
+   */
+  async getChanges(e = {}) {
+    const { format: t = this.defaultFormat, ...i } = e;
+    return this.makeRequest(_.GET_CHANGES, i, t);
+  }
+  /**
+   * Get available field keys
+   */
+  async getFieldKeys() {
+    return this.makeRequest(_.GET_FIELD_KEYS);
+  }
+  /**
+   * Get field values for a specific field key
+   */
+  async getFieldValues(e) {
+    const { format: t = this.defaultFormat, ...i } = e;
+    return this.makeRequest(_.GET_FIELD_VALUES, i, t);
+  }
+  /**
+   * Get NAWS dump for a service body (CSV format only)
+   */
+  async getNAWSDump(e) {
+    return this.makeRequest(_.GET_NAWS_DUMP, e, y.CSV);
+  }
+  /**
+   * Get server information
+   */
+  async getServerInfo() {
+    return this.makeRequest(_.GET_SERVER_INFO);
+  }
+  /**
+   * Get server coverage area
+   */
+  async getCoverageArea() {
+    return this.makeRequest(_.GET_COVERAGE_AREA);
+  }
+  /**
+   * Geocode an address using the built-in geocoding service
+   */
+  async geocodeAddress(e, t) {
+    if (!this.geocodingService)
+      throw new Error("Geocoding is not enabled. Initialize client with enableGeocoding: true");
+    return this.geocodingService.geocode(e, t);
+  }
+  /**
+   * Reverse geocode coordinates to an address
+   */
+  async reverseGeocode(e, t) {
+    if (!this.geocodingService)
+      throw new Error("Geocoding is not enabled. Initialize client with enableGeocoding: true");
+    return this.geocodingService.reverseGeocode(e, t);
+  }
+  /**
+   * Get the root server URL
+   */
+  getRootServerURL() {
+    return this.rootServerURL;
+  }
+  /**
+   * Update the root server URL
+   */
+  setRootServerURL(e) {
+    this.rootServerURL = ge(e);
+  }
+  /**
+   * Get the default data format
+   */
+  getDefaultFormat() {
+    return this.defaultFormat;
+  }
+  /**
+   * Set the default data format
+   */
+  setDefaultFormat(e) {
+    this.defaultFormat = e;
+  }
+  /**
+   * Get geocoding service statistics
+   */
+  getGeocodingStats() {
+    return this.geocodingService ? {
+      queueSize: this.geocodingService.getQueueSize(),
+      pendingCount: this.geocodingService.getPendingCount()
+    } : null;
+  }
+  /**
+   * Clear the geocoding queue
+   */
+  clearGeocodingQueue() {
+    this.geocodingService && this.geocodingService.clearQueue();
+  }
+}
+class C {
+  constructor(e) {
+    this.params = {}, this.client = e;
+  }
+  /**
+   * Include or exclude specific meeting IDs
+   */
+  meetingIds(e, t = !1) {
+    return Array.isArray(e) ? this.params.meeting_ids = t ? e.map((i) => -i) : e : this.params.meeting_ids = t ? -e : e, this;
+  }
+  /**
+   * Include meetings on specific weekdays
+   */
+  onWeekdays(...e) {
+    return this.params.weekdays = e.length === 1 ? e[0] : e, this;
+  }
+  /**
+   * Exclude meetings on specific weekdays
+   */
+  notOnWeekdays(...e) {
+    const t = e.map((i) => -i);
+    return this.params.weekdays = t.length === 1 ? t[0] : t, this;
+  }
+  /**
+   * Filter by venue types
+   */
+  venueTypes(...e) {
+    return this.params.venue_types = e.length === 1 ? e[0] : e, this;
+  }
+  /**
+   * Include only in-person meetings
+   */
+  inPersonOnly() {
+    return this.venueTypes(F.IN_PERSON);
+  }
+  /**
+   * Include only virtual meetings
+   */
+  virtualOnly() {
+    return this.venueTypes(F.VIRTUAL);
+  }
+  /**
+   * Include only hybrid meetings
+   */
+  hybridOnly() {
+    return this.venueTypes(F.HYBRID);
+  }
+  /**
+   * Include virtual and hybrid meetings
+   */
+  virtualOrHybrid() {
+    return this.venueTypes(F.VIRTUAL, F.HYBRID);
+  }
+  /**
+   * Filter by meeting formats
+   */
+  formats(e, t = !1) {
+    return Array.isArray(e) ? this.params.formats = t ? e.map((i) => -i) : e : this.params.formats = t ? -e : e, this;
+  }
+  /**
+   * Use OR logic for format matching instead of AND
+   */
+  anyFormat() {
+    return this.params.formats_comparison_operator = "OR", this;
+  }
+  /**
+   * Filter by service bodies
+   */
+  serviceBodies(e, t = !1) {
+    return Array.isArray(e) ? this.params.services = t ? e.map((i) => -i) : e : this.params.services = t ? -e : e, this;
+  }
+  /**
+   * Include child service bodies
+   */
+  includeChildServiceBodies() {
+    return this.params.recursive = !0, this;
+  }
+  /**
+   * Search for specific text
+   */
+  searchText(e) {
+    return this.params.SearchString = e, this;
+  }
+  /**
+   * Meetings starting after specific time
+   */
+  startingAfter(e, t = 0) {
+    return this.params.StartsAfterH = e, this.params.StartsAfterM = t, this;
+  }
+  /**
+   * Meetings starting before specific time
+   */
+  startingBefore(e, t = 0) {
+    return this.params.StartsBeforeH = e, this.params.StartsBeforeM = t, this;
+  }
+  /**
+   * Meetings ending before specific time
+   */
+  endingBefore(e, t = 0) {
+    return this.params.EndsBeforeH = e, this.params.EndsBeforeM = t, this;
+  }
+  /**
+   * Minimum meeting duration
+   */
+  minimumDuration(e = 0, t = 0) {
+    return e > 0 && (this.params.MinDurationH = e), t > 0 && (this.params.MinDurationM = t), this;
+  }
+  /**
+   * Maximum meeting duration
+   */
+  maximumDuration(e = 0, t = 0) {
+    return e > 0 && (this.params.MaxDurationH = e), t > 0 && (this.params.MaxDurationM = t), this;
+  }
+  /**
+   * Search within geographic area by coordinates
+   */
+  nearCoordinates(e, t, i) {
+    return this.params.lat_val = e.latitude, this.params.long_val = e.longitude, t !== void 0 ? this.params.geo_width = t : i !== void 0 && (this.params.geo_width_km = i), this;
+  }
+  /**
+   * Search for specific field value
+   */
+  fieldValue(e, t) {
+    return this.params.meeting_key = e, this.params.meeting_key_value = t, this;
+  }
+  /**
+   * Return only specific fields
+   */
+  selectFields(...e) {
+    return this.params.data_field_key = e.join(","), this;
+  }
+  /**
+   * Sort results by specific fields
+   */
+  sortBy(...e) {
+    return this.params.sort_keys = e.join(","), this;
+  }
+  /**
+   * Sort by predefined aliases
+   */
+  sortByAlias(e) {
+    return this.params.sort_key = e, this;
+  }
+  /**
+   * Sort by distance (requires geographic search)
+   */
+  sortByDistance() {
+    return this.params.sort_results_by_distance = !0, this;
+  }
+  /**
+   * Set pagination
+   */
+  paginate(e, t = 1) {
+    return this.params.page_size = e, this.params.page_num = t, this;
+  }
+  /**
+   * Include unpublished meetings
+   */
+  includeUnpublished() {
+    return this.params.advanced_published = 0, this;
+  }
+  /**
+   * Include only unpublished meetings
+   */
+  unpublishedOnly() {
+    return this.params.advanced_published = -1, this;
+  }
+  /**
+   * Set language for format names
+   */
+  language(e) {
+    return this.params.lang_enum = e, this;
+  }
+  /**
+   * Set response format
+   */
+  format(e) {
+    return this.params.format = e, this;
+  }
+  /**
+   * Include formats used in search results
+   */
+  includeFormats() {
+    return this.params.get_used_formats = !0, this;
+  }
+  /**
+   * Return only formats (requires includeFormats)
+   */
+  formatsOnly() {
+    return this.params.get_used_formats = !0, this.params.get_formats_only = !0, this;
+  }
+  /**
+   * Filter by root server IDs (aggregator mode)
+   */
+  rootServerIds(e, t = !1) {
+    return Array.isArray(e) ? this.params.root_server_ids = t ? e.map((i) => -i) : e : this.params.root_server_ids = t ? -e : e, this;
+  }
+  /**
+   * Get the current query parameters
+   */
+  getParams() {
+    return { ...this.params };
+  }
+  /**
+   * Reset the query builder
+   */
+  reset() {
+    return this.params = {}, this;
+  }
+  /**
+   * Clone the current query builder
+   */
+  clone() {
+    const e = new C(this.client);
+    return e.params = { ...this.params }, e;
+  }
+  /**
+   * Execute the search and return results
+   */
+  async execute() {
+    return this.client.searchMeetings(this.params);
+  }
+  /**
+   * Execute the search by geocoding an address first
+   */
+  async executeNearAddress(e, t, i, n = !0) {
+    return this.client.searchMeetingsByAddress({
+      address: e,
+      radiusMiles: t,
+      radiusKm: i,
+      sortByDistance: n,
+      searchParams: this.params
+    });
+  }
+}
+class ht {
+  constructor(e) {
+    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);
+  }
+  /**
+   * Search for weekend meetings
+   */
+  weekend() {
+    return new C(this.client).onWeekdays(G.SATURDAY, G.SUNDAY);
+  }
+  /**
+   * Search for weekday meetings
+   */
+  weekdays() {
+    return new C(this.client).onWeekdays(
+      G.MONDAY,
+      G.TUESDAY,
+      G.WEDNESDAY,
+      G.THURSDAY,
+      G.FRIDAY
+    );
+  }
+  /**
+   * Search for evening meetings (after 5 PM)
+   */
+  evening() {
+    return new C(this.client).startingAfter(17);
+  }
+  /**
+   * Search for morning meetings (before 12 PM)
+   */
+  morning() {
+    return new C(this.client).startingBefore(12);
+  }
+  /**
+   * Search for virtual meetings only
+   */
+  virtual() {
+    return new C(this.client).virtualOnly();
+  }
+  /**
+   * Search for in-person meetings only
+   */
+  inPerson() {
+    return new C(this.client).inPersonOnly();
+  }
+  /**
+   * Search by meeting name or location
+   */
+  byText(e) {
+    return new C(this.client).searchText(e);
+  }
+}
+export {
+  ct as BmltClient,
+  y 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,
+  ge as validateRootServerURL
+};
+//# sourceMappingURL=app.js.map