wcz-test 6.9.3 → 6.9.4

package/dist/auth-client-B6cIXYDV.js

@@ -0,0 +1,1417 @@
+import { createTheme, darken, lighten } from "@mui/material";
+import { grey } from "@mui/material/colors";
+import { enUS as enUS$2, csCZ as csCZ$2 } from "@mui/material/locale";
+import { enUS, csCZ } from "@mui/x-data-grid/locales";
+import { enUS as enUS$1, csCZ as csCZ$1 } from "@mui/x-date-pickers/locales";
+import { useTranslation } from "react-i18next";
+import { e as env, B as BetterAuthError } from "./error-BhAKg8LX-X0sdNXNa.js";
+import { useRef, useCallback, useSyncExternalStore } from "react";
+import { c as clientEnv } from "./env-CoxTjaDr.js";
+const WISTRON_PRIMARY_COLOR = "#00506E";
+const WISTRON_SECONDARY_COLOR = "#64DC00";
+const LOCALE_MAP = {
+  cs: [csCZ, csCZ$1, csCZ$2],
+  en: [enUS, enUS$1, enUS$2]
+};
+const useGetTheme = (theme) => {
+  const { i18n } = useTranslation();
+  return createTheme(
+    {
+      cssVariables: {
+        colorSchemeSelector: "data-mui-color-scheme"
+      },
+      colorSchemes: {
+        light: {
+          palette: {
+            primary: { main: WISTRON_PRIMARY_COLOR },
+            secondary: { main: WISTRON_SECONDARY_COLOR }
+          }
+        },
+        dark: {
+          palette: {
+            primary: { main: lighten(WISTRON_PRIMARY_COLOR, 0.5) },
+            secondary: { main: darken(WISTRON_SECONDARY_COLOR, 0.5) }
+          }
+        },
+        ...theme?.colorSchemes
+      },
+      components: {
+        MuiCssBaseline: {
+          styleOverrides: ({ palette }) => {
+            return {
+              body: {
+                "&::-webkit-scrollbar, & *::-webkit-scrollbar": {
+                  width: "0.7em",
+                  height: "0.7em"
+                },
+                "&::-webkit-scrollbar-track, & *::-webkit-scrollbar-track": {
+                  backgroundColor: palette.mode === "dark" ? grey[900] : grey[200],
+                  borderRadius: "5px"
+                },
+                "&::-webkit-scrollbar-thumb, & *::-webkit-scrollbar-thumb": {
+                  backgroundColor: palette.mode === "dark" ? grey[800] : grey[400],
+                  borderRadius: "10px"
+                },
+                "&::-webkit-scrollbar-thumb:hover, & *::-webkit-scrollbar-thumb:hover": {
+                  backgroundColor: palette.mode === "dark" ? grey[700] : grey[500]
+                },
+                "&::-webkit-scrollbar-corner, & *::-webkit-scrollbar-corner": {
+                  backgroundColor: "transparent"
+                }
+              }
+            };
+          }
+        },
+        ...theme?.components
+      }
+    },
+    ...LOCALE_MAP[i18n.language]
+  );
+};
+function checkHasPath(url) {
+  try {
+    return (new URL(url).pathname.replace(/\/+$/, "") || "/") !== "/";
+  } catch (error) {
+    throw new BetterAuthError(`Invalid base URL: ${url}. Please provide a valid base URL.`);
+  }
+}
+function assertHasProtocol(url) {
+  try {
+    const parsedUrl = new URL(url);
+    if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") throw new BetterAuthError(`Invalid base URL: ${url}. URL must include 'http://' or 'https://'`);
+  } catch (error) {
+    if (error instanceof BetterAuthError) throw error;
+    throw new BetterAuthError(`Invalid base URL: ${url}. Please provide a valid base URL.`, String(error));
+  }
+}
+function withPath(url, path = "/api/auth") {
+  assertHasProtocol(url);
+  if (checkHasPath(url)) return url;
+  const trimmedUrl = url.replace(/\/+$/, "");
+  if (!path || path === "/") return trimmedUrl;
+  path = path.startsWith("/") ? path : `/${path}`;
+  return `${trimmedUrl}${path}`;
+}
+function getBaseURL(url, path, request, loadEnv) {
+  if (url) return withPath(url, path);
+  {
+    const fromEnv = env.BETTER_AUTH_URL || env.NEXT_PUBLIC_BETTER_AUTH_URL || env.PUBLIC_BETTER_AUTH_URL || env.NUXT_PUBLIC_BETTER_AUTH_URL || env.NUXT_PUBLIC_AUTH_URL || (env.BASE_URL !== "/" ? env.BASE_URL : void 0);
+    if (fromEnv) return withPath(fromEnv, path);
+  }
+  if (typeof window !== "undefined" && window.location) return withPath(window.location.origin, path);
+}
+const PROTO_POLLUTION_PATTERNS = {
+  proto: /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/,
+  constructor: /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/,
+  protoShort: /"__proto__"\s*:/,
+  constructorShort: /"constructor"\s*:/
+};
+const JSON_SIGNATURE = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
+const SPECIAL_VALUES = {
+  true: true,
+  false: false,
+  null: null,
+  undefined: void 0,
+  nan: NaN,
+  infinity: Number.POSITIVE_INFINITY,
+  "-infinity": Number.NEGATIVE_INFINITY
+};
+const ISO_DATE_REGEX = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,7}))?(?:Z|([+-])(\d{2}):(\d{2}))$/;
+function isValidDate(date) {
+  return date instanceof Date && !isNaN(date.getTime());
+}
+function parseISODate(value) {
+  const match = ISO_DATE_REGEX.exec(value);
+  if (!match) return null;
+  const [, year, month, day, hour, minute, second, ms, offsetSign, offsetHour, offsetMinute] = match;
+  let date = new Date(Date.UTC(parseInt(year, 10), parseInt(month, 10) - 1, parseInt(day, 10), parseInt(hour, 10), parseInt(minute, 10), parseInt(second, 10), ms ? parseInt(ms.padEnd(3, "0"), 10) : 0));
+  if (offsetSign) {
+    const offset = (parseInt(offsetHour, 10) * 60 + parseInt(offsetMinute, 10)) * (offsetSign === "+" ? -1 : 1);
+    date.setUTCMinutes(date.getUTCMinutes() + offset);
+  }
+  return isValidDate(date) ? date : null;
+}
+function betterJSONParse(value, options = {}) {
+  const { strict = false, warnings = false, reviver, parseDates = true } = options;
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  if (trimmed.length > 0 && trimmed[0] === '"' && trimmed.endsWith('"') && !trimmed.slice(1, -1).includes('"')) return trimmed.slice(1, -1);
+  const lowerValue = trimmed.toLowerCase();
+  if (lowerValue.length <= 9 && lowerValue in SPECIAL_VALUES) return SPECIAL_VALUES[lowerValue];
+  if (!JSON_SIGNATURE.test(trimmed)) {
+    if (strict) throw new SyntaxError("[better-json] Invalid JSON");
+    return value;
+  }
+  if (Object.entries(PROTO_POLLUTION_PATTERNS).some(([key, pattern]) => {
+    const matches = pattern.test(trimmed);
+    if (matches && warnings) console.warn(`[better-json] Detected potential prototype pollution attempt using ${key} pattern`);
+    return matches;
+  }) && strict) throw new Error("[better-json] Potential prototype pollution attempt detected");
+  try {
+    const secureReviver = (key, value$1) => {
+      if (key === "__proto__" || key === "constructor" && value$1 && typeof value$1 === "object" && "prototype" in value$1) {
+        if (warnings) console.warn(`[better-json] Dropping "${key}" key to prevent prototype pollution`);
+        return;
+      }
+      if (parseDates && typeof value$1 === "string") {
+        const date = parseISODate(value$1);
+        if (date) return date;
+      }
+      return reviver ? reviver(key, value$1) : value$1;
+    };
+    return JSON.parse(trimmed, secureReviver);
+  } catch (error) {
+    if (strict) throw error;
+    return value;
+  }
+}
+function parseJSON(value, options = { strict: true }) {
+  return betterJSONParse(value, options);
+}
+let clean = Symbol("clean");
+let listenerQueue = [];
+let lqIndex = 0;
+const QUEUE_ITEMS_PER_LISTENER = 4;
+const atom = /* @__NO_SIDE_EFFECTS__ */ (initialValue) => {
+  let listeners = [];
+  let $atom = {
+    get() {
+      if (!$atom.lc) {
+        $atom.listen(() => {
+        })();
+      }
+      return $atom.value;
+    },
+    lc: 0,
+    listen(listener) {
+      $atom.lc = listeners.push(listener);
+      return () => {
+        for (let i = lqIndex + QUEUE_ITEMS_PER_LISTENER; i < listenerQueue.length; ) {
+          if (listenerQueue[i] === listener) {
+            listenerQueue.splice(i, QUEUE_ITEMS_PER_LISTENER);
+          } else {
+            i += QUEUE_ITEMS_PER_LISTENER;
+          }
+        }
+        let index = listeners.indexOf(listener);
+        if (~index) {
+          listeners.splice(index, 1);
+          if (!--$atom.lc) $atom.off();
+        }
+      };
+    },
+    notify(oldValue, changedKey) {
+      let runListenerQueue = !listenerQueue.length;
+      for (let listener of listeners) {
+        listenerQueue.push(listener, $atom.value, oldValue, changedKey);
+      }
+      if (runListenerQueue) {
+        for (lqIndex = 0; lqIndex < listenerQueue.length; lqIndex += QUEUE_ITEMS_PER_LISTENER) {
+          listenerQueue[lqIndex](
+            listenerQueue[lqIndex + 1],
+            listenerQueue[lqIndex + 2],
+            listenerQueue[lqIndex + 3]
+          );
+        }
+        listenerQueue.length = 0;
+      }
+    },
+    /* It will be called on last listener unsubscribing.
+       We will redefine it in onMount and onStop. */
+    off() {
+    },
+    set(newValue) {
+      let oldValue = $atom.value;
+      if (oldValue !== newValue) {
+        $atom.value = newValue;
+        $atom.notify(oldValue);
+      }
+    },
+    subscribe(listener) {
+      let unbind = $atom.listen(listener);
+      listener($atom.value);
+      return unbind;
+    },
+    value: initialValue
+  };
+  if (process.env.NODE_ENV !== "production") {
+    $atom[clean] = () => {
+      listeners = [];
+      $atom.lc = 0;
+      $atom.off();
+    };
+  }
+  return $atom;
+};
+const MOUNT = 5;
+const UNMOUNT = 6;
+const REVERT_MUTATION = 10;
+let on = (object, listener, eventKey, mutateStore) => {
+  object.events = object.events || {};
+  if (!object.events[eventKey + REVERT_MUTATION]) {
+    object.events[eventKey + REVERT_MUTATION] = mutateStore((eventProps) => {
+      object.events[eventKey].reduceRight((event, l) => (l(event), event), {
+        shared: {},
+        ...eventProps
+      });
+    });
+  }
+  object.events[eventKey] = object.events[eventKey] || [];
+  object.events[eventKey].push(listener);
+  return () => {
+    let currentListeners = object.events[eventKey];
+    let index = currentListeners.indexOf(listener);
+    currentListeners.splice(index, 1);
+    if (!currentListeners.length) {
+      delete object.events[eventKey];
+      object.events[eventKey + REVERT_MUTATION]();
+      delete object.events[eventKey + REVERT_MUTATION];
+    }
+  };
+};
+let STORE_UNMOUNT_DELAY = 1e3;
+let onMount = ($store, initialize) => {
+  let listener = (payload) => {
+    let destroy = initialize(payload);
+    if (destroy) $store.events[UNMOUNT].push(destroy);
+  };
+  return on($store, listener, MOUNT, (runListeners) => {
+    let originListen = $store.listen;
+    $store.listen = (...args) => {
+      if (!$store.lc && !$store.active) {
+        $store.active = true;
+        runListeners();
+      }
+      return originListen(...args);
+    };
+    let originOff = $store.off;
+    $store.events[UNMOUNT] = [];
+    $store.off = () => {
+      originOff();
+      setTimeout(() => {
+        if ($store.active && !$store.lc) {
+          $store.active = false;
+          for (let destroy of $store.events[UNMOUNT]) destroy();
+          $store.events[UNMOUNT] = [];
+        }
+      }, STORE_UNMOUNT_DELAY);
+    };
+    if (process.env.NODE_ENV !== "production") {
+      let originClean = $store[clean];
+      $store[clean] = () => {
+        for (let destroy of $store.events[UNMOUNT]) destroy();
+        $store.events[UNMOUNT] = [];
+        $store.active = false;
+        originClean();
+      };
+    }
+    return () => {
+      $store.listen = originListen;
+      $store.off = originOff;
+    };
+  });
+};
+function listenKeys($store, keys, listener) {
+  let keysSet = new Set(keys).add(void 0);
+  return $store.listen((value, oldValue, changed) => {
+    if (keysSet.has(changed)) {
+      listener(value, oldValue, changed);
+    }
+  });
+}
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var BetterFetchError = class extends Error {
+  constructor(status, statusText, error) {
+    super(statusText || status.toString(), {
+      cause: error
+    });
+    this.status = status;
+    this.statusText = statusText;
+    this.error = error;
+  }
+};
+var initializePlugins = async (url, options) => {
+  var _a, _b, _c, _d, _e, _f;
+  let opts = options || {};
+  const hooks = {
+    onRequest: [options == null ? void 0 : options.onRequest],
+    onResponse: [options == null ? void 0 : options.onResponse],
+    onSuccess: [options == null ? void 0 : options.onSuccess],
+    onError: [options == null ? void 0 : options.onError],
+    onRetry: [options == null ? void 0 : options.onRetry]
+  };
+  if (!options || !(options == null ? void 0 : options.plugins)) {
+    return {
+      url,
+      options: opts,
+      hooks
+    };
+  }
+  for (const plugin of (options == null ? void 0 : options.plugins) || []) {
+    if (plugin.init) {
+      const pluginRes = await ((_a = plugin.init) == null ? void 0 : _a.call(plugin, url.toString(), options));
+      opts = pluginRes.options || opts;
+      url = pluginRes.url;
+    }
+    hooks.onRequest.push((_b = plugin.hooks) == null ? void 0 : _b.onRequest);
+    hooks.onResponse.push((_c = plugin.hooks) == null ? void 0 : _c.onResponse);
+    hooks.onSuccess.push((_d = plugin.hooks) == null ? void 0 : _d.onSuccess);
+    hooks.onError.push((_e = plugin.hooks) == null ? void 0 : _e.onError);
+    hooks.onRetry.push((_f = plugin.hooks) == null ? void 0 : _f.onRetry);
+  }
+  return {
+    url,
+    options: opts,
+    hooks
+  };
+};
+var LinearRetryStrategy = class {
+  constructor(options) {
+    this.options = options;
+  }
+  shouldAttemptRetry(attempt, response) {
+    if (this.options.shouldRetry) {
+      return Promise.resolve(
+        attempt < this.options.attempts && this.options.shouldRetry(response)
+      );
+    }
+    return Promise.resolve(attempt < this.options.attempts);
+  }
+  getDelay() {
+    return this.options.delay;
+  }
+};
+var ExponentialRetryStrategy = class {
+  constructor(options) {
+    this.options = options;
+  }
+  shouldAttemptRetry(attempt, response) {
+    if (this.options.shouldRetry) {
+      return Promise.resolve(
+        attempt < this.options.attempts && this.options.shouldRetry(response)
+      );
+    }
+    return Promise.resolve(attempt < this.options.attempts);
+  }
+  getDelay(attempt) {
+    const delay = Math.min(
+      this.options.maxDelay,
+      this.options.baseDelay * 2 ** attempt
+    );
+    return delay;
+  }
+};
+function createRetryStrategy(options) {
+  if (typeof options === "number") {
+    return new LinearRetryStrategy({
+      type: "linear",
+      attempts: options,
+      delay: 1e3
+    });
+  }
+  switch (options.type) {
+    case "linear":
+      return new LinearRetryStrategy(options);
+    case "exponential":
+      return new ExponentialRetryStrategy(options);
+    default:
+      throw new Error("Invalid retry strategy");
+  }
+}
+var getAuthHeader = async (options) => {
+  const headers = {};
+  const getValue = async (value) => typeof value === "function" ? await value() : value;
+  if (options == null ? void 0 : options.auth) {
+    if (options.auth.type === "Bearer") {
+      const token = await getValue(options.auth.token);
+      if (!token) {
+        return headers;
+      }
+      headers["authorization"] = `Bearer ${token}`;
+    } else if (options.auth.type === "Basic") {
+      const username = getValue(options.auth.username);
+      const password = getValue(options.auth.password);
+      if (!username || !password) {
+        return headers;
+      }
+      headers["authorization"] = `Basic ${btoa(`${username}:${password}`)}`;
+    } else if (options.auth.type === "Custom") {
+      const value = getValue(options.auth.value);
+      if (!value) {
+        return headers;
+      }
+      headers["authorization"] = `${getValue(options.auth.prefix)} ${value}`;
+    }
+  }
+  return headers;
+};
+var JSON_RE = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(;.+)?$/i;
+function detectResponseType(request) {
+  const _contentType = request.headers.get("content-type");
+  const textTypes = /* @__PURE__ */ new Set([
+    "image/svg",
+    "application/xml",
+    "application/xhtml",
+    "application/html"
+  ]);
+  if (!_contentType) {
+    return "json";
+  }
+  const contentType = _contentType.split(";").shift() || "";
+  if (JSON_RE.test(contentType)) {
+    return "json";
+  }
+  if (textTypes.has(contentType) || contentType.startsWith("text/")) {
+    return "text";
+  }
+  return "blob";
+}
+function isJSONParsable(value) {
+  try {
+    JSON.parse(value);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+function isJSONSerializable(value) {
+  if (value === void 0) {
+    return false;
+  }
+  const t = typeof value;
+  if (t === "string" || t === "number" || t === "boolean" || t === null) {
+    return true;
+  }
+  if (t !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return true;
+  }
+  if (value.buffer) {
+    return false;
+  }
+  return value.constructor && value.constructor.name === "Object" || typeof value.toJSON === "function";
+}
+function jsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    return text;
+  }
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function getFetch(options) {
+  if (options == null ? void 0 : options.customFetchImpl) {
+    return options.customFetchImpl;
+  }
+  if (typeof globalThis !== "undefined" && isFunction(globalThis.fetch)) {
+    return globalThis.fetch;
+  }
+  if (typeof window !== "undefined" && isFunction(window.fetch)) {
+    return window.fetch;
+  }
+  throw new Error("No fetch implementation found");
+}
+async function getHeaders(opts) {
+  const headers = new Headers(opts == null ? void 0 : opts.headers);
+  const authHeader = await getAuthHeader(opts);
+  for (const [key, value] of Object.entries(authHeader || {})) {
+    headers.set(key, value);
+  }
+  if (!headers.has("content-type")) {
+    const t = detectContentType(opts == null ? void 0 : opts.body);
+    if (t) {
+      headers.set("content-type", t);
+    }
+  }
+  return headers;
+}
+function detectContentType(body) {
+  if (isJSONSerializable(body)) {
+    return "application/json";
+  }
+  return null;
+}
+function getBody(options) {
+  if (!(options == null ? void 0 : options.body)) {
+    return null;
+  }
+  const headers = new Headers(options == null ? void 0 : options.headers);
+  if (isJSONSerializable(options.body) && !headers.has("content-type")) {
+    for (const [key, value] of Object.entries(options == null ? void 0 : options.body)) {
+      if (value instanceof Date) {
+        options.body[key] = value.toISOString();
+      }
+    }
+    return JSON.stringify(options.body);
+  }
+  return options.body;
+}
+function getMethod$1(url, options) {
+  var _a;
+  if (options == null ? void 0 : options.method) {
+    return options.method.toUpperCase();
+  }
+  if (url.startsWith("@")) {
+    const pMethod = (_a = url.split("@")[1]) == null ? void 0 : _a.split("/")[0];
+    if (!methods.includes(pMethod)) {
+      return (options == null ? void 0 : options.body) ? "POST" : "GET";
+    }
+    return pMethod.toUpperCase();
+  }
+  return (options == null ? void 0 : options.body) ? "POST" : "GET";
+}
+function getTimeout(options, controller) {
+  let abortTimeout;
+  if (!(options == null ? void 0 : options.signal) && (options == null ? void 0 : options.timeout)) {
+    abortTimeout = setTimeout(() => controller == null ? void 0 : controller.abort(), options == null ? void 0 : options.timeout);
+  }
+  return {
+    abortTimeout,
+    clearTimeout: () => {
+      if (abortTimeout) {
+        clearTimeout(abortTimeout);
+      }
+    }
+  };
+}
+var ValidationError = class _ValidationError extends Error {
+  constructor(issues, message) {
+    super(message || JSON.stringify(issues, null, 2));
+    this.issues = issues;
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+async function parseStandardSchema(schema, input) {
+  let result = await schema["~standard"].validate(input);
+  if (result.issues) {
+    throw new ValidationError(result.issues);
+  }
+  return result.value;
+}
+var methods = ["get", "post", "put", "patch", "delete"];
+var applySchemaPlugin = (config) => ({
+  id: "apply-schema",
+  name: "Apply Schema",
+  version: "1.0.0",
+  async init(url, options) {
+    var _a, _b, _c, _d;
+    const schema = ((_b = (_a = config.plugins) == null ? void 0 : _a.find(
+      (plugin) => {
+        var _a2;
+        return ((_a2 = plugin.schema) == null ? void 0 : _a2.config) ? url.startsWith(plugin.schema.config.baseURL || "") || url.startsWith(plugin.schema.config.prefix || "") : false;
+      }
+    )) == null ? void 0 : _b.schema) || config.schema;
+    if (schema) {
+      let urlKey = url;
+      if ((_c = schema.config) == null ? void 0 : _c.prefix) {
+        if (urlKey.startsWith(schema.config.prefix)) {
+          urlKey = urlKey.replace(schema.config.prefix, "");
+          if (schema.config.baseURL) {
+            url = url.replace(schema.config.prefix, schema.config.baseURL);
+          }
+        }
+      }
+      if ((_d = schema.config) == null ? void 0 : _d.baseURL) {
+        if (urlKey.startsWith(schema.config.baseURL)) {
+          urlKey = urlKey.replace(schema.config.baseURL, "");
+        }
+      }
+      const keySchema = schema.schema[urlKey];
+      if (keySchema) {
+        let opts = __spreadProps(__spreadValues({}, options), {
+          method: keySchema.method,
+          output: keySchema.output
+        });
+        if (!(options == null ? void 0 : options.disableValidation)) {
+          opts = __spreadProps(__spreadValues({}, opts), {
+            body: keySchema.input ? await parseStandardSchema(keySchema.input, options == null ? void 0 : options.body) : options == null ? void 0 : options.body,
+            params: keySchema.params ? await parseStandardSchema(keySchema.params, options == null ? void 0 : options.params) : options == null ? void 0 : options.params,
+            query: keySchema.query ? await parseStandardSchema(keySchema.query, options == null ? void 0 : options.query) : options == null ? void 0 : options.query
+          });
+        }
+        return {
+          url,
+          options: opts
+        };
+      }
+    }
+    return {
+      url,
+      options
+    };
+  }
+});
+var createFetch = (config) => {
+  async function $fetch(url, options) {
+    const opts = __spreadProps(__spreadValues(__spreadValues({}, config), options), {
+      plugins: [...(config == null ? void 0 : config.plugins) || [], applySchemaPlugin(config || {})]
+    });
+    if (config == null ? void 0 : config.catchAllError) {
+      try {
+        return await betterFetch(url, opts);
+      } catch (error) {
+        return {
+          data: null,
+          error: {
+            status: 500,
+            statusText: "Fetch Error",
+            message: "Fetch related error. Captured by catchAllError option. See error property for more details.",
+            error
+          }
+        };
+      }
+    }
+    return await betterFetch(url, opts);
+  }
+  return $fetch;
+};
+function getURL2(url, option) {
+  let { baseURL, params, query } = option || {
+    query: {},
+    params: {},
+    baseURL: ""
+  };
+  let basePath = url.startsWith("http") ? url.split("/").slice(0, 3).join("/") : baseURL || "";
+  if (url.startsWith("@")) {
+    const m = url.toString().split("@")[1].split("/")[0];
+    if (methods.includes(m)) {
+      url = url.replace(`@${m}/`, "/");
+    }
+  }
+  if (!basePath.endsWith("/")) basePath += "/";
+  let [path, urlQuery] = url.replace(basePath, "").split("?");
+  const queryParams = new URLSearchParams(urlQuery);
+  for (const [key, value] of Object.entries(query || {})) {
+    if (value == null) continue;
+    queryParams.set(key, String(value));
+  }
+  if (params) {
+    if (Array.isArray(params)) {
+      const paramPaths = path.split("/").filter((p) => p.startsWith(":"));
+      for (const [index, key] of paramPaths.entries()) {
+        const value = params[index];
+        path = path.replace(key, value);
+      }
+    } else {
+      for (const [key, value] of Object.entries(params)) {
+        path = path.replace(`:${key}`, String(value));
+      }
+    }
+  }
+  path = path.split("/").map(encodeURIComponent).join("/");
+  if (path.startsWith("/")) path = path.slice(1);
+  let queryParamString = queryParams.toString();
+  queryParamString = queryParamString.length > 0 ? `?${queryParamString}`.replace(/\+/g, "%20") : "";
+  if (!basePath.startsWith("http")) {
+    return `${basePath}${path}${queryParamString}`;
+  }
+  const _url = new URL(`${path}${queryParamString}`, basePath);
+  return _url;
+}
+var betterFetch = async (url, options) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const {
+    hooks,
+    url: __url,
+    options: opts
+  } = await initializePlugins(url, options);
+  const fetch2 = getFetch(opts);
+  const controller = new AbortController();
+  const signal = (_a = opts.signal) != null ? _a : controller.signal;
+  const _url = getURL2(__url, opts);
+  const body = getBody(opts);
+  const headers = await getHeaders(opts);
+  const method = getMethod$1(__url, opts);
+  let context = __spreadProps(__spreadValues({}, opts), {
+    url: _url,
+    headers,
+    body,
+    method,
+    signal
+  });
+  for (const onRequest of hooks.onRequest) {
+    if (onRequest) {
+      const res = await onRequest(context);
+      if (res instanceof Object) {
+        context = res;
+      }
+    }
+  }
+  if ("pipeTo" in context && typeof context.pipeTo === "function" || typeof ((_b = options == null ? void 0 : options.body) == null ? void 0 : _b.pipe) === "function") {
+    if (!("duplex" in context)) {
+      context.duplex = "half";
+    }
+  }
+  const { clearTimeout: clearTimeout2 } = getTimeout(opts, controller);
+  let response = await fetch2(context.url, context);
+  clearTimeout2();
+  const responseContext = {
+    response,
+    request: context
+  };
+  for (const onResponse of hooks.onResponse) {
+    if (onResponse) {
+      const r = await onResponse(__spreadProps(__spreadValues({}, responseContext), {
+        response: ((_c = options == null ? void 0 : options.hookOptions) == null ? void 0 : _c.cloneResponse) ? response.clone() : response
+      }));
+      if (r instanceof Response) {
+        response = r;
+      } else if (r instanceof Object) {
+        response = r.response;
+      }
+    }
+  }
+  if (response.ok) {
+    const hasBody = context.method !== "HEAD";
+    if (!hasBody) {
+      return {
+        data: "",
+        error: null
+      };
+    }
+    const responseType = detectResponseType(response);
+    const successContext = {
+      data: "",
+      response,
+      request: context
+    };
+    if (responseType === "json" || responseType === "text") {
+      const text = await response.text();
+      const parser2 = (_d = context.jsonParser) != null ? _d : jsonParse;
+      const data = await parser2(text);
+      successContext.data = data;
+    } else {
+      successContext.data = await response[responseType]();
+    }
+    if (context == null ? void 0 : context.output) {
+      if (context.output && !context.disableValidation) {
+        successContext.data = await parseStandardSchema(
+          context.output,
+          successContext.data
+        );
+      }
+    }
+    for (const onSuccess of hooks.onSuccess) {
+      if (onSuccess) {
+        await onSuccess(__spreadProps(__spreadValues({}, successContext), {
+          response: ((_e = options == null ? void 0 : options.hookOptions) == null ? void 0 : _e.cloneResponse) ? response.clone() : response
+        }));
+      }
+    }
+    if (options == null ? void 0 : options.throw) {
+      return successContext.data;
+    }
+    return {
+      data: successContext.data,
+      error: null
+    };
+  }
+  const parser = (_f = options == null ? void 0 : options.jsonParser) != null ? _f : jsonParse;
+  const responseText = await response.text();
+  const isJSONResponse = isJSONParsable(responseText);
+  const errorObject = isJSONResponse ? await parser(responseText) : null;
+  const errorContext = {
+    response,
+    responseText,
+    request: context,
+    error: __spreadProps(__spreadValues({}, errorObject), {
+      status: response.status,
+      statusText: response.statusText
+    })
+  };
+  for (const onError of hooks.onError) {
+    if (onError) {
+      await onError(__spreadProps(__spreadValues({}, errorContext), {
+        response: ((_g = options == null ? void 0 : options.hookOptions) == null ? void 0 : _g.cloneResponse) ? response.clone() : response
+      }));
+    }
+  }
+  if (options == null ? void 0 : options.retry) {
+    const retryStrategy = createRetryStrategy(options.retry);
+    const _retryAttempt = (_h = options.retryAttempt) != null ? _h : 0;
+    if (await retryStrategy.shouldAttemptRetry(_retryAttempt, response)) {
+      for (const onRetry of hooks.onRetry) {
+        if (onRetry) {
+          await onRetry(responseContext);
+        }
+      }
+      const delay = retryStrategy.getDelay(_retryAttempt);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      return await betterFetch(url, __spreadProps(__spreadValues({}, options), {
+        retryAttempt: _retryAttempt + 1
+      }));
+    }
+  }
+  if (options == null ? void 0 : options.throw) {
+    throw new BetterFetchError(
+      response.status,
+      response.statusText,
+      isJSONResponse ? errorObject : responseText
+    );
+  }
+  return {
+    data: null,
+    error: __spreadProps(__spreadValues({}, errorObject), {
+      status: response.status,
+      statusText: response.statusText
+    })
+  };
+};
+const kBroadcastChannel = Symbol.for("better-auth:broadcast-channel");
+const now$1 = () => Math.floor(Date.now() / 1e3);
+var WindowBroadcastChannel = class {
+  listeners = /* @__PURE__ */ new Set();
+  name;
+  constructor(name = "better-auth.message") {
+    this.name = name;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  post(message) {
+    if (typeof window === "undefined") return;
+    try {
+      localStorage.setItem(this.name, JSON.stringify({
+        ...message,
+        timestamp: now$1()
+      }));
+    } catch {
+    }
+  }
+  setup() {
+    if (typeof window === "undefined" || typeof window.addEventListener === "undefined") return () => {
+    };
+    const handler = (event) => {
+      if (event.key !== this.name) return;
+      const message = JSON.parse(event.newValue ?? "{}");
+      if (message?.event !== "session" || !message?.data) return;
+      this.listeners.forEach((listener) => listener(message));
+    };
+    window.addEventListener("storage", handler);
+    return () => {
+      window.removeEventListener("storage", handler);
+    };
+  }
+};
+function getGlobalBroadcastChannel(name = "better-auth.message") {
+  if (!globalThis[kBroadcastChannel]) globalThis[kBroadcastChannel] = new WindowBroadcastChannel(name);
+  return globalThis[kBroadcastChannel];
+}
+const kFocusManager = Symbol.for("better-auth:focus-manager");
+var WindowFocusManager = class {
+  listeners = /* @__PURE__ */ new Set();
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  setFocused(focused) {
+    this.listeners.forEach((listener) => listener(focused));
+  }
+  setup() {
+    if (typeof window === "undefined" || typeof document === "undefined" || typeof window.addEventListener === "undefined") return () => {
+    };
+    const onFocus = () => this.setFocused(true);
+    const visibilityHandler = () => {
+      if (document.visibilityState === "visible") this.setFocused(true);
+    };
+    window.addEventListener("focus", onFocus, false);
+    document.addEventListener("visibilitychange", visibilityHandler, false);
+    return () => {
+      window.removeEventListener("focus", onFocus, false);
+      document.removeEventListener("visibilitychange", visibilityHandler, false);
+    };
+  }
+};
+function getGlobalFocusManager() {
+  if (!globalThis[kFocusManager]) globalThis[kFocusManager] = new WindowFocusManager();
+  return globalThis[kFocusManager];
+}
+const kOnlineManager = Symbol.for("better-auth:online-manager");
+var WindowOnlineManager = class {
+  listeners = /* @__PURE__ */ new Set();
+  isOnline = typeof navigator !== "undefined" ? navigator.onLine : true;
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  setOnline(online) {
+    this.isOnline = online;
+    this.listeners.forEach((listener) => listener(online));
+  }
+  setup() {
+    if (typeof window === "undefined" || typeof window.addEventListener === "undefined") return () => {
+    };
+    const onOnline = () => this.setOnline(true);
+    const onOffline = () => this.setOnline(false);
+    window.addEventListener("online", onOnline, false);
+    window.addEventListener("offline", onOffline, false);
+    return () => {
+      window.removeEventListener("online", onOnline, false);
+      window.removeEventListener("offline", onOffline, false);
+    };
+  }
+};
+function getGlobalOnlineManager() {
+  if (!globalThis[kOnlineManager]) globalThis[kOnlineManager] = new WindowOnlineManager();
+  return globalThis[kOnlineManager];
+}
+const isServer = () => typeof window === "undefined";
+const useAuthQuery = (initializedAtom, path, $fetch, options) => {
+  const value = /* @__PURE__ */ atom({
+    data: null,
+    error: null,
+    isPending: true,
+    isRefetching: false,
+    refetch: (queryParams) => fn(queryParams)
+  });
+  const fn = async (queryParams) => {
+    return new Promise((resolve) => {
+      const opts = typeof options === "function" ? options({
+        data: value.get().data,
+        error: value.get().error,
+        isPending: value.get().isPending
+      }) : options;
+      $fetch(path, {
+        ...opts,
+        query: {
+          ...opts?.query,
+          ...queryParams?.query
+        },
+        async onSuccess(context) {
+          value.set({
+            data: context.data,
+            error: null,
+            isPending: false,
+            isRefetching: false,
+            refetch: value.value.refetch
+          });
+          await opts?.onSuccess?.(context);
+        },
+        async onError(context) {
+          const { request } = context;
+          const retryAttempts = typeof request.retry === "number" ? request.retry : request.retry?.attempts;
+          const retryAttempt = request.retryAttempt || 0;
+          if (retryAttempts && retryAttempt < retryAttempts) return;
+          value.set({
+            error: context.error,
+            data: null,
+            isPending: false,
+            isRefetching: false,
+            refetch: value.value.refetch
+          });
+          await opts?.onError?.(context);
+        },
+        async onRequest(context) {
+          const currentValue = value.get();
+          value.set({
+            isPending: currentValue.data === null,
+            data: currentValue.data,
+            error: null,
+            isRefetching: true,
+            refetch: value.value.refetch
+          });
+          await opts?.onRequest?.(context);
+        }
+      }).catch((error) => {
+        value.set({
+          error,
+          data: null,
+          isPending: false,
+          isRefetching: false,
+          refetch: value.value.refetch
+        });
+      }).finally(() => {
+        resolve(void 0);
+      });
+    });
+  };
+  initializedAtom = Array.isArray(initializedAtom) ? initializedAtom : [initializedAtom];
+  let isMounted = false;
+  for (const initAtom of initializedAtom) initAtom.subscribe(async () => {
+    if (isServer()) return;
+    if (isMounted) await fn();
+    else onMount(value, () => {
+      const timeoutId = setTimeout(async () => {
+        if (!isMounted) {
+          await fn();
+          isMounted = true;
+        }
+      }, 0);
+      return () => {
+        value.off();
+        initAtom.off();
+        clearTimeout(timeoutId);
+      };
+    });
+  });
+  return value;
+};
+const now = () => Math.floor(Date.now() / 1e3);
+const FOCUS_REFETCH_RATE_LIMIT_SECONDS = 5;
+function createSessionRefreshManager(opts) {
+  const { sessionAtom, sessionSignal, $fetch, options = {} } = opts;
+  const refetchInterval = options.sessionOptions?.refetchInterval ?? 0;
+  const refetchOnWindowFocus = options.sessionOptions?.refetchOnWindowFocus ?? true;
+  const refetchWhenOffline = options.sessionOptions?.refetchWhenOffline ?? false;
+  const state = {
+    lastSync: 0,
+    lastSessionRequest: 0,
+    cachedSession: void 0
+  };
+  const shouldRefetch = () => {
+    return refetchWhenOffline || getGlobalOnlineManager().isOnline;
+  };
+  const triggerRefetch = (event) => {
+    if (!shouldRefetch()) return;
+    if (event?.event === "storage") {
+      state.lastSync = now();
+      sessionSignal.set(!sessionSignal.get());
+      return;
+    }
+    const currentSession = sessionAtom.get();
+    if (event?.event === "poll") {
+      state.lastSessionRequest = now();
+      $fetch("/get-session").then((res) => {
+        sessionAtom.set({
+          ...currentSession,
+          data: res.data,
+          error: res.error || null
+        });
+        state.lastSync = now();
+        sessionSignal.set(!sessionSignal.get());
+      }).catch(() => {
+      });
+      return;
+    }
+    if (event?.event === "visibilitychange") {
+      if (now() - state.lastSessionRequest < FOCUS_REFETCH_RATE_LIMIT_SECONDS && currentSession?.data !== null && currentSession?.data !== void 0) return;
+    }
+    if (currentSession?.data === null || currentSession?.data === void 0 || event?.event === "visibilitychange") {
+      if (event?.event === "visibilitychange") state.lastSessionRequest = now();
+      state.lastSync = now();
+      sessionSignal.set(!sessionSignal.get());
+    }
+  };
+  const broadcastSessionUpdate = (trigger) => {
+    getGlobalBroadcastChannel().post({
+      event: "session",
+      data: { trigger },
+      clientId: Math.random().toString(36).substring(7)
+    });
+  };
+  const setupPolling = () => {
+    if (refetchInterval && refetchInterval > 0) state.pollInterval = setInterval(() => {
+      if (sessionAtom.get()?.data) triggerRefetch({ event: "poll" });
+    }, refetchInterval * 1e3);
+  };
+  const setupBroadcast = () => {
+    state.unsubscribeBroadcast = getGlobalBroadcastChannel().subscribe(() => {
+      triggerRefetch({ event: "storage" });
+    });
+  };
+  const setupFocusRefetch = () => {
+    if (!refetchOnWindowFocus) return;
+    state.unsubscribeFocus = getGlobalFocusManager().subscribe(() => {
+      triggerRefetch({ event: "visibilitychange" });
+    });
+  };
+  const setupOnlineRefetch = () => {
+    state.unsubscribeOnline = getGlobalOnlineManager().subscribe((online) => {
+      if (online) triggerRefetch({ event: "visibilitychange" });
+    });
+  };
+  const init = () => {
+    setupPolling();
+    setupBroadcast();
+    setupFocusRefetch();
+    setupOnlineRefetch();
+    getGlobalBroadcastChannel().setup();
+    getGlobalFocusManager().setup();
+    getGlobalOnlineManager().setup();
+  };
+  const cleanup = () => {
+    if (state.pollInterval) {
+      clearInterval(state.pollInterval);
+      state.pollInterval = void 0;
+    }
+    if (state.unsubscribeBroadcast) {
+      state.unsubscribeBroadcast();
+      state.unsubscribeBroadcast = void 0;
+    }
+    if (state.unsubscribeFocus) {
+      state.unsubscribeFocus();
+      state.unsubscribeFocus = void 0;
+    }
+    if (state.unsubscribeOnline) {
+      state.unsubscribeOnline();
+      state.unsubscribeOnline = void 0;
+    }
+    state.lastSync = 0;
+    state.lastSessionRequest = 0;
+    state.cachedSession = void 0;
+  };
+  return {
+    init,
+    cleanup,
+    triggerRefetch,
+    broadcastSessionUpdate
+  };
+}
+const redirectPlugin = {
+  id: "redirect",
+  name: "Redirect",
+  hooks: { onSuccess(context) {
+    if (context.data?.url && context.data?.redirect) {
+      if (typeof window !== "undefined" && window.location) {
+        if (window.location) try {
+          window.location.href = context.data.url;
+        } catch {
+        }
+      }
+    }
+  } }
+};
+const userAgentPlugin = {
+  id: "user-agent",
+  name: "UserAgent",
+  hooks: { onRequest(context) {
+    context.headers.append("user-agent", "better-auth");
+  } }
+};
+function getSessionAtom($fetch, options) {
+  const $signal = /* @__PURE__ */ atom(false);
+  const session = useAuthQuery($signal, "/get-session", $fetch, { method: "GET" });
+  onMount(session, () => {
+    const refreshManager = createSessionRefreshManager({
+      sessionAtom: session,
+      sessionSignal: $signal,
+      $fetch,
+      options
+    });
+    refreshManager.init();
+    return () => {
+      refreshManager.cleanup();
+    };
+  });
+  return {
+    session,
+    $sessionSignal: $signal
+  };
+}
+const getClientConfig = (options, loadEnv) => {
+  const isCredentialsSupported = "credentials" in Request.prototype;
+  const baseURL = getBaseURL(options?.baseURL, options?.basePath) ?? "/api/auth";
+  const pluginsFetchPlugins = options?.plugins?.flatMap((plugin) => plugin.fetchPlugins).filter((pl) => pl !== void 0) || [];
+  const lifeCyclePlugin = {
+    id: "lifecycle-hooks",
+    name: "lifecycle-hooks",
+    hooks: {
+      onSuccess: options?.fetchOptions?.onSuccess,
+      onError: options?.fetchOptions?.onError,
+      onRequest: options?.fetchOptions?.onRequest,
+      onResponse: options?.fetchOptions?.onResponse
+    }
+  };
+  const { onSuccess, onError, onRequest, onResponse, ...restOfFetchOptions } = options?.fetchOptions || {};
+  const $fetch = createFetch({
+    baseURL,
+    ...isCredentialsSupported ? { credentials: "include" } : {},
+    method: "GET",
+    jsonParser(text) {
+      if (!text) return null;
+      return parseJSON(text, { strict: false });
+    },
+    customFetchImpl: fetch,
+    ...restOfFetchOptions,
+    plugins: [
+      lifeCyclePlugin,
+      ...restOfFetchOptions.plugins || [],
+      ...options?.disableDefaultFetchPlugins ? [] : [userAgentPlugin, redirectPlugin],
+      ...pluginsFetchPlugins
+    ]
+  });
+  const { $sessionSignal, session } = getSessionAtom($fetch, options);
+  const plugins = options?.plugins || [];
+  let pluginsActions = {};
+  let pluginsAtoms = {
+    $sessionSignal,
+    session
+  };
+  let pluginPathMethods = {
+    "/sign-out": "POST",
+    "/revoke-sessions": "POST",
+    "/revoke-other-sessions": "POST",
+    "/delete-user": "POST"
+  };
+  const atomListeners = [{
+    signal: "$sessionSignal",
+    matcher(path) {
+      return path === "/sign-out" || path === "/update-user" || path === "/sign-up/email" || path === "/sign-in/email" || path === "/delete-user" || path === "/verify-email" || path === "/revoke-sessions" || path === "/revoke-session" || path === "/change-email";
+    }
+  }];
+  for (const plugin of plugins) {
+    if (plugin.getAtoms) Object.assign(pluginsAtoms, plugin.getAtoms?.($fetch));
+    if (plugin.pathMethods) Object.assign(pluginPathMethods, plugin.pathMethods);
+    if (plugin.atomListeners) atomListeners.push(...plugin.atomListeners);
+  }
+  const $store = {
+    notify: (signal) => {
+      pluginsAtoms[signal].set(!pluginsAtoms[signal].get());
+    },
+    listen: (signal, listener) => {
+      pluginsAtoms[signal].subscribe(listener);
+    },
+    atoms: pluginsAtoms
+  };
+  for (const plugin of plugins) if (plugin.getActions) Object.assign(pluginsActions, plugin.getActions?.($fetch, $store, options));
+  return {
+    get baseURL() {
+      return baseURL;
+    },
+    pluginsActions,
+    pluginsAtoms,
+    pluginPathMethods,
+    atomListeners,
+    $fetch,
+    $store
+  };
+};
+function isAtom(value) {
+  return typeof value === "object" && value !== null && "get" in value && typeof value.get === "function" && "lc" in value && typeof value.lc === "number";
+}
+function getMethod(path, knownPathMethods, args) {
+  const method = knownPathMethods[path];
+  const { fetchOptions, query, ...body } = args || {};
+  if (method) return method;
+  if (fetchOptions?.method) return fetchOptions.method;
+  if (body && Object.keys(body).length > 0) return "POST";
+  return "GET";
+}
+function createDynamicPathProxy(routes, client, knownPathMethods, atoms, atomListeners) {
+  function createProxy(path = []) {
+    return new Proxy(function() {
+    }, {
+      get(_, prop) {
+        if (typeof prop !== "string") return;
+        if (prop === "then" || prop === "catch" || prop === "finally") return;
+        const fullPath = [...path, prop];
+        let current = routes;
+        for (const segment of fullPath) if (current && typeof current === "object" && segment in current) current = current[segment];
+        else {
+          current = void 0;
+          break;
+        }
+        if (typeof current === "function") return current;
+        if (isAtom(current)) return current;
+        return createProxy(fullPath);
+      },
+      apply: async (_, __, args) => {
+        const routePath = "/" + path.map((segment) => segment.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)).join("/");
+        const arg = args[0] || {};
+        const fetchOptions = args[1] || {};
+        const { query, fetchOptions: argFetchOptions, ...body } = arg;
+        const options = {
+          ...fetchOptions,
+          ...argFetchOptions
+        };
+        const method = getMethod(routePath, knownPathMethods, arg);
+        return await client(routePath, {
+          ...options,
+          body: method === "GET" ? void 0 : {
+            ...body,
+            ...options?.body || {}
+          },
+          query: query || options?.query,
+          method,
+          async onSuccess(context) {
+            await options?.onSuccess?.(context);
+            if (!atomListeners || options.disableSignal) return;
+            const matches = atomListeners.filter((s) => s.matcher(routePath));
+            if (!matches.length) return;
+            for (const match of matches) {
+              const signal = atoms[match.signal];
+              if (!signal) return;
+              const val = signal.get();
+              setTimeout(() => {
+                signal.set(!val);
+              }, 10);
+            }
+          }
+        });
+      }
+    });
+  }
+  return createProxy();
+}
+function useStore(store, options = {}) {
+  let snapshotRef = useRef(store.get());
+  const { keys, deps = [store, keys] } = options;
+  let subscribe = useCallback((onChange) => {
+    const emitChange = (value) => {
+      if (snapshotRef.current === value) return;
+      snapshotRef.current = value;
+      onChange();
+    };
+    emitChange(store.value);
+    if (keys?.length) return listenKeys(store, keys, emitChange);
+    return store.listen(emitChange);
+  }, deps);
+  let get = () => snapshotRef.current;
+  return useSyncExternalStore(subscribe, get, get);
+}
+function getAtomKey(str) {
+  return `use${capitalizeFirstLetter(str)}`;
+}
+function capitalizeFirstLetter(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function createAuthClient(options) {
+  const { pluginPathMethods, pluginsActions, pluginsAtoms, $fetch, $store, atomListeners } = getClientConfig(options);
+  let resolvedHooks = {};
+  for (const [key, value] of Object.entries(pluginsAtoms)) resolvedHooks[getAtomKey(key)] = () => useStore(value);
+  return createDynamicPathProxy({
+    ...pluginsActions,
+    ...resolvedHooks,
+    $fetch,
+    $store
+  }, $fetch, pluginPathMethods, pluginsAtoms, atomListeners);
+}
+const authClient = createAuthClient({
+  baseURL: clientEnv.VITE_API_URL
+});
+export {
+  WISTRON_PRIMARY_COLOR as W,
+  authClient as a,
+  WISTRON_SECONDARY_COLOR as b,
+  useGetTheme as u
+};
+//# sourceMappingURL=auth-client-B6cIXYDV.js.map