@leancodepl/feature-flags-react-client 9.7.2 → 9.7.3

package/dist/index.js

@@ -0,0 +1,2406 @@
+var Ut = Object.defineProperty, Gt = Object.defineProperties, Vt = Object.getOwnPropertyDescriptors, et = Object.getOwnPropertySymbols, zt = Object.prototype.hasOwnProperty, Wt = Object.prototype.propertyIsEnumerable, tt = (t, r, n) => r in t ? Ut(t, r, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[r] = n, Ne = (t, r) => {
+  for (var n in r || (r = {}))
+    zt.call(r, n) && tt(t, n, r[n]);
+  if (et)
+    for (var n of et(r))
+      Wt.call(r, n) && tt(t, n, r[n]);
+  return t;
+}, ke = (t, r) => Gt(t, Vt(r)), le = (t, r, n) => new Promise((i, a) => {
+  var c = (E) => {
+    try {
+      p(n.next(E));
+    } catch (y) {
+      a(y);
+    }
+  }, h = (E) => {
+    try {
+      p(n.throw(E));
+    } catch (y) {
+      a(y);
+    }
+  }, p = (E) => E.done ? i(E.value) : Promise.resolve(E.value).then(c, h);
+  p((n = n.apply(t, r)).next());
+}), qt = class {
+  constructor() {
+    this.data = /* @__PURE__ */ new Map();
+  }
+  set(t, r) {
+    this.data.set(t, r);
+  }
+  get(t) {
+    return this.data.get(t);
+  }
+  has(t) {
+    return this.data.has(t);
+  }
+  delete(t) {
+    return this.data.delete(t);
+  }
+  clear() {
+    this.data.clear();
+  }
+}, we = {
+  /**
+   * The resolved value was the result of the flag being disabled in the management system.
+   */
+  DISABLED: "DISABLED",
+  /**
+   * The resolved value is non-authoritative or possibly out of date.
+   */
+  STALE: "STALE",
+  /**
+   * The resolved value was the result of an error.
+   *
+   * Note: The `errorCode` and `errorMessage` fields may contain additional details of this error.
+   */
+  ERROR: "ERROR"
+}, vt = /* @__PURE__ */ ((t) => (t.PROVIDER_NOT_READY = "PROVIDER_NOT_READY", t.PROVIDER_FATAL = "PROVIDER_FATAL", t.FLAG_NOT_FOUND = "FLAG_NOT_FOUND", t.PARSE_ERROR = "PARSE_ERROR", t.TYPE_MISMATCH = "TYPE_MISMATCH", t.TARGETING_KEY_MISSING = "TARGETING_KEY_MISSING", t.INVALID_CONTEXT = "INVALID_CONTEXT", t.GENERAL = "GENERAL", t))(vt || {}), te = class pt extends Error {
+  constructor(r, n) {
+    super(r), Object.setPrototypeOf(this, pt.prototype), this.name = "OpenFeatureError", this.cause = n?.cause;
+  }
+}, Bt = class _t extends te {
+  constructor(r, n) {
+    super(r, n), Object.setPrototypeOf(this, _t.prototype), this.name = "FlagNotFoundError", this.code = "FLAG_NOT_FOUND";
+  }
+}, gt = class Et extends te {
+  constructor(r, n) {
+    super(r, n), Object.setPrototypeOf(this, Et.prototype), this.name = "GeneralError", this.code = "GENERAL";
+  }
+}, Qt = class mt extends te {
+  constructor(r, n) {
+    super(r, n), Object.setPrototypeOf(this, mt.prototype), this.name = "InvalidContextError", this.code = "INVALID_CONTEXT";
+  }
+}, Kt = class yt extends te {
+  constructor(r, n) {
+    super(r, n), Object.setPrototypeOf(this, yt.prototype), this.name = "ParseError", this.code = "PARSE_ERROR";
+  }
+}, Rt = class Ot extends te {
+  constructor(r, n) {
+    super(r, n), Object.setPrototypeOf(this, Ot.prototype), this.name = "ProviderFatalError", this.code = "PROVIDER_FATAL";
+  }
+}, Ct = class wt extends te {
+  constructor(r, n) {
+    super(r, n), Object.setPrototypeOf(this, wt.prototype), this.name = "ProviderNotReadyError", this.code = "PROVIDER_NOT_READY";
+  }
+}, Xt = class At extends te {
+  constructor(r, n) {
+    super(r, n), Object.setPrototypeOf(this, At.prototype), this.name = "TargetingKeyMissingError", this.code = "TARGETING_KEY_MISSING";
+  }
+}, Zt = class Pt extends te {
+  constructor(r, n) {
+    super(r, n), Object.setPrototypeOf(this, Pt.prototype), this.name = "TypeMismatchError", this.code = "TYPE_MISMATCH";
+  }
+}, Jt = (t, r) => {
+  switch (t) {
+    case "FLAG_NOT_FOUND":
+      return new Bt(r);
+    case "PARSE_ERROR":
+      return new Kt(r);
+    case "TYPE_MISMATCH":
+      return new Zt(r);
+    case "TARGETING_KEY_MISSING":
+      return new Xt(r);
+    case "INVALID_CONTEXT":
+      return new Qt(r);
+    case "PROVIDER_NOT_READY":
+      return new Ct(r);
+    case "PROVIDER_FATAL":
+      return new Rt(r);
+    default:
+      return new gt(r);
+  }
+}, ee = /* @__PURE__ */ ((t) => (t.NOT_READY = "NOT_READY", t.READY = "READY", t.ERROR = "ERROR", t.STALE = "STALE", t.FATAL = "FATAL", t.RECONCILING = "RECONCILING", t))(ee || {}), I = /* @__PURE__ */ ((t) => (t.Ready = "PROVIDER_READY", t.Error = "PROVIDER_ERROR", t.ConfigurationChanged = "PROVIDER_CONFIGURATION_CHANGED", t.ContextChanged = "PROVIDER_CONTEXT_CHANGED", t.Reconciling = "PROVIDER_RECONCILING", t.Stale = "PROVIDER_STALE", t))(I || {}), er = {
+  READY: "PROVIDER_READY",
+  ERROR: "PROVIDER_ERROR",
+  FATAL: "PROVIDER_ERROR",
+  STALE: "PROVIDER_STALE",
+  RECONCILING: "PROVIDER_RECONCILING",
+  NOT_READY: void 0
+}, bt = (t, r) => !r && t === "PROVIDER_READY" || er[r] === t, Tt = class {
+  error(...t) {
+    console.error(...t);
+  }
+  warn(...t) {
+    console.warn(...t);
+  }
+  info() {
+  }
+  debug() {
+  }
+}, tr = ["error", "warn", "info", "debug"], Le = class {
+  constructor(t) {
+    this.fallbackLogger = new Tt();
+    try {
+      for (const r of tr)
+        if (!t[r] || typeof t[r] != "function")
+          throw new Error(`The provided logger is missing the ${r} method.`);
+      this.logger = t;
+    } catch (r) {
+      console.error(r), console.error("Falling back to the default logger."), this.logger = this.fallbackLogger;
+    }
+  }
+  error(...t) {
+    this.log("error", ...t);
+  }
+  warn(...t) {
+    this.log("warn", ...t);
+  }
+  info(...t) {
+    this.log("info", ...t);
+  }
+  debug(...t) {
+    this.log("debug", ...t);
+  }
+  log(t, ...r) {
+    try {
+      this.logger[t](...r);
+    } catch {
+      this.fallbackLogger[t](...r);
+    }
+  }
+}, rr = class {
+  constructor(t) {
+    this.globalLogger = t, this._handlers = {
+      PROVIDER_CONFIGURATION_CHANGED: /* @__PURE__ */ new WeakMap(),
+      PROVIDER_CONTEXT_CHANGED: /* @__PURE__ */ new WeakMap(),
+      PROVIDER_READY: /* @__PURE__ */ new WeakMap(),
+      PROVIDER_ERROR: /* @__PURE__ */ new WeakMap(),
+      PROVIDER_STALE: /* @__PURE__ */ new WeakMap(),
+      PROVIDER_RECONCILING: /* @__PURE__ */ new WeakMap()
+    };
+  }
+  // here we use E, to restrict the events a provider can manually emit (PROVIDER_CONTEXT_CHANGED is emitted by the SDK)
+  emit(t, r) {
+    this.eventEmitter.emit(t, r);
+  }
+  addHandler(t, r) {
+    const n = (a) => le(this, null, function* () {
+      var c;
+      try {
+        yield r(a);
+      } catch (h) {
+        (c = this._logger) == null || c.error("Error running event handler:", h);
+      }
+    }), i = this._handlers[t].get(r);
+    this._handlers[t].set(r, [...i || [], n]), this.eventEmitter.on(t, n);
+  }
+  removeHandler(t, r) {
+    const n = this._handlers[t].get(r);
+    if (n) {
+      const i = n.pop();
+      i && this.eventEmitter.removeListener(t, i);
+    }
+  }
+  removeAllHandlers(t) {
+    t ? this.eventEmitter.removeAllListeners(t) : this.eventEmitter.removeAllListeners();
+  }
+  getHandlers(t) {
+    return this.eventEmitter.listeners(t);
+  }
+  setLogger(t) {
+    return this._eventLogger = new Le(t), this;
+  }
+  get _logger() {
+    var t, r;
+    return (r = this._eventLogger) != null ? r : (t = this.globalLogger) == null ? void 0 : t.call(this);
+  }
+};
+function nr(t) {
+  return typeof t == "string";
+}
+function ce(t) {
+  return nr(t) ? t : void 0;
+}
+function or(t) {
+  return typeof t == "object";
+}
+function z(t) {
+  return or(t) ? t : void 0;
+}
+function rt(t) {
+  return typeof t < "u" && t !== null;
+}
+var Ie = class {
+  constructor(t, r, n) {
+    this._provider = t, this._status = r, this._pendingContextChanges = 0;
+    var i, a, c;
+    (i = t.events) == null || i.addHandler("PROVIDER_READY", () => {
+      this._status = n.READY;
+    }), (a = t.events) == null || a.addHandler("PROVIDER_STALE", () => {
+      this._status = n.STALE;
+    }), (c = t.events) == null || c.addHandler("PROVIDER_ERROR", (h) => {
+      h?.errorCode === "PROVIDER_FATAL" ? this._status = n.FATAL : this._status = n.ERROR;
+    });
+  }
+  get provider() {
+    return this._provider;
+  }
+  set provider(t) {
+    this._provider = t;
+  }
+  get status() {
+    return this._status;
+  }
+  set status(t) {
+    this._status = t;
+  }
+  get allContextChangesSettled() {
+    return this._pendingContextChanges === 0;
+  }
+  incrementPendingContextChanges() {
+    this._pendingContextChanges++;
+  }
+  decrementPendingContextChanges() {
+    this._pendingContextChanges--;
+  }
+}, sr = class {
+  constructor(t) {
+    this._hooks = [], this._context = {}, this._logger = new Tt(), this._clientEventHandlers = /* @__PURE__ */ new Map(), this._domainScopedContext = /* @__PURE__ */ new Map(), this._clientEvents = /* @__PURE__ */ new Map(), this._runsOn = t;
+  }
+  addHooks(...t) {
+    return this._hooks = [...this._hooks, ...t], this;
+  }
+  getHooks() {
+    return this._hooks;
+  }
+  clearHooks() {
+    return this._hooks = [], this;
+  }
+  setLogger(t) {
+    return this._logger = new Le(t), this;
+  }
+  /**
+   * Get metadata about the default provider.
+   * @returns {ProviderMetadata} Provider Metadata
+   */
+  get providerMetadata() {
+    return this.getProviderMetadata();
+  }
+  /**
+   * Get metadata about a registered provider using the client name.
+   * An unbound or empty client name will return metadata from the default provider.
+   * @param {string} domain An identifier which logically binds clients with providers
+   * @returns {ProviderMetadata} Provider Metadata
+   */
+  getProviderMetadata(t) {
+    return this.getProviderForClient(t).metadata;
+  }
+  /**
+   * Adds a handler for the given provider event type.
+   * The handlers are called in the order they have been added.
+   * API (global) events run for all providers.
+   * @param {AnyProviderEvent} eventType The provider event type to listen to
+   * @param {EventHandler} handler The handler to run on occurrence of the event type
+   * @param {EventOptions} options Optional options such as signal for aborting
+   */
+  addHandler(t, r, n) {
+    [.../* @__PURE__ */ new Map([[void 0, this._defaultProvider]]), ...this._domainScopedProviders].forEach((i) => {
+      var a;
+      const c = i[0], h = i[1].provider, p = i[1].status;
+      if (bt(t, p))
+        try {
+          r({ domain: c, providerName: h.metadata.name });
+        } catch (y) {
+          (a = this._logger) == null || a.error("Error running event handler:", y);
+        }
+    }), this._apiEmitter.addHandler(t, r), n?.signal && typeof n.signal.addEventListener == "function" && n.signal.addEventListener("abort", () => {
+      this.removeHandler(t, r);
+    });
+  }
+  /**
+   * Removes a handler for the given provider event type.
+   * @param {AnyProviderEvent} eventType The provider event type to remove the listener for
+   * @param {EventHandler} handler The handler to remove for the provider event type
+   */
+  removeHandler(t, r) {
+    this._apiEmitter.removeHandler(t, r);
+  }
+  /**
+   * Removes all event handlers.
+   */
+  clearHandlers() {
+    this._apiEmitter.removeAllHandlers();
+  }
+  /**
+   * Gets the current handlers for the given provider event type.
+   * @param {AnyProviderEvent} eventType The provider event type to get the current handlers for
+   * @returns {EventHandler[]} The handlers currently attached to the given provider event type
+   */
+  getHandlers(t) {
+    return this._apiEmitter.getHandlers(t);
+  }
+  setAwaitableProvider(t, r) {
+    var n, i, a, c, h, p, E, y;
+    const f = ce(t), v = (n = z(t)) != null ? n : z(r);
+    if (!v) {
+      this._logger.debug("No provider defined, ignoring setProvider call");
+      return;
+    }
+    const _ = this.getProviderForClient(f), A = v.metadata.name;
+    if (_ === v) {
+      this._logger.debug("Provider is already set, ignoring setProvider call");
+      return;
+    }
+    if (!v.runsOn)
+      this._logger.debug(`Provider '${v.metadata.name}' has not defined its intended use.`);
+    else if (v.runsOn !== this._runsOn)
+      throw new gt(`Provider '${v.metadata.name}' is intended for use on the ${v.runsOn}.`);
+    const k = this.getAssociatedEventEmitters(f);
+    let N;
+    const $ = new Ie(
+      v,
+      this._statusEnumType.NOT_READY,
+      this._statusEnumType
+    );
+    return typeof v.initialize == "function" && !this.allProviders.includes(v) ? N = (h = (c = (a = v.initialize) == null ? void 0 : a.call(v, f ? (i = this._domainScopedContext.get(f)) != null ? i : this._context : this._context)) == null ? void 0 : c.then(() => {
+      var g;
+      $.status = this._statusEnumType.READY, this.getAssociatedEventEmitters(f).forEach((Y) => {
+        Y?.emit("PROVIDER_READY", { clientName: f, domain: f, providerName: A });
+      }), (g = this._apiEmitter) == null || g.emit("PROVIDER_READY", { clientName: f, domain: f, providerName: A });
+    })) == null ? void 0 : h.catch((g) => {
+      var Y;
+      throw g?.code === "PROVIDER_FATAL" ? $.status = this._statusEnumType.FATAL : $.status = this._statusEnumType.ERROR, this.getAssociatedEventEmitters(f).forEach((U) => {
+        U?.emit("PROVIDER_ERROR", {
+          clientName: f,
+          domain: f,
+          providerName: A,
+          message: g?.message
+        });
+      }), (Y = this._apiEmitter) == null || Y.emit("PROVIDER_ERROR", {
+        clientName: f,
+        domain: f,
+        providerName: A,
+        message: g?.message
+      }), g;
+    }) : ($.status = this._statusEnumType.READY, k.forEach((g) => {
+      g?.emit("PROVIDER_READY", { clientName: f, domain: f, providerName: A });
+    }), (p = this._apiEmitter) == null || p.emit("PROVIDER_READY", { clientName: f, domain: f, providerName: A })), f ? this._domainScopedProviders.set(f, $) : this._defaultProvider = $, this.transferListeners(_, v, f, k), this.allProviders.includes(_) || (y = (E = _?.onClose) == null ? void 0 : E.call(_)) == null || y.catch((g) => {
+      this._logger.error(`error closing provider: ${g?.message}, ${g?.stack}`);
+    }), N;
+  }
+  getProviderForClient(t) {
+    var r, n;
+    return t ? (n = (r = this._domainScopedProviders.get(t)) == null ? void 0 : r.provider) != null ? n : this._defaultProvider.provider : this._defaultProvider.provider;
+  }
+  buildAndCacheEventEmitterForClient(t) {
+    const r = this._clientEvents.get(t);
+    if (r)
+      return r;
+    const n = this._createEventEmitter();
+    this._clientEvents.set(t, n);
+    const i = this.getProviderForClient(t);
+    return Object.values(I).forEach(
+      (a) => {
+        var c;
+        return (c = i.events) == null ? void 0 : c.addHandler(a, (h) => le(this, null, function* () {
+          n.emit(a, ke(Ne({}, h), {
+            clientName: t,
+            domain: t,
+            providerName: i.metadata.name
+          }));
+        }));
+      }
+    ), n;
+  }
+  getUnboundEmitters() {
+    const t = [...this._domainScopedProviders.keys()];
+    return [
+      // all unbound, named emitters
+      ...[...this._clientEvents.keys()].filter(rt).filter((i) => !t.includes(i)).map((i) => this._clientEvents.get(i)),
+      // the default emitter
+      this._clientEvents.get(void 0)
+    ].filter(rt);
+  }
+  getAssociatedEventEmitters(t) {
+    return t ? [this.buildAndCacheEventEmitterForClient(t)] : this.getUnboundEmitters();
+  }
+  transferListeners(t, r, n, i) {
+    var a;
+    (a = this._clientEventHandlers.get(n)) == null || a.forEach((h) => {
+      var p;
+      return (p = t.events) == null ? void 0 : p.removeHandler(...h);
+    });
+    const c = Object.values(I).map((h) => [h, (E) => le(this, null, function* () {
+      i.forEach((y) => {
+        y?.emit(h, ke(Ne({}, E), { clientName: n, domain: n, providerName: r.metadata.name }));
+      }), this._apiEmitter.emit(h, ke(Ne({}, E), {
+        clientName: n,
+        domain: n,
+        providerName: r.metadata.name
+      }));
+    })]);
+    this._clientEventHandlers.set(n, c), c.forEach((h) => {
+      var p;
+      return (p = r.events) == null ? void 0 : p.addHandler(...h);
+    });
+  }
+  close() {
+    return le(this, null, function* () {
+      var t, r;
+      try {
+        yield (r = (t = this == null ? void 0 : this._defaultProvider.provider) == null ? void 0 : t.onClose) == null ? void 0 : r.call(t);
+      } catch (i) {
+        this.handleShutdownError(this._defaultProvider.provider, i);
+      }
+      const n = Array.from(this._domainScopedProviders);
+      yield Promise.all(
+        n.map((i) => le(this, [i], function* ([, a]) {
+          var c, h;
+          try {
+            yield (h = a == null ? void 0 : (c = a.provider).onClose) == null ? void 0 : h.call(c);
+          } catch (p) {
+            this.handleShutdownError(a?.provider, p);
+          }
+        }))
+      );
+    });
+  }
+  clearProvidersAndSetDefault(t) {
+    return le(this, null, function* () {
+      try {
+        yield this.close();
+      } catch {
+        this._logger.error("Unable to cleanly close providers. Resetting to the default configuration.");
+      } finally {
+        this._domainScopedProviders.clear(), this._defaultProvider = new Ie(
+          t,
+          this._statusEnumType.NOT_READY,
+          this._statusEnumType
+        );
+      }
+    });
+  }
+  get allProviders() {
+    return [
+      ...[...this._domainScopedProviders.values()].map((t) => t.provider),
+      this._defaultProvider.provider
+    ];
+  }
+  handleShutdownError(t, r) {
+    this._logger.error(`Error during shutdown of provider ${t.metadata.name}: ${r}`), this._logger.error(r?.stack);
+  }
+}, ir = Object.create, je = Object.defineProperty, ar = Object.defineProperties, ur = Object.getOwnPropertyDescriptor, lr = Object.getOwnPropertyDescriptors, St = Object.getOwnPropertyNames, nt = Object.getOwnPropertySymbols, Nt = Object.getPrototypeOf, kt = Object.prototype.hasOwnProperty, cr = Object.prototype.propertyIsEnumerable, fr = Reflect.get, ot = (t, r, n) => r in t ? je(t, r, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[r] = n, De = (t, r) => {
+  for (var n in r || (r = {}))
+    kt.call(r, n) && ot(t, n, r[n]);
+  if (nt)
+    for (var n of nt(r))
+      cr.call(r, n) && ot(t, n, r[n]);
+  return t;
+}, dr = (t, r) => ar(t, lr(r)), hr = (t, r) => function() {
+  return r || (0, t[St(t)[0]])((r = { exports: {} }).exports, r), r.exports;
+}, vr = (t, r, n, i) => {
+  if (r && typeof r == "object" || typeof r == "function")
+    for (let a of St(r))
+      !kt.call(t, a) && a !== n && je(t, a, { get: () => r[a], enumerable: !(i = ur(r, a)) || i.enumerable });
+  return t;
+}, pr = (t, r, n) => (n = t != null ? ir(Nt(t)) : {}, vr(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  je(n, "default", { value: t, enumerable: !0 }),
+  t
+)), _r = (t, r, n) => fr(Nt(t), n, r), ue = (t, r, n) => new Promise((i, a) => {
+  var c = (E) => {
+    try {
+      p(n.next(E));
+    } catch (y) {
+      a(y);
+    }
+  }, h = (E) => {
+    try {
+      p(n.throw(E));
+    } catch (y) {
+      a(y);
+    }
+  }, p = (E) => E.done ? i(E.value) : Promise.resolve(E.value).then(c, h);
+  p((n = n.apply(t, r)).next());
+}), gr = hr({
+  "../../node_modules/eventemitter3/index.js"(t, r) {
+    var n = Object.prototype.hasOwnProperty, i = "~";
+    function a() {
+    }
+    Object.create && (a.prototype = /* @__PURE__ */ Object.create(null), new a().__proto__ || (i = !1));
+    function c(y, f, v) {
+      this.fn = y, this.context = f, this.once = v || !1;
+    }
+    function h(y, f, v, _, A) {
+      if (typeof v != "function")
+        throw new TypeError("The listener must be a function");
+      var k = new c(v, _ || y, A), N = i ? i + f : f;
+      return y._events[N] ? y._events[N].fn ? y._events[N] = [y._events[N], k] : y._events[N].push(k) : (y._events[N] = k, y._eventsCount++), y;
+    }
+    function p(y, f) {
+      --y._eventsCount === 0 ? y._events = new a() : delete y._events[f];
+    }
+    function E() {
+      this._events = new a(), this._eventsCount = 0;
+    }
+    E.prototype.eventNames = function() {
+      var f = [], v, _;
+      if (this._eventsCount === 0) return f;
+      for (_ in v = this._events)
+        n.call(v, _) && f.push(i ? _.slice(1) : _);
+      return Object.getOwnPropertySymbols ? f.concat(Object.getOwnPropertySymbols(v)) : f;
+    }, E.prototype.listeners = function(f) {
+      var v = i ? i + f : f, _ = this._events[v];
+      if (!_) return [];
+      if (_.fn) return [_.fn];
+      for (var A = 0, k = _.length, N = new Array(k); A < k; A++)
+        N[A] = _[A].fn;
+      return N;
+    }, E.prototype.listenerCount = function(f) {
+      var v = i ? i + f : f, _ = this._events[v];
+      return _ ? _.fn ? 1 : _.length : 0;
+    }, E.prototype.emit = function(f, v, _, A, k, N) {
+      var $ = i ? i + f : f;
+      if (!this._events[$]) return !1;
+      var g = this._events[$], Y = arguments.length, U, j;
+      if (g.fn) {
+        switch (g.once && this.removeListener(f, g.fn, void 0, !0), Y) {
+          case 1:
+            return g.fn.call(g.context), !0;
+          case 2:
+            return g.fn.call(g.context, v), !0;
+          case 3:
+            return g.fn.call(g.context, v, _), !0;
+          case 4:
+            return g.fn.call(g.context, v, _, A), !0;
+          case 5:
+            return g.fn.call(g.context, v, _, A, k), !0;
+          case 6:
+            return g.fn.call(g.context, v, _, A, k, N), !0;
+        }
+        for (j = 1, U = new Array(Y - 1); j < Y; j++)
+          U[j - 1] = arguments[j];
+        g.fn.apply(g.context, U);
+      } else {
+        var W = g.length, q;
+        for (j = 0; j < W; j++)
+          switch (g[j].once && this.removeListener(f, g[j].fn, void 0, !0), Y) {
+            case 1:
+              g[j].fn.call(g[j].context);
+              break;
+            case 2:
+              g[j].fn.call(g[j].context, v);
+              break;
+            case 3:
+              g[j].fn.call(g[j].context, v, _);
+              break;
+            case 4:
+              g[j].fn.call(g[j].context, v, _, A);
+              break;
+            default:
+              if (!U) for (q = 1, U = new Array(Y - 1); q < Y; q++)
+                U[q - 1] = arguments[q];
+              g[j].fn.apply(g[j].context, U);
+          }
+      }
+      return !0;
+    }, E.prototype.on = function(f, v, _) {
+      return h(this, f, v, _, !1);
+    }, E.prototype.once = function(f, v, _) {
+      return h(this, f, v, _, !0);
+    }, E.prototype.removeListener = function(f, v, _, A) {
+      var k = i ? i + f : f;
+      if (!this._events[k]) return this;
+      if (!v)
+        return p(this, k), this;
+      var N = this._events[k];
+      if (N.fn)
+        N.fn === v && (!A || N.once) && (!_ || N.context === _) && p(this, k);
+      else {
+        for (var $ = 0, g = [], Y = N.length; $ < Y; $++)
+          (N[$].fn !== v || A && !N[$].once || _ && N[$].context !== _) && g.push(N[$]);
+        g.length ? this._events[k] = g.length === 1 ? g[0] : g : p(this, k);
+      }
+      return this;
+    }, E.prototype.removeAllListeners = function(f) {
+      var v;
+      return f ? (v = i ? i + f : f, this._events[v] && p(this, v)) : (this._events = new a(), this._eventsCount = 0), this;
+    }, E.prototype.off = E.prototype.removeListener, E.prototype.addListener = E.prototype.on, E.prefixed = i, E.EventEmitter = E, typeof r < "u" && (r.exports = E);
+  }
+}), Er = "No-op", mr = class {
+  constructor() {
+    this.metadata = {
+      name: "No-op Provider"
+    };
+  }
+  resolveBooleanEvaluation(t, r) {
+    return this.noOp(r);
+  }
+  resolveStringEvaluation(t, r) {
+    return this.noOp(r);
+  }
+  resolveNumberEvaluation(t, r) {
+    return this.noOp(r);
+  }
+  resolveObjectEvaluation(t, r) {
+    return this.noOp(r);
+  }
+  noOp(t) {
+    return {
+      value: t,
+      reason: Er
+    };
+  }
+}, st = new mr(), yr = pr(gr()), it = class extends rr {
+  constructor() {
+    super(), this.eventEmitter = new yr.default();
+  }
+}, Rr = class {
+  constructor(t, r, n, i, a, c, h) {
+    this.providerAccessor = t, this.providerStatusAccessor = r, this.emitterAccessor = n, this.apiContextAccessor = i, this.apiHooksAccessor = a, this.globalLogger = c, this.options = h, this._hooks = [];
+  }
+  get metadata() {
+    var t, r;
+    return {
+      // Use domain if name is not provided
+      name: (t = this.options.domain) != null ? t : this.options.name,
+      domain: (r = this.options.domain) != null ? r : this.options.name,
+      version: this.options.version,
+      providerMetadata: this.providerAccessor().metadata
+    };
+  }
+  get providerStatus() {
+    return this.providerStatusAccessor();
+  }
+  addHandler(t, r, n) {
+    var i;
+    if (this.emitterAccessor().addHandler(t, r), bt(t, this.providerStatus))
+      try {
+        r({
+          clientName: this.metadata.name,
+          domain: this.metadata.domain,
+          providerName: this._provider.metadata.name
+        });
+      } catch (c) {
+        (i = this._logger) == null || i.error("Error running event handler:", c);
+      }
+    n?.signal && typeof n.signal.addEventListener == "function" && n.signal.addEventListener("abort", () => {
+      this.removeHandler(t, r);
+    });
+  }
+  removeHandler(t, r) {
+    this.emitterAccessor().removeHandler(t, r);
+  }
+  getHandlers(t) {
+    return this.emitterAccessor().getHandlers(t);
+  }
+  setLogger(t) {
+    return this._clientLogger = new Le(t), this;
+  }
+  addHooks(...t) {
+    return this._hooks = [...this._hooks, ...t], this;
+  }
+  getHooks() {
+    return this._hooks;
+  }
+  clearHooks() {
+    return this._hooks = [], this;
+  }
+  getBooleanValue(t, r, n) {
+    return this.getBooleanDetails(t, r, n).value;
+  }
+  getBooleanDetails(t, r, n) {
+    return this.evaluate(t, this._provider.resolveBooleanEvaluation, r, "boolean", n);
+  }
+  getStringValue(t, r, n) {
+    return this.getStringDetails(t, r, n).value;
+  }
+  getStringDetails(t, r, n) {
+    return this.evaluate(
+      t,
+      // this isolates providers from our restricted string generic argument.
+      this._provider.resolveStringEvaluation,
+      r,
+      "string",
+      n
+    );
+  }
+  getNumberValue(t, r, n) {
+    return this.getNumberDetails(t, r, n).value;
+  }
+  getNumberDetails(t, r, n) {
+    return this.evaluate(
+      t,
+      // this isolates providers from our restricted number generic argument.
+      this._provider.resolveNumberEvaluation,
+      r,
+      "number",
+      n
+    );
+  }
+  getObjectValue(t, r, n) {
+    return this.getObjectDetails(t, r, n).value;
+  }
+  getObjectDetails(t, r, n) {
+    return this.evaluate(t, this._provider.resolveObjectEvaluation, r, "object", n);
+  }
+  track(t, r = {}) {
+    var n, i, a;
+    try {
+      if (this.shortCircuitIfNotReady(), typeof this._provider.track == "function") {
+        const c = Object.freeze(De({}, this.apiContextAccessor((n = this == null ? void 0 : this.options) == null ? void 0 : n.domain)));
+        return (a = (i = this._provider).track) == null ? void 0 : a.call(i, t, c, r);
+      } else
+        this._logger.debug("Provider does not support the track function; will no-op.");
+    } catch (c) {
+      this._logger.debug("Error recording tracking event.", c);
+    }
+  }
+  evaluate(t, r, n, i, a = {}) {
+    var c, h;
+    const p = [
+      ...this.apiHooksAccessor(),
+      ...this.getHooks(),
+      ...a.hooks || [],
+      ...this._provider.hooks || []
+    ], E = [...p].reverse(), y = De({}, this.apiContextAccessor((c = this == null ? void 0 : this.options) == null ? void 0 : c.domain)), f = E.map(
+      () => Object.freeze({
+        flagKey: t,
+        defaultValue: n,
+        flagValueType: i,
+        clientMetadata: this.metadata,
+        providerMetadata: this._provider.metadata,
+        context: y,
+        logger: this._logger,
+        hookData: new qt()
+      })
+    );
+    let v;
+    try {
+      this.beforeHooks(p, f, a), this.shortCircuitIfNotReady();
+      const _ = r.call(this._provider, t, n, y, this._logger), A = dr(De({}, _), {
+        flagMetadata: Object.freeze((h = _.flagMetadata) != null ? h : {}),
+        flagKey: t
+      });
+      if (A.errorCode) {
+        const k = Jt(A.errorCode, A.errorMessage);
+        this.errorHooks(E, f, k, a), v = this.getErrorEvaluationDetails(t, n, k, A.flagMetadata);
+      } else
+        this.afterHooks(E, f, A, a), v = A;
+    } catch (_) {
+      this.errorHooks(E, f, _, a), v = this.getErrorEvaluationDetails(t, n, _);
+    }
+    return this.finallyHooks(E, f, v, a), v;
+  }
+  beforeHooks(t, r, n) {
+    var i;
+    for (const [a, c] of t.entries()) {
+      const h = t.length - 1 - a, p = r[h];
+      Object.freeze(p), Object.freeze(p.context), (i = c?.before) == null || i.call(c, p, Object.freeze(n.hookHints));
+    }
+  }
+  afterHooks(t, r, n, i) {
+    var a;
+    for (const [c, h] of t.entries()) {
+      const p = r[c];
+      (a = h?.after) == null || a.call(h, p, n, i.hookHints);
+    }
+  }
+  errorHooks(t, r, n, i) {
+    var a;
+    for (const [c, h] of t.entries())
+      try {
+        const p = r[c];
+        (a = h?.error) == null || a.call(h, p, n, i.hookHints);
+      } catch (p) {
+        this._logger.error(`Unhandled error during 'error' hook: ${p}`), p instanceof Error && this._logger.error(p.stack), this._logger.error(p?.stack);
+      }
+  }
+  finallyHooks(t, r, n, i) {
+    var a;
+    for (const [c, h] of t.entries())
+      try {
+        const p = r[c];
+        (a = h?.finally) == null || a.call(h, p, n, i.hookHints);
+      } catch (p) {
+        this._logger.error(`Unhandled error during 'finally' hook: ${p}`), p instanceof Error && this._logger.error(p.stack), this._logger.error(p?.stack);
+      }
+  }
+  get _provider() {
+    return this.providerAccessor();
+  }
+  get _logger() {
+    return this._clientLogger || this.globalLogger();
+  }
+  shortCircuitIfNotReady() {
+    if (this.providerStatus === ee.NOT_READY)
+      throw new Ct("provider has not yet initialized");
+    if (this.providerStatus === ee.FATAL)
+      throw new Rt("provider is in an irrecoverable error state");
+  }
+  getErrorEvaluationDetails(t, r, n, i = {}) {
+    const a = n?.message;
+    return {
+      errorCode: n?.code || vt.GENERAL,
+      errorMessage: a,
+      value: r,
+      reason: we.ERROR,
+      flagMetadata: Object.freeze(i),
+      flagKey: t
+    };
+  }
+}, at = /* @__PURE__ */ Symbol.for("@openfeature/web-sdk/api"), ut = globalThis, Or = class He extends sr {
+  constructor() {
+    super("client"), this._statusEnumType = ee, this._apiEmitter = new it(), this._defaultProvider = new Ie(
+      st,
+      ee.NOT_READY,
+      this._statusEnumType
+    ), this._domainScopedProviders = /* @__PURE__ */ new Map(), this._createEventEmitter = () => new it();
+  }
+  /**
+   * Gets a singleton instance of the OpenFeature API.
+   * @ignore
+   * @returns {OpenFeatureAPI} OpenFeature API
+   */
+  static getInstance() {
+    const r = ut[at];
+    if (r)
+      return r;
+    const n = new He();
+    return ut[at] = n, n;
+  }
+  getProviderStatus(r) {
+    var n, i;
+    return r ? (i = (n = this._domainScopedProviders.get(r)) == null ? void 0 : n.status) != null ? i : this._defaultProvider.status : this._defaultProvider.status;
+  }
+  setProviderAndWait(r, n, i) {
+    return ue(this, null, function* () {
+      const a = ce(r), c = z(a ? n : r), h = z(a ? i : n);
+      h && (a ? this._domainScopedContext.set(a, h) : this._context = h), yield this.setAwaitableProvider(a, c);
+    });
+  }
+  setProvider(r, n, i) {
+    const a = ce(r), c = z(a ? n : r), h = z(a ? i : n);
+    h && (a ? this._domainScopedContext.set(a, h) : this._context = h);
+    const p = this.setAwaitableProvider(a, c);
+    return Promise.resolve(p).catch((E) => {
+      this._logger.error("Error during provider initialization:", E);
+    }), this;
+  }
+  getProvider(r) {
+    return this.getProviderForClient(r);
+  }
+  setContext(r, n) {
+    return ue(this, null, function* () {
+      var i, a;
+      const c = ce(r), h = (a = (i = z(r)) != null ? i : z(n)) != null ? a : {};
+      if (c) {
+        const p = this._domainScopedProviders.get(c);
+        if (p) {
+          const E = this.getContext(c);
+          this._domainScopedContext.set(c, h), yield this.runProviderContextChangeHandler(c, p, E, h);
+        } else
+          this._domainScopedContext.set(c, h);
+      } else {
+        const p = this._context;
+        this._context = h;
+        const E = Array.from(this._domainScopedProviders.entries()).filter(([f]) => !this._domainScopedContext.has(f)).reduce((f, [v, _]) => (f.push({ domain: v, wrapper: _ }), f), []), y = [
+          // add in the default (no domain)
+          { domain: void 0, wrapper: this._defaultProvider },
+          ...E
+        ];
+        yield Promise.all(
+          y.map((f) => this.runProviderContextChangeHandler(f.domain, f.wrapper, p, h))
+        );
+      }
+    });
+  }
+  getContext(r) {
+    const n = ce(r);
+    if (n) {
+      const i = this._domainScopedContext.get(n);
+      if (i)
+        return i;
+      this._logger.debug(`Unable to find context for '${n}'.`);
+    }
+    return this._context;
+  }
+  clearContext(r) {
+    return ue(this, null, function* () {
+      const n = ce(r);
+      if (n) {
+        const i = this._domainScopedProviders.get(n);
+        if (i) {
+          const a = this.getContext(n);
+          this._domainScopedContext.delete(n);
+          const c = this.getContext();
+          yield this.runProviderContextChangeHandler(n, i, a, c);
+        } else
+          this._domainScopedContext.delete(n);
+      } else
+        return this.setContext({});
+    });
+  }
+  /**
+   * Resets the global evaluation context and removes the evaluation context for
+   * all domains.
+   */
+  clearContexts() {
+    return ue(this, null, function* () {
+      yield this.clearContext(), yield Promise.allSettled(Array.from(this._domainScopedProviders.keys()).map((r) => this.clearContext(r)));
+    });
+  }
+  /**
+   * A factory function for creating new domain-scoped OpenFeature clients. Clients
+   * can contain their own state (e.g. logger, hook, context). Multiple domains
+   * can be used to segment feature flag configuration.
+   *
+   * If there is already a provider bound to this name via {@link this.setProvider setProvider}, this provider will be used.
+   * Otherwise, the default provider is used until a provider is assigned to that name.
+   * @param {string} domain An identifier which logically binds clients with providers
+   * @param {string} version The version of the client (only used for metadata)
+   * @returns {Client} OpenFeature Client
+   */
+  getClient(r, n) {
+    return new Rr(
+      // functions are passed here to make sure that these values are always up to date,
+      // and so we don't have to make these public properties on the API class.
+      () => this.getProviderForClient(r),
+      () => this.getProviderStatus(r),
+      () => this.buildAndCacheEventEmitterForClient(r),
+      (i) => this.getContext(i),
+      () => this.getHooks(),
+      () => this._logger,
+      { domain: r, version: n }
+    );
+  }
+  /**
+   * Clears all registered providers and resets the default provider.
+   * @returns {Promise<void>}
+   */
+  clearProviders() {
+    return ue(this, null, function* () {
+      yield _r(He.prototype, this, "clearProvidersAndSetDefault").call(this, st), this._domainScopedContext.clear();
+    });
+  }
+  runProviderContextChangeHandler(r, n, i, a) {
+    return ue(this, null, function* () {
+      var c, h, p, E, y, f;
+      const v = ((h = (c = n.provider) == null ? void 0 : c.metadata) == null ? void 0 : h.name) || "unnamed-provider";
+      try {
+        if (typeof n.provider.onContextChange == "function") {
+          const _ = n.provider.onContextChange(i, a);
+          _ && typeof _?.then == "function" && (n.incrementPendingContextChanges(), n.status = this._statusEnumType.RECONCILING, this.getAssociatedEventEmitters(r).forEach((A) => {
+            A?.emit(I.Reconciling, { domain: r, providerName: v });
+          }), (p = this._apiEmitter) == null || p.emit(I.Reconciling, { domain: r, providerName: v }), yield _, n.decrementPendingContextChanges());
+        }
+        n.status = this._statusEnumType.READY, n.allContextChangesSettled && (this.getAssociatedEventEmitters(r).forEach((_) => {
+          _?.emit(I.ContextChanged, { clientName: r, domain: r, providerName: v });
+        }), (E = this._apiEmitter) == null || E.emit(I.ContextChanged, { clientName: r, domain: r, providerName: v }));
+      } catch (_) {
+        if (n.decrementPendingContextChanges(), n.status = this._statusEnumType.ERROR, n.allContextChangesSettled) {
+          const A = _, k = `Error running ${v}'s context change handler: ${A?.message}`;
+          (y = this._logger) == null || y.error(`${k}`, _), this.getAssociatedEventEmitters(r).forEach((N) => {
+            N?.emit(I.Error, { clientName: r, domain: r, providerName: v, message: k });
+          }), (f = this._apiEmitter) == null || f.emit(I.Error, { clientName: r, domain: r, providerName: v, message: k });
+        }
+      }
+    });
+  }
+}, Ae = Or.getInstance();
+function Cr(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+var Oe = { exports: {} }, C = {};
+var lt;
+function wr() {
+  if (lt) return C;
+  lt = 1;
+  var t = /* @__PURE__ */ Symbol.for("react.transitional.element"), r = /* @__PURE__ */ Symbol.for("react.portal"), n = /* @__PURE__ */ Symbol.for("react.fragment"), i = /* @__PURE__ */ Symbol.for("react.strict_mode"), a = /* @__PURE__ */ Symbol.for("react.profiler"), c = /* @__PURE__ */ Symbol.for("react.consumer"), h = /* @__PURE__ */ Symbol.for("react.context"), p = /* @__PURE__ */ Symbol.for("react.forward_ref"), E = /* @__PURE__ */ Symbol.for("react.suspense"), y = /* @__PURE__ */ Symbol.for("react.memo"), f = /* @__PURE__ */ Symbol.for("react.lazy"), v = /* @__PURE__ */ Symbol.for("react.activity"), _ = Symbol.iterator;
+  function A(o) {
+    return o === null || typeof o != "object" ? null : (o = _ && o[_] || o["@@iterator"], typeof o == "function" ? o : null);
+  }
+  var k = {
+    isMounted: function() {
+      return !1;
+    },
+    enqueueForceUpdate: function() {
+    },
+    enqueueReplaceState: function() {
+    },
+    enqueueSetState: function() {
+    }
+  }, N = Object.assign, $ = {};
+  function g(o, l, O) {
+    this.props = o, this.context = l, this.refs = $, this.updater = O || k;
+  }
+  g.prototype.isReactComponent = {}, g.prototype.setState = function(o, l) {
+    if (typeof o != "object" && typeof o != "function" && o != null)
+      throw Error(
+        "takes an object of state variables to update or a function which returns an object of state variables."
+      );
+    this.updater.enqueueSetState(this, o, l, "setState");
+  }, g.prototype.forceUpdate = function(o) {
+    this.updater.enqueueForceUpdate(this, o, "forceUpdate");
+  };
+  function Y() {
+  }
+  Y.prototype = g.prototype;
+  function U(o, l, O) {
+    this.props = o, this.context = l, this.refs = $, this.updater = O || k;
+  }
+  var j = U.prototype = new Y();
+  j.constructor = U, N(j, g.prototype), j.isPureReactComponent = !0;
+  var W = Array.isArray;
+  function q() {
+  }
+  var H = { H: null, A: null, T: null, S: null }, _e = Object.prototype.hasOwnProperty;
+  function Q(o, l, O) {
+    var R = O.ref;
+    return {
+      $$typeof: t,
+      type: o,
+      key: l,
+      ref: R !== void 0 ? R : null,
+      props: O
+    };
+  }
+  function se(o, l) {
+    return Q(o.type, l, o.props);
+  }
+  function fe(o) {
+    return typeof o == "object" && o !== null && o.$$typeof === t;
+  }
+  function M(o) {
+    var l = { "=": "=0", ":": "=2" };
+    return "$" + o.replace(/[=:]/g, function(O) {
+      return l[O];
+    });
+  }
+  var de = /\/+/g;
+  function X(o, l) {
+    return typeof o == "object" && o !== null && o.key != null ? M("" + o.key) : l.toString(36);
+  }
+  function re(o) {
+    switch (o.status) {
+      case "fulfilled":
+        return o.value;
+      case "rejected":
+        throw o.reason;
+      default:
+        switch (typeof o.status == "string" ? o.then(q, q) : (o.status = "pending", o.then(
+          function(l) {
+            o.status === "pending" && (o.status = "fulfilled", o.value = l);
+          },
+          function(l) {
+            o.status === "pending" && (o.status = "rejected", o.reason = l);
+          }
+        )), o.status) {
+          case "fulfilled":
+            return o.value;
+          case "rejected":
+            throw o.reason;
+        }
+    }
+    throw o;
+  }
+  function B(o, l, O, R, S) {
+    var D = typeof o;
+    (D === "undefined" || D === "boolean") && (o = null);
+    var L = !1;
+    if (o === null) L = !0;
+    else
+      switch (D) {
+        case "bigint":
+        case "string":
+        case "number":
+          L = !0;
+          break;
+        case "object":
+          switch (o.$$typeof) {
+            case t:
+            case r:
+              L = !0;
+              break;
+            case f:
+              return L = o._init, B(
+                L(o._payload),
+                l,
+                O,
+                R,
+                S
+              );
+          }
+      }
+    if (L)
+      return S = S(o), L = R === "" ? "." + X(o, 0) : R, W(S) ? (O = "", L != null && (O = L.replace(de, "$&/") + "/"), B(S, l, O, "", function(ne) {
+        return ne;
+      })) : S != null && (fe(S) && (S = se(
+        S,
+        O + (S.key == null || o && o.key === S.key ? "" : ("" + S.key).replace(
+          de,
+          "$&/"
+        ) + "/") + L
+      )), l.push(S)), 1;
+    L = 0;
+    var G = R === "" ? "." : R + ":";
+    if (W(o))
+      for (var F = 0; F < o.length; F++)
+        R = o[F], D = G + X(R, F), L += B(
+          R,
+          l,
+          O,
+          D,
+          S
+        );
+    else if (F = A(o), typeof F == "function")
+      for (o = F.call(o), F = 0; !(R = o.next()).done; )
+        R = R.value, D = G + X(R, F++), L += B(
+          R,
+          l,
+          O,
+          D,
+          S
+        );
+    else if (D === "object") {
+      if (typeof o.then == "function")
+        return B(
+          re(o),
+          l,
+          O,
+          R,
+          S
+        );
+      throw l = String(o), Error(
+        "Objects are not valid as a React child (found: " + (l === "[object Object]" ? "object with keys {" + Object.keys(o).join(", ") + "}" : l) + "). If you meant to render a collection of children, use an array instead."
+      );
+    }
+    return L;
+  }
+  function Z(o, l, O) {
+    if (o == null) return o;
+    var R = [], S = 0;
+    return B(o, R, "", "", function(D) {
+      return l.call(O, D, S++);
+    }), R;
+  }
+  function he(o) {
+    if (o._status === -1) {
+      var l = o._result;
+      l = l(), l.then(
+        function(O) {
+          (o._status === 0 || o._status === -1) && (o._status = 1, o._result = O);
+        },
+        function(O) {
+          (o._status === 0 || o._status === -1) && (o._status = 2, o._result = O);
+        }
+      ), o._status === -1 && (o._status = 0, o._result = l);
+    }
+    if (o._status === 1) return o._result.default;
+    throw o._result;
+  }
+  var ie = typeof reportError == "function" ? reportError : function(o) {
+    if (typeof window == "object" && typeof window.ErrorEvent == "function") {
+      var l = new window.ErrorEvent("error", {
+        bubbles: !0,
+        cancelable: !0,
+        message: typeof o == "object" && o !== null && typeof o.message == "string" ? String(o.message) : String(o),
+        error: o
+      });
+      if (!window.dispatchEvent(l)) return;
+    } else if (typeof process == "object" && typeof process.emit == "function") {
+      process.emit("uncaughtException", o);
+      return;
+    }
+    console.error(o);
+  }, ge = {
+    map: Z,
+    forEach: function(o, l, O) {
+      Z(
+        o,
+        function() {
+          l.apply(this, arguments);
+        },
+        O
+      );
+    },
+    count: function(o) {
+      var l = 0;
+      return Z(o, function() {
+        l++;
+      }), l;
+    },
+    toArray: function(o) {
+      return Z(o, function(l) {
+        return l;
+      }) || [];
+    },
+    only: function(o) {
+      if (!fe(o))
+        throw Error(
+          "React.Children.only expected to receive a single React element child."
+        );
+      return o;
+    }
+  };
+  return C.Activity = v, C.Children = ge, C.Component = g, C.Fragment = n, C.Profiler = a, C.PureComponent = U, C.StrictMode = i, C.Suspense = E, C.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = H, C.__COMPILER_RUNTIME = {
+    __proto__: null,
+    c: function(o) {
+      return H.H.useMemoCache(o);
+    }
+  }, C.cache = function(o) {
+    return function() {
+      return o.apply(null, arguments);
+    };
+  }, C.cacheSignal = function() {
+    return null;
+  }, C.cloneElement = function(o, l, O) {
+    if (o == null)
+      throw Error(
+        "The argument must be a React element, but you passed " + o + "."
+      );
+    var R = N({}, o.props), S = o.key;
+    if (l != null)
+      for (D in l.key !== void 0 && (S = "" + l.key), l)
+        !_e.call(l, D) || D === "key" || D === "__self" || D === "__source" || D === "ref" && l.ref === void 0 || (R[D] = l[D]);
+    var D = arguments.length - 2;
+    if (D === 1) R.children = O;
+    else if (1 < D) {
+      for (var L = Array(D), G = 0; G < D; G++)
+        L[G] = arguments[G + 2];
+      R.children = L;
+    }
+    return Q(o.type, S, R);
+  }, C.createContext = function(o) {
+    return o = {
+      $$typeof: h,
+      _currentValue: o,
+      _currentValue2: o,
+      _threadCount: 0,
+      Provider: null,
+      Consumer: null
+    }, o.Provider = o, o.Consumer = {
+      $$typeof: c,
+      _context: o
+    }, o;
+  }, C.createElement = function(o, l, O) {
+    var R, S = {}, D = null;
+    if (l != null)
+      for (R in l.key !== void 0 && (D = "" + l.key), l)
+        _e.call(l, R) && R !== "key" && R !== "__self" && R !== "__source" && (S[R] = l[R]);
+    var L = arguments.length - 2;
+    if (L === 1) S.children = O;
+    else if (1 < L) {
+      for (var G = Array(L), F = 0; F < L; F++)
+        G[F] = arguments[F + 2];
+      S.children = G;
+    }
+    if (o && o.defaultProps)
+      for (R in L = o.defaultProps, L)
+        S[R] === void 0 && (S[R] = L[R]);
+    return Q(o, D, S);
+  }, C.createRef = function() {
+    return { current: null };
+  }, C.forwardRef = function(o) {
+    return { $$typeof: p, render: o };
+  }, C.isValidElement = fe, C.lazy = function(o) {
+    return {
+      $$typeof: f,
+      _payload: { _status: -1, _result: o },
+      _init: he
+    };
+  }, C.memo = function(o, l) {
+    return {
+      $$typeof: y,
+      type: o,
+      compare: l === void 0 ? null : l
+    };
+  }, C.startTransition = function(o) {
+    var l = H.T, O = {};
+    H.T = O;
+    try {
+      var R = o(), S = H.S;
+      S !== null && S(O, R), typeof R == "object" && R !== null && typeof R.then == "function" && R.then(q, ie);
+    } catch (D) {
+      ie(D);
+    } finally {
+      l !== null && O.types !== null && (l.types = O.types), H.T = l;
+    }
+  }, C.unstable_useCacheRefresh = function() {
+    return H.H.useCacheRefresh();
+  }, C.use = function(o) {
+    return H.H.use(o);
+  }, C.useActionState = function(o, l, O) {
+    return H.H.useActionState(o, l, O);
+  }, C.useCallback = function(o, l) {
+    return H.H.useCallback(o, l);
+  }, C.useContext = function(o) {
+    return H.H.useContext(o);
+  }, C.useDebugValue = function() {
+  }, C.useDeferredValue = function(o, l) {
+    return H.H.useDeferredValue(o, l);
+  }, C.useEffect = function(o, l) {
+    return H.H.useEffect(o, l);
+  }, C.useEffectEvent = function(o) {
+    return H.H.useEffectEvent(o);
+  }, C.useId = function() {
+    return H.H.useId();
+  }, C.useImperativeHandle = function(o, l, O) {
+    return H.H.useImperativeHandle(o, l, O);
+  }, C.useInsertionEffect = function(o, l) {
+    return H.H.useInsertionEffect(o, l);
+  }, C.useLayoutEffect = function(o, l) {
+    return H.H.useLayoutEffect(o, l);
+  }, C.useMemo = function(o, l) {
+    return H.H.useMemo(o, l);
+  }, C.useOptimistic = function(o, l) {
+    return H.H.useOptimistic(o, l);
+  }, C.useReducer = function(o, l, O) {
+    return H.H.useReducer(o, l, O);
+  }, C.useRef = function(o) {
+    return H.H.useRef(o);
+  }, C.useState = function(o) {
+    return H.H.useState(o);
+  }, C.useSyncExternalStore = function(o, l, O) {
+    return H.H.useSyncExternalStore(
+      o,
+      l,
+      O
+    );
+  }, C.useTransition = function() {
+    return H.H.useTransition();
+  }, C.version = "19.2.0", C;
+}
+var pe = { exports: {} };
+pe.exports;
+var ct;
+function Ar() {
+  return ct || (ct = 1, (function(t, r) {
+    process.env.NODE_ENV !== "production" && (function() {
+      function n(e, s) {
+        Object.defineProperty(c.prototype, e, {
+          get: function() {
+            console.warn(
+              "%s(...) is deprecated in plain JavaScript React classes. %s",
+              s[0],
+              s[1]
+            );
+          }
+        });
+      }
+      function i(e) {
+        return e === null || typeof e != "object" ? null : (e = Ye && e[Ye] || e["@@iterator"], typeof e == "function" ? e : null);
+      }
+      function a(e, s) {
+        e = (e = e.constructor) && (e.displayName || e.name) || "ReactClass";
+        var u = e + "." + s;
+        Fe[u] || (console.error(
+          "Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.",
+          s,
+          e
+        ), Fe[u] = !0);
+      }
+      function c(e, s, u) {
+        this.props = e, this.context = s, this.refs = Te, this.updater = u || Ue;
+      }
+      function h() {
+      }
+      function p(e, s, u) {
+        this.props = e, this.context = s, this.refs = Te, this.updater = u || Ue;
+      }
+      function E() {
+      }
+      function y(e) {
+        return "" + e;
+      }
+      function f(e) {
+        try {
+          y(e);
+          var s = !1;
+        } catch {
+          s = !0;
+        }
+        if (s) {
+          s = console;
+          var u = s.error, d = typeof Symbol == "function" && Symbol.toStringTag && e[Symbol.toStringTag] || e.constructor.name || "Object";
+          return u.call(
+            s,
+            "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+            d
+          ), y(e);
+        }
+      }
+      function v(e) {
+        if (e == null) return null;
+        if (typeof e == "function")
+          return e.$$typeof === xt ? null : e.displayName || e.name || null;
+        if (typeof e == "string") return e;
+        switch (e) {
+          case o:
+            return "Fragment";
+          case O:
+            return "Profiler";
+          case l:
+            return "StrictMode";
+          case L:
+            return "Suspense";
+          case G:
+            return "SuspenseList";
+          case $e:
+            return "Activity";
+        }
+        if (typeof e == "object")
+          switch (typeof e.tag == "number" && console.error(
+            "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+          ), e.$$typeof) {
+            case ge:
+              return "Portal";
+            case S:
+              return e.displayName || "Context";
+            case R:
+              return (e._context.displayName || "Context") + ".Consumer";
+            case D:
+              var s = e.render;
+              return e = e.displayName, e || (e = s.displayName || s.name || "", e = e !== "" ? "ForwardRef(" + e + ")" : "ForwardRef"), e;
+            case F:
+              return s = e.displayName || null, s !== null ? s : v(e.type) || "Memo";
+            case ne:
+              s = e._payload, e = e._init;
+              try {
+                return v(e(s));
+              } catch {
+              }
+          }
+        return null;
+      }
+      function _(e) {
+        if (e === o) return "<>";
+        if (typeof e == "object" && e !== null && e.$$typeof === ne)
+          return "<...>";
+        try {
+          var s = v(e);
+          return s ? "<" + s + ">" : "<...>";
+        } catch {
+          return "<...>";
+        }
+      }
+      function A() {
+        var e = P.A;
+        return e === null ? null : e.getOwner();
+      }
+      function k() {
+        return Error("react-stack-top-frame");
+      }
+      function N(e) {
+        if (Ee.call(e, "key")) {
+          var s = Object.getOwnPropertyDescriptor(e, "key").get;
+          if (s && s.isReactWarning) return !1;
+        }
+        return e.key !== void 0;
+      }
+      function $(e, s) {
+        function u() {
+          We || (We = !0, console.error(
+            "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+            s
+          ));
+        }
+        u.isReactWarning = !0, Object.defineProperty(e, "key", {
+          get: u,
+          configurable: !0
+        });
+      }
+      function g() {
+        var e = v(this.type);
+        return Be[e] || (Be[e] = !0, console.error(
+          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+        )), e = this.props.ref, e !== void 0 ? e : null;
+      }
+      function Y(e, s, u, d, m, b) {
+        var w = u.ref;
+        return e = {
+          $$typeof: ie,
+          type: e,
+          key: s,
+          props: u,
+          _owner: d
+        }, (w !== void 0 ? w : null) !== null ? Object.defineProperty(e, "ref", {
+          enumerable: !1,
+          get: g
+        }) : Object.defineProperty(e, "ref", { enumerable: !1, value: null }), e._store = {}, Object.defineProperty(e._store, "validated", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: 0
+        }), Object.defineProperty(e, "_debugInfo", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: null
+        }), Object.defineProperty(e, "_debugStack", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: m
+        }), Object.defineProperty(e, "_debugTask", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: b
+        }), Object.freeze && (Object.freeze(e.props), Object.freeze(e)), e;
+      }
+      function U(e, s) {
+        return s = Y(
+          e.type,
+          s,
+          e.props,
+          e._owner,
+          e._debugStack,
+          e._debugTask
+        ), e._store && (s._store.validated = e._store.validated), s;
+      }
+      function j(e) {
+        W(e) ? e._store && (e._store.validated = 1) : typeof e == "object" && e !== null && e.$$typeof === ne && (e._payload.status === "fulfilled" ? W(e._payload.value) && e._payload.value._store && (e._payload.value._store.validated = 1) : e._store && (e._store.validated = 1));
+      }
+      function W(e) {
+        return typeof e == "object" && e !== null && e.$$typeof === ie;
+      }
+      function q(e) {
+        var s = { "=": "=0", ":": "=2" };
+        return "$" + e.replace(/[=:]/g, function(u) {
+          return s[u];
+        });
+      }
+      function H(e, s) {
+        return typeof e == "object" && e !== null && e.key != null ? (f(e.key), q("" + e.key)) : s.toString(36);
+      }
+      function _e(e) {
+        switch (e.status) {
+          case "fulfilled":
+            return e.value;
+          case "rejected":
+            throw e.reason;
+          default:
+            switch (typeof e.status == "string" ? e.then(E, E) : (e.status = "pending", e.then(
+              function(s) {
+                e.status === "pending" && (e.status = "fulfilled", e.value = s);
+              },
+              function(s) {
+                e.status === "pending" && (e.status = "rejected", e.reason = s);
+              }
+            )), e.status) {
+              case "fulfilled":
+                return e.value;
+              case "rejected":
+                throw e.reason;
+            }
+        }
+        throw e;
+      }
+      function Q(e, s, u, d, m) {
+        var b = typeof e;
+        (b === "undefined" || b === "boolean") && (e = null);
+        var w = !1;
+        if (e === null) w = !0;
+        else
+          switch (b) {
+            case "bigint":
+            case "string":
+            case "number":
+              w = !0;
+              break;
+            case "object":
+              switch (e.$$typeof) {
+                case ie:
+                case ge:
+                  w = !0;
+                  break;
+                case ne:
+                  return w = e._init, Q(
+                    w(e._payload),
+                    s,
+                    u,
+                    d,
+                    m
+                  );
+              }
+          }
+        if (w) {
+          w = e, m = m(w);
+          var x = d === "" ? "." + H(w, 0) : d;
+          return Ve(m) ? (u = "", x != null && (u = x.replace(Ke, "$&/") + "/"), Q(m, s, u, "", function(J) {
+            return J;
+          })) : m != null && (W(m) && (m.key != null && (w && w.key === m.key || f(m.key)), u = U(
+            m,
+            u + (m.key == null || w && w.key === m.key ? "" : ("" + m.key).replace(
+              Ke,
+              "$&/"
+            ) + "/") + x
+          ), d !== "" && w != null && W(w) && w.key == null && w._store && !w._store.validated && (u._store.validated = 2), m = u), s.push(m)), 1;
+        }
+        if (w = 0, x = d === "" ? "." : d + ":", Ve(e))
+          for (var T = 0; T < e.length; T++)
+            d = e[T], b = x + H(d, T), w += Q(
+              d,
+              s,
+              u,
+              b,
+              m
+            );
+        else if (T = i(e), typeof T == "function")
+          for (T === e.entries && (Qe || console.warn(
+            "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
+          ), Qe = !0), e = T.call(e), T = 0; !(d = e.next()).done; )
+            d = d.value, b = x + H(d, T++), w += Q(
+              d,
+              s,
+              u,
+              b,
+              m
+            );
+        else if (b === "object") {
+          if (typeof e.then == "function")
+            return Q(
+              _e(e),
+              s,
+              u,
+              d,
+              m
+            );
+          throw s = String(e), Error(
+            "Objects are not valid as a React child (found: " + (s === "[object Object]" ? "object with keys {" + Object.keys(e).join(", ") + "}" : s) + "). If you meant to render a collection of children, use an array instead."
+          );
+        }
+        return w;
+      }
+      function se(e, s, u) {
+        if (e == null) return e;
+        var d = [], m = 0;
+        return Q(e, d, "", "", function(b) {
+          return s.call(u, b, m++);
+        }), d;
+      }
+      function fe(e) {
+        if (e._status === -1) {
+          var s = e._ioInfo;
+          s != null && (s.start = s.end = performance.now()), s = e._result;
+          var u = s();
+          if (u.then(
+            function(m) {
+              if (e._status === 0 || e._status === -1) {
+                e._status = 1, e._result = m;
+                var b = e._ioInfo;
+                b != null && (b.end = performance.now()), u.status === void 0 && (u.status = "fulfilled", u.value = m);
+              }
+            },
+            function(m) {
+              if (e._status === 0 || e._status === -1) {
+                e._status = 2, e._result = m;
+                var b = e._ioInfo;
+                b != null && (b.end = performance.now()), u.status === void 0 && (u.status = "rejected", u.reason = m);
+              }
+            }
+          ), s = e._ioInfo, s != null) {
+            s.value = u;
+            var d = u.displayName;
+            typeof d == "string" && (s.name = d);
+          }
+          e._status === -1 && (e._status = 0, e._result = u);
+        }
+        if (e._status === 1)
+          return s = e._result, s === void 0 && console.error(
+            `lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))
+
+Did you accidentally put curly braces around the import?`,
+            s
+          ), "default" in s || console.error(
+            `lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))`,
+            s
+          ), s.default;
+        throw e._result;
+      }
+      function M() {
+        var e = P.H;
+        return e === null && console.error(
+          `Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.`
+        ), e;
+      }
+      function de() {
+        P.asyncTransitions--;
+      }
+      function X(e) {
+        if (me === null)
+          try {
+            var s = ("require" + Math.random()).slice(0, 7);
+            me = (t && t[s]).call(
+              t,
+              "timers"
+            ).setImmediate;
+          } catch {
+            me = function(d) {
+              Ze === !1 && (Ze = !0, typeof MessageChannel > "u" && console.error(
+                "This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."
+              ));
+              var m = new MessageChannel();
+              m.port1.onmessage = d, m.port2.postMessage(void 0);
+            };
+          }
+        return me(e);
+      }
+      function re(e) {
+        return 1 < e.length && typeof AggregateError == "function" ? new AggregateError(e) : e[0];
+      }
+      function B(e, s) {
+        s !== ye - 1 && console.error(
+          "You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "
+        ), ye = s;
+      }
+      function Z(e, s, u) {
+        var d = P.actQueue;
+        if (d !== null)
+          if (d.length !== 0)
+            try {
+              he(d), X(function() {
+                return Z(e, s, u);
+              });
+              return;
+            } catch (m) {
+              P.thrownErrors.push(m);
+            }
+          else P.actQueue = null;
+        0 < P.thrownErrors.length ? (d = re(P.thrownErrors), P.thrownErrors.length = 0, u(d)) : s(e);
+      }
+      function he(e) {
+        if (!Se) {
+          Se = !0;
+          var s = 0;
+          try {
+            for (; s < e.length; s++) {
+              var u = e[s];
+              do {
+                P.didUsePromise = !1;
+                var d = u(!1);
+                if (d !== null) {
+                  if (P.didUsePromise) {
+                    e[s] = u, e.splice(0, s);
+                    return;
+                  }
+                  u = d;
+                } else break;
+              } while (!0);
+            }
+            e.length = 0;
+          } catch (m) {
+            e.splice(0, s + 1), P.thrownErrors.push(m);
+          } finally {
+            Se = !1;
+          }
+        }
+      }
+      typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var ie = /* @__PURE__ */ Symbol.for("react.transitional.element"), ge = /* @__PURE__ */ Symbol.for("react.portal"), o = /* @__PURE__ */ Symbol.for("react.fragment"), l = /* @__PURE__ */ Symbol.for("react.strict_mode"), O = /* @__PURE__ */ Symbol.for("react.profiler"), R = /* @__PURE__ */ Symbol.for("react.consumer"), S = /* @__PURE__ */ Symbol.for("react.context"), D = /* @__PURE__ */ Symbol.for("react.forward_ref"), L = /* @__PURE__ */ Symbol.for("react.suspense"), G = /* @__PURE__ */ Symbol.for("react.suspense_list"), F = /* @__PURE__ */ Symbol.for("react.memo"), ne = /* @__PURE__ */ Symbol.for("react.lazy"), $e = /* @__PURE__ */ Symbol.for("react.activity"), Ye = Symbol.iterator, Fe = {}, Ue = {
+        isMounted: function() {
+          return !1;
+        },
+        enqueueForceUpdate: function(e) {
+          a(e, "forceUpdate");
+        },
+        enqueueReplaceState: function(e) {
+          a(e, "replaceState");
+        },
+        enqueueSetState: function(e) {
+          a(e, "setState");
+        }
+      }, Ge = Object.assign, Te = {};
+      Object.freeze(Te), c.prototype.isReactComponent = {}, c.prototype.setState = function(e, s) {
+        if (typeof e != "object" && typeof e != "function" && e != null)
+          throw Error(
+            "takes an object of state variables to update or a function which returns an object of state variables."
+          );
+        this.updater.enqueueSetState(this, e, s, "setState");
+      }, c.prototype.forceUpdate = function(e) {
+        this.updater.enqueueForceUpdate(this, e, "forceUpdate");
+      };
+      var V = {
+        isMounted: [
+          "isMounted",
+          "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
+        ],
+        replaceState: [
+          "replaceState",
+          "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
+        ]
+      };
+      for (ve in V)
+        V.hasOwnProperty(ve) && n(ve, V[ve]);
+      h.prototype = c.prototype, V = p.prototype = new h(), V.constructor = p, Ge(V, c.prototype), V.isPureReactComponent = !0;
+      var Ve = Array.isArray, xt = /* @__PURE__ */ Symbol.for("react.client.reference"), P = {
+        H: null,
+        A: null,
+        T: null,
+        S: null,
+        actQueue: null,
+        asyncTransitions: 0,
+        isBatchingLegacy: !1,
+        didScheduleLegacyUpdate: !1,
+        didUsePromise: !1,
+        thrownErrors: [],
+        getCurrentStack: null,
+        recentlyCreatedOwnerStacks: 0
+      }, Ee = Object.prototype.hasOwnProperty, ze = console.createTask ? console.createTask : function() {
+        return null;
+      };
+      V = {
+        react_stack_bottom_frame: function(e) {
+          return e();
+        }
+      };
+      var We, qe, Be = {}, Mt = V.react_stack_bottom_frame.bind(
+        V,
+        k
+      )(), $t = ze(_(k)), Qe = !1, Ke = /\/+/g, Xe = typeof reportError == "function" ? reportError : function(e) {
+        if (typeof window == "object" && typeof window.ErrorEvent == "function") {
+          var s = new window.ErrorEvent("error", {
+            bubbles: !0,
+            cancelable: !0,
+            message: typeof e == "object" && e !== null && typeof e.message == "string" ? String(e.message) : String(e),
+            error: e
+          });
+          if (!window.dispatchEvent(s)) return;
+        } else if (typeof process == "object" && typeof process.emit == "function") {
+          process.emit("uncaughtException", e);
+          return;
+        }
+        console.error(e);
+      }, Ze = !1, me = null, ye = 0, Re = !1, Se = !1, Je = typeof queueMicrotask == "function" ? function(e) {
+        queueMicrotask(function() {
+          return queueMicrotask(e);
+        });
+      } : X;
+      V = Object.freeze({
+        __proto__: null,
+        c: function(e) {
+          return M().useMemoCache(e);
+        }
+      });
+      var ve = {
+        map: se,
+        forEach: function(e, s, u) {
+          se(
+            e,
+            function() {
+              s.apply(this, arguments);
+            },
+            u
+          );
+        },
+        count: function(e) {
+          var s = 0;
+          return se(e, function() {
+            s++;
+          }), s;
+        },
+        toArray: function(e) {
+          return se(e, function(s) {
+            return s;
+          }) || [];
+        },
+        only: function(e) {
+          if (!W(e))
+            throw Error(
+              "React.Children.only expected to receive a single React element child."
+            );
+          return e;
+        }
+      };
+      r.Activity = $e, r.Children = ve, r.Component = c, r.Fragment = o, r.Profiler = O, r.PureComponent = p, r.StrictMode = l, r.Suspense = L, r.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = P, r.__COMPILER_RUNTIME = V, r.act = function(e) {
+        var s = P.actQueue, u = ye;
+        ye++;
+        var d = P.actQueue = s !== null ? s : [], m = !1;
+        try {
+          var b = e();
+        } catch (T) {
+          P.thrownErrors.push(T);
+        }
+        if (0 < P.thrownErrors.length)
+          throw B(s, u), e = re(P.thrownErrors), P.thrownErrors.length = 0, e;
+        if (b !== null && typeof b == "object" && typeof b.then == "function") {
+          var w = b;
+          return Je(function() {
+            m || Re || (Re = !0, console.error(
+              "You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"
+            ));
+          }), {
+            then: function(T, J) {
+              m = !0, w.then(
+                function(ae) {
+                  if (B(s, u), u === 0) {
+                    try {
+                      he(d), X(function() {
+                        return Z(
+                          ae,
+                          T,
+                          J
+                        );
+                      });
+                    } catch (Ft) {
+                      P.thrownErrors.push(Ft);
+                    }
+                    if (0 < P.thrownErrors.length) {
+                      var Yt = re(
+                        P.thrownErrors
+                      );
+                      P.thrownErrors.length = 0, J(Yt);
+                    }
+                  } else T(ae);
+                },
+                function(ae) {
+                  B(s, u), 0 < P.thrownErrors.length && (ae = re(
+                    P.thrownErrors
+                  ), P.thrownErrors.length = 0), J(ae);
+                }
+              );
+            }
+          };
+        }
+        var x = b;
+        if (B(s, u), u === 0 && (he(d), d.length !== 0 && Je(function() {
+          m || Re || (Re = !0, console.error(
+            "A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"
+          ));
+        }), P.actQueue = null), 0 < P.thrownErrors.length)
+          throw e = re(P.thrownErrors), P.thrownErrors.length = 0, e;
+        return {
+          then: function(T, J) {
+            m = !0, u === 0 ? (P.actQueue = d, X(function() {
+              return Z(
+                x,
+                T,
+                J
+              );
+            })) : T(x);
+          }
+        };
+      }, r.cache = function(e) {
+        return function() {
+          return e.apply(null, arguments);
+        };
+      }, r.cacheSignal = function() {
+        return null;
+      }, r.captureOwnerStack = function() {
+        var e = P.getCurrentStack;
+        return e === null ? null : e();
+      }, r.cloneElement = function(e, s, u) {
+        if (e == null)
+          throw Error(
+            "The argument must be a React element, but you passed " + e + "."
+          );
+        var d = Ge({}, e.props), m = e.key, b = e._owner;
+        if (s != null) {
+          var w;
+          e: {
+            if (Ee.call(s, "ref") && (w = Object.getOwnPropertyDescriptor(
+              s,
+              "ref"
+            ).get) && w.isReactWarning) {
+              w = !1;
+              break e;
+            }
+            w = s.ref !== void 0;
+          }
+          w && (b = A()), N(s) && (f(s.key), m = "" + s.key);
+          for (x in s)
+            !Ee.call(s, x) || x === "key" || x === "__self" || x === "__source" || x === "ref" && s.ref === void 0 || (d[x] = s[x]);
+        }
+        var x = arguments.length - 2;
+        if (x === 1) d.children = u;
+        else if (1 < x) {
+          w = Array(x);
+          for (var T = 0; T < x; T++)
+            w[T] = arguments[T + 2];
+          d.children = w;
+        }
+        for (d = Y(
+          e.type,
+          m,
+          d,
+          b,
+          e._debugStack,
+          e._debugTask
+        ), m = 2; m < arguments.length; m++)
+          j(arguments[m]);
+        return d;
+      }, r.createContext = function(e) {
+        return e = {
+          $$typeof: S,
+          _currentValue: e,
+          _currentValue2: e,
+          _threadCount: 0,
+          Provider: null,
+          Consumer: null
+        }, e.Provider = e, e.Consumer = {
+          $$typeof: R,
+          _context: e
+        }, e._currentRenderer = null, e._currentRenderer2 = null, e;
+      }, r.createElement = function(e, s, u) {
+        for (var d = 2; d < arguments.length; d++)
+          j(arguments[d]);
+        d = {};
+        var m = null;
+        if (s != null)
+          for (T in qe || !("__self" in s) || "key" in s || (qe = !0, console.warn(
+            "Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform"
+          )), N(s) && (f(s.key), m = "" + s.key), s)
+            Ee.call(s, T) && T !== "key" && T !== "__self" && T !== "__source" && (d[T] = s[T]);
+        var b = arguments.length - 2;
+        if (b === 1) d.children = u;
+        else if (1 < b) {
+          for (var w = Array(b), x = 0; x < b; x++)
+            w[x] = arguments[x + 2];
+          Object.freeze && Object.freeze(w), d.children = w;
+        }
+        if (e && e.defaultProps)
+          for (T in b = e.defaultProps, b)
+            d[T] === void 0 && (d[T] = b[T]);
+        m && $(
+          d,
+          typeof e == "function" ? e.displayName || e.name || "Unknown" : e
+        );
+        var T = 1e4 > P.recentlyCreatedOwnerStacks++;
+        return Y(
+          e,
+          m,
+          d,
+          A(),
+          T ? Error("react-stack-top-frame") : Mt,
+          T ? ze(_(e)) : $t
+        );
+      }, r.createRef = function() {
+        var e = { current: null };
+        return Object.seal(e), e;
+      }, r.forwardRef = function(e) {
+        e != null && e.$$typeof === F ? console.error(
+          "forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."
+        ) : typeof e != "function" ? console.error(
+          "forwardRef requires a render function but was given %s.",
+          e === null ? "null" : typeof e
+        ) : e.length !== 0 && e.length !== 2 && console.error(
+          "forwardRef render functions accept exactly two parameters: props and ref. %s",
+          e.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."
+        ), e != null && e.defaultProps != null && console.error(
+          "forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?"
+        );
+        var s = { $$typeof: D, render: e }, u;
+        return Object.defineProperty(s, "displayName", {
+          enumerable: !1,
+          configurable: !0,
+          get: function() {
+            return u;
+          },
+          set: function(d) {
+            u = d, e.name || e.displayName || (Object.defineProperty(e, "name", { value: d }), e.displayName = d);
+          }
+        }), s;
+      }, r.isValidElement = W, r.lazy = function(e) {
+        e = { _status: -1, _result: e };
+        var s = {
+          $$typeof: ne,
+          _payload: e,
+          _init: fe
+        }, u = {
+          name: "lazy",
+          start: -1,
+          end: -1,
+          value: null,
+          owner: null,
+          debugStack: Error("react-stack-top-frame"),
+          debugTask: console.createTask ? console.createTask("lazy()") : null
+        };
+        return e._ioInfo = u, s._debugInfo = [{ awaited: u }], s;
+      }, r.memo = function(e, s) {
+        e == null && console.error(
+          "memo: The first argument must be a component. Instead received: %s",
+          e === null ? "null" : typeof e
+        ), s = {
+          $$typeof: F,
+          type: e,
+          compare: s === void 0 ? null : s
+        };
+        var u;
+        return Object.defineProperty(s, "displayName", {
+          enumerable: !1,
+          configurable: !0,
+          get: function() {
+            return u;
+          },
+          set: function(d) {
+            u = d, e.name || e.displayName || (Object.defineProperty(e, "name", { value: d }), e.displayName = d);
+          }
+        }), s;
+      }, r.startTransition = function(e) {
+        var s = P.T, u = {};
+        u._updatedFibers = /* @__PURE__ */ new Set(), P.T = u;
+        try {
+          var d = e(), m = P.S;
+          m !== null && m(u, d), typeof d == "object" && d !== null && typeof d.then == "function" && (P.asyncTransitions++, d.then(de, de), d.then(E, Xe));
+        } catch (b) {
+          Xe(b);
+        } finally {
+          s === null && u._updatedFibers && (e = u._updatedFibers.size, u._updatedFibers.clear(), 10 < e && console.warn(
+            "Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."
+          )), s !== null && u.types !== null && (s.types !== null && s.types !== u.types && console.error(
+            "We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."
+          ), s.types = u.types), P.T = s;
+        }
+      }, r.unstable_useCacheRefresh = function() {
+        return M().useCacheRefresh();
+      }, r.use = function(e) {
+        return M().use(e);
+      }, r.useActionState = function(e, s, u) {
+        return M().useActionState(
+          e,
+          s,
+          u
+        );
+      }, r.useCallback = function(e, s) {
+        return M().useCallback(e, s);
+      }, r.useContext = function(e) {
+        var s = M();
+        return e.$$typeof === R && console.error(
+          "Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?"
+        ), s.useContext(e);
+      }, r.useDebugValue = function(e, s) {
+        return M().useDebugValue(e, s);
+      }, r.useDeferredValue = function(e, s) {
+        return M().useDeferredValue(e, s);
+      }, r.useEffect = function(e, s) {
+        return e == null && console.warn(
+          "React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), M().useEffect(e, s);
+      }, r.useEffectEvent = function(e) {
+        return M().useEffectEvent(e);
+      }, r.useId = function() {
+        return M().useId();
+      }, r.useImperativeHandle = function(e, s, u) {
+        return M().useImperativeHandle(e, s, u);
+      }, r.useInsertionEffect = function(e, s) {
+        return e == null && console.warn(
+          "React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), M().useInsertionEffect(e, s);
+      }, r.useLayoutEffect = function(e, s) {
+        return e == null && console.warn(
+          "React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), M().useLayoutEffect(e, s);
+      }, r.useMemo = function(e, s) {
+        return M().useMemo(e, s);
+      }, r.useOptimistic = function(e, s) {
+        return M().useOptimistic(e, s);
+      }, r.useReducer = function(e, s, u) {
+        return M().useReducer(e, s, u);
+      }, r.useRef = function(e) {
+        return M().useRef(e);
+      }, r.useState = function(e) {
+        return M().useState(e);
+      }, r.useSyncExternalStore = function(e, s, u) {
+        return M().useSyncExternalStore(
+          e,
+          s,
+          u
+        );
+      }, r.useTransition = function() {
+        return M().useTransition();
+      }, r.version = "19.2.0", typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    })();
+  })(pe, pe.exports)), pe.exports;
+}
+var ft;
+function Pr() {
+  return ft || (ft = 1, process.env.NODE_ENV === "production" ? Oe.exports = wr() : Oe.exports = Ar()), Oe.exports;
+}
+var K = Pr();
+const xe = /* @__PURE__ */ Cr(K);
+var br = Object.defineProperty, Pe = Object.getOwnPropertySymbols, Dt = Object.prototype.hasOwnProperty, It = Object.prototype.propertyIsEnumerable, dt = (t, r, n) => r in t ? br(t, r, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[r] = n, oe = (t, r) => {
+  for (var n in r || (r = {}))
+    Dt.call(r, n) && dt(t, n, r[n]);
+  if (Pe)
+    for (var n of Pe(r))
+      It.call(r, n) && dt(t, n, r[n]);
+  return t;
+}, Tr = (t, r) => {
+  var n = {};
+  for (var i in t)
+    Dt.call(t, i) && r.indexOf(i) < 0 && (n[i] = t[i]);
+  if (t != null && Pe)
+    for (var i of Pe(t))
+      r.indexOf(i) < 0 && It.call(t, i) && (n[i] = t[i]);
+  return n;
+}, Me = xe.createContext(void 0);
+function Sr() {
+  const { options: t } = xe.useContext(Me) || {};
+  return Lt(t);
+}
+function Ht(t, r) {
+  if (t === r)
+    return !0;
+  if (typeof t != typeof r)
+    return !1;
+  if (typeof t == "object" && t !== null && r !== null) {
+    const n = Object.keys(t), i = Object.keys(r);
+    if (n.length !== i.length)
+      return !1;
+    for (const a of n)
+      if (!Ht(t[a], r[a]))
+        return !1;
+    return !0;
+  }
+  return !1;
+}
+var Nr = {
+  updateOnContextChanged: !0,
+  updateOnConfigurationChanged: !0,
+  suspendUntilReady: !1,
+  suspendWhileReconciling: !1
+}, Lt = (t = {}) => {
+  const r = t.updateOnContextChanged, n = t.updateOnConfigurationChanged, i = "suspendUntilReady" in t ? t.suspendUntilReady : t.suspend, a = "suspendWhileReconciling" in t ? t.suspendWhileReconciling : t.suspend;
+  return oe(oe(oe(oe({}, typeof i == "boolean" && { suspendUntilReady: i }), typeof a == "boolean" && { suspendWhileReconciling: a }), typeof r == "boolean" && { updateOnContextChanged: r }), typeof n == "boolean" && { updateOnConfigurationChanged: n });
+};
+function ht(t) {
+  let r, n;
+  throw new Promise((i, a) => {
+    r = i, n = a, t.addHandler(I.Ready, r), t.addHandler(I.Error, n);
+  }).finally(() => {
+    t.removeHandler(I.Ready, r), t.removeHandler(I.Ready, n);
+  });
+}
+function jt() {
+  const { client: t } = xe.useContext(Me) || {};
+  if (!t)
+    throw new Error(
+      "No OpenFeature client available - components using OpenFeature must be wrapped with an <OpenFeatureProvider>. If you are seeing this in a test, see: https://openfeature.dev/docs/reference/technologies/client/web/react#testing"
+    );
+  return t;
+}
+function kr() {
+  const t = jt(), [r, n] = K.useState(t.providerStatus);
+  return K.useEffect(() => {
+    const i = () => n(t.providerStatus);
+    return t.addHandler(I.ConfigurationChanged, i), t.addHandler(I.ContextChanged, i), t.addHandler(I.Error, i), t.addHandler(I.Ready, i), t.addHandler(I.Stale, i), t.addHandler(I.Reconciling, i), () => {
+      t.removeHandler(I.ConfigurationChanged, i), t.removeHandler(I.ContextChanged, i), t.removeHandler(I.Error, i), t.removeHandler(I.Ready, i), t.removeHandler(I.Stale, i), t.removeHandler(I.Reconciling, i);
+    };
+  }, [t]), r;
+}
+var Ce = class {
+  constructor(t) {
+    this._details = t;
+  }
+  get details() {
+    return this._details;
+  }
+  get value() {
+    var t;
+    return (t = this._details) == null ? void 0 : t.value;
+  }
+  get variant() {
+    return this._details.variant;
+  }
+  get flagMetadata() {
+    return this._details.flagMetadata;
+  }
+  get reason() {
+    return this._details.reason;
+  }
+  get isError() {
+    var t;
+    return !!((t = this._details) != null && t.errorCode) || this._details.reason == we.ERROR;
+  }
+  get errorCode() {
+    var t;
+    return (t = this._details) == null ? void 0 : t.errorCode;
+  }
+  get errorMessage() {
+    var t;
+    return (t = this._details) == null ? void 0 : t.errorMessage;
+  }
+  get isAuthoritative() {
+    return !this.isError && this._details.reason != we.STALE && this._details.reason != we.DISABLED;
+  }
+  get type() {
+    return typeof this._details.value;
+  }
+};
+function Dr(t, r, n) {
+  return typeof r == "boolean" ? new Ce(Ir(t, r, n)) : typeof r == "number" ? new Ce(Lr(t, r, n)) : typeof r == "string" ? new Ce(Hr(t, r, n)) : new Ce(jr(t, r, n));
+}
+function Ir(t, r, n) {
+  return be(
+    t,
+    r,
+    (i) => i.getBooleanDetails,
+    n
+  );
+}
+function Hr(t, r, n) {
+  return be(
+    t,
+    r,
+    (i) => i.getStringDetails,
+    n
+  );
+}
+function Lr(t, r, n) {
+  return be(
+    t,
+    r,
+    (i) => i.getNumberDetails,
+    n
+  );
+}
+function jr(t, r, n) {
+  return be(
+    t,
+    r,
+    (i) => i.getObjectDetails,
+    n
+  );
+}
+function xr(t, r) {
+  return !r || r.includes(t);
+}
+function be(t, r, n, i) {
+  const a = oe(oe(oe({}, Nr), Sr()), Lt(i)), c = jt(), h = kr();
+  a.suspendUntilReady && h === ee.NOT_READY && ht(c), a.suspendWhileReconciling && h === ee.RECONCILING && ht(c);
+  const [p, E] = K.useState(
+    n(c).call(c, t, r, i)
+  ), y = K.useRef(p);
+  K.useEffect(() => {
+    y.current = p;
+  }, [p]);
+  const f = () => {
+    const _ = n(c).call(c, t, r, i);
+    Ht(_.value, y.current.value) || E(_);
+  }, v = (_) => {
+    xr(t, _?.flagsChanged) && f();
+  };
+  return K.useEffect(() => (h === ee.NOT_READY && c.addHandler(I.Ready, f), a.updateOnContextChanged && c.addHandler(I.ContextChanged, f), () => {
+    c.removeHandler(I.Ready, f), c.removeHandler(I.ContextChanged, f);
+  }), []), K.useEffect(() => (a.updateOnConfigurationChanged && c.addHandler(I.ConfigurationChanged, v), () => {
+    c.removeHandler(I.ConfigurationChanged, v);
+  }), []), p;
+}
+function Mr(t) {
+  var r = t, { client: n, domain: i, children: a } = r, c = Tr(r, ["client", "domain", "children"]);
+  return n || (n = Ae.getClient(i)), /* @__PURE__ */ K.createElement(Me.Provider, { value: { client: n, options: c, domain: i } }, a);
+}
+function $r(t, r) {
+  return Ae.setProvider(r), {
+    useFeatureFlag: (n, i) => Dr(n.toString(), i ?? t[n].defaultValue),
+    FeatureFlagsProvider: Mr,
+    setFeatureFlagsContext: Ae.setContext.bind(Ae)
+  };
+}
+export {
+  $r as mkFeatureFlags
+};