@erikey/react 0.3.5 → 0.4.1

package/dist/chunk-Y3WVYSUI.mjs

@@ -0,0 +1,1150 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// ../../../node_modules/.pnpm/@better-auth+core@1.4.10_@better-auth+utils@0.3.0_@better-fetch+fetch@1.1.21_better-call@1.1._s4ptmt7cznbdkhj2rfry3i4hxy/node_modules/@better-auth/core/dist/env-DbssmzoK.mjs
+var _envShim = /* @__PURE__ */ Object.create(null);
+var _getEnv = (useShim) => globalThis.process?.env || globalThis.Deno?.env.toObject() || globalThis.__env__ || (useShim ? _envShim : globalThis);
+var env = new Proxy(_envShim, {
+  get(_, prop) {
+    return _getEnv()[prop] ?? _envShim[prop];
+  },
+  has(_, prop) {
+    return prop in _getEnv() || prop in _envShim;
+  },
+  set(_, prop, value) {
+    const env$1 = _getEnv(true);
+    env$1[prop] = value;
+    return true;
+  },
+  deleteProperty(_, prop) {
+    if (!prop) return false;
+    const env$1 = _getEnv(true);
+    delete env$1[prop];
+    return true;
+  },
+  ownKeys() {
+    const env$1 = _getEnv(true);
+    return Object.keys(env$1);
+  }
+});
+var nodeENV = typeof process !== "undefined" && process.env && process.env.NODE_ENV || "";
+function getEnvVar(key, fallback) {
+  if (typeof process !== "undefined" && process.env) return process.env[key] ?? fallback;
+  if (typeof Deno !== "undefined") return Deno.env.get(key) ?? fallback;
+  if (typeof Bun !== "undefined") return Bun.env[key] ?? fallback;
+  return fallback;
+}
+var ENV = Object.freeze({
+  get BETTER_AUTH_SECRET() {
+    return getEnvVar("BETTER_AUTH_SECRET");
+  },
+  get AUTH_SECRET() {
+    return getEnvVar("AUTH_SECRET");
+  },
+  get BETTER_AUTH_TELEMETRY() {
+    return getEnvVar("BETTER_AUTH_TELEMETRY");
+  },
+  get BETTER_AUTH_TELEMETRY_ID() {
+    return getEnvVar("BETTER_AUTH_TELEMETRY_ID");
+  },
+  get NODE_ENV() {
+    return getEnvVar("NODE_ENV", "development");
+  },
+  get PACKAGE_VERSION() {
+    return getEnvVar("PACKAGE_VERSION", "0.0.0");
+  },
+  get BETTER_AUTH_TELEMETRY_ENDPOINT() {
+    return getEnvVar("BETTER_AUTH_TELEMETRY_ENDPOINT", "https://telemetry.better-auth.com/v1/track");
+  }
+});
+var COLORS_2 = 1;
+var COLORS_16 = 4;
+var COLORS_256 = 8;
+var COLORS_16m = 24;
+var TERM_ENVS = {
+  eterm: COLORS_16,
+  cons25: COLORS_16,
+  console: COLORS_16,
+  cygwin: COLORS_16,
+  dtterm: COLORS_16,
+  gnome: COLORS_16,
+  hurd: COLORS_16,
+  jfbterm: COLORS_16,
+  konsole: COLORS_16,
+  kterm: COLORS_16,
+  mlterm: COLORS_16,
+  mosh: COLORS_16m,
+  putty: COLORS_16,
+  st: COLORS_16,
+  "rxvt-unicode-24bit": COLORS_16m,
+  terminator: COLORS_16m,
+  "xterm-kitty": COLORS_16m
+};
+var CI_ENVS_MAP = new Map(Object.entries({
+  APPVEYOR: COLORS_256,
+  BUILDKITE: COLORS_256,
+  CIRCLECI: COLORS_16m,
+  DRONE: COLORS_256,
+  GITEA_ACTIONS: COLORS_16m,
+  GITHUB_ACTIONS: COLORS_16m,
+  GITLAB_CI: COLORS_256,
+  TRAVIS: COLORS_256
+}));
+var TERM_ENVS_REG_EXP = [
+  /ansi/,
+  /color/,
+  /linux/,
+  /direct/,
+  /^con[0-9]*x[0-9]/,
+  /^rxvt/,
+  /^screen/,
+  /^xterm/,
+  /^vt100/,
+  /^vt220/
+];
+function getColorDepth() {
+  if (getEnvVar("FORCE_COLOR") !== void 0) switch (getEnvVar("FORCE_COLOR")) {
+    case "":
+    case "1":
+    case "true":
+      return COLORS_16;
+    case "2":
+      return COLORS_256;
+    case "3":
+      return COLORS_16m;
+    default:
+      return COLORS_2;
+  }
+  if (getEnvVar("NODE_DISABLE_COLORS") !== void 0 && getEnvVar("NODE_DISABLE_COLORS") !== "" || getEnvVar("NO_COLOR") !== void 0 && getEnvVar("NO_COLOR") !== "" || getEnvVar("TERM") === "dumb") return COLORS_2;
+  if (getEnvVar("TMUX")) return COLORS_16m;
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) return COLORS_16;
+  if ("CI" in env) {
+    for (const { 0: envName, 1: colors } of CI_ENVS_MAP) if (envName in env) return colors;
+    if (getEnvVar("CI_NAME") === "codeship") return COLORS_256;
+    return COLORS_2;
+  }
+  if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.exec(getEnvVar("TEAMCITY_VERSION")) !== null ? COLORS_16 : COLORS_2;
+  switch (getEnvVar("TERM_PROGRAM")) {
+    case "iTerm.app":
+      if (!getEnvVar("TERM_PROGRAM_VERSION") || /^[0-2]\./.exec(getEnvVar("TERM_PROGRAM_VERSION")) !== null) return COLORS_256;
+      return COLORS_16m;
+    case "HyperTerm":
+    case "MacTerm":
+      return COLORS_16m;
+    case "Apple_Terminal":
+      return COLORS_256;
+  }
+  if (getEnvVar("COLORTERM") === "truecolor" || getEnvVar("COLORTERM") === "24bit") return COLORS_16m;
+  if (getEnvVar("TERM")) {
+    if (/truecolor/.exec(getEnvVar("TERM")) !== null) return COLORS_16m;
+    if (/^xterm-256/.exec(getEnvVar("TERM")) !== null) return COLORS_256;
+    const termEnv = getEnvVar("TERM").toLowerCase();
+    if (TERM_ENVS[termEnv]) return TERM_ENVS[termEnv];
+    if (TERM_ENVS_REG_EXP.some((term) => term.exec(termEnv) !== null)) return COLORS_16;
+  }
+  if (getEnvVar("COLORTERM")) return COLORS_16;
+  return COLORS_2;
+}
+var TTY_COLORS = {
+  reset: "\x1B[0m",
+  bright: "\x1B[1m",
+  dim: "\x1B[2m",
+  undim: "\x1B[22m",
+  underscore: "\x1B[4m",
+  blink: "\x1B[5m",
+  reverse: "\x1B[7m",
+  hidden: "\x1B[8m",
+  fg: {
+    black: "\x1B[30m",
+    red: "\x1B[31m",
+    green: "\x1B[32m",
+    yellow: "\x1B[33m",
+    blue: "\x1B[34m",
+    magenta: "\x1B[35m",
+    cyan: "\x1B[36m",
+    white: "\x1B[37m"
+  },
+  bg: {
+    black: "\x1B[40m",
+    red: "\x1B[41m",
+    green: "\x1B[42m",
+    yellow: "\x1B[43m",
+    blue: "\x1B[44m",
+    magenta: "\x1B[45m",
+    cyan: "\x1B[46m",
+    white: "\x1B[47m"
+  }
+};
+var levels = [
+  "debug",
+  "info",
+  "success",
+  "warn",
+  "error"
+];
+function shouldPublishLog(currentLogLevel, logLevel) {
+  return levels.indexOf(logLevel) >= levels.indexOf(currentLogLevel);
+}
+var levelColors = {
+  info: TTY_COLORS.fg.blue,
+  success: TTY_COLORS.fg.green,
+  warn: TTY_COLORS.fg.yellow,
+  error: TTY_COLORS.fg.red,
+  debug: TTY_COLORS.fg.magenta
+};
+var formatMessage = (level, message, colorsEnabled) => {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  if (colorsEnabled) return `${TTY_COLORS.dim}${timestamp}${TTY_COLORS.reset} ${levelColors[level]}${level.toUpperCase()}${TTY_COLORS.reset} ${TTY_COLORS.bright}[Better Auth]:${TTY_COLORS.reset} ${message}`;
+  return `${timestamp} ${level.toUpperCase()} [Better Auth]: ${message}`;
+};
+var createLogger = (options) => {
+  const enabled = options?.disabled !== true;
+  const logLevel = options?.level ?? "error";
+  const colorsEnabled = options?.disableColors !== void 0 ? !options.disableColors : getColorDepth() !== 1;
+  const LogFunc = (level, message, args = []) => {
+    if (!enabled || !shouldPublishLog(logLevel, level)) return;
+    const formattedMessage = formatMessage(level, message, colorsEnabled);
+    if (!options || typeof options.log !== "function") {
+      if (level === "error") console.error(formattedMessage, ...args);
+      else if (level === "warn") console.warn(formattedMessage, ...args);
+      else console.log(formattedMessage, ...args);
+      return;
+    }
+    options.log(level === "success" ? "info" : level, message, ...args);
+  };
+  return {
+    ...Object.fromEntries(levels.map((level) => [level, (...[message, ...args]) => LogFunc(level, message, args)])),
+    get level() {
+      return logLevel;
+    }
+  };
+};
+var logger = createLogger();
+
+// ../../../node_modules/.pnpm/@better-auth+core@1.4.10_@better-auth+utils@0.3.0_@better-fetch+fetch@1.1.21_better-call@1.1._s4ptmt7cznbdkhj2rfry3i4hxy/node_modules/@better-auth/core/dist/utils-NloIXYE0.mjs
+function defineErrorCodes(codes) {
+  return codes;
+}
+function capitalizeFirstLetter(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// ../../../node_modules/.pnpm/@better-auth+core@1.4.10_@better-auth+utils@0.3.0_@better-fetch+fetch@1.1.21_better-call@1.1._s4ptmt7cznbdkhj2rfry3i4hxy/node_modules/@better-auth/core/dist/error-RtKwr3Pu.mjs
+var BASE_ERROR_CODES = defineErrorCodes({
+  USER_NOT_FOUND: "User not found",
+  FAILED_TO_CREATE_USER: "Failed to create user",
+  FAILED_TO_CREATE_SESSION: "Failed to create session",
+  FAILED_TO_UPDATE_USER: "Failed to update user",
+  FAILED_TO_GET_SESSION: "Failed to get session",
+  INVALID_PASSWORD: "Invalid password",
+  INVALID_EMAIL: "Invalid email",
+  INVALID_EMAIL_OR_PASSWORD: "Invalid email or password",
+  SOCIAL_ACCOUNT_ALREADY_LINKED: "Social account already linked",
+  PROVIDER_NOT_FOUND: "Provider not found",
+  INVALID_TOKEN: "Invalid token",
+  ID_TOKEN_NOT_SUPPORTED: "id_token not supported",
+  FAILED_TO_GET_USER_INFO: "Failed to get user info",
+  USER_EMAIL_NOT_FOUND: "User email not found",
+  EMAIL_NOT_VERIFIED: "Email not verified",
+  PASSWORD_TOO_SHORT: "Password too short",
+  PASSWORD_TOO_LONG: "Password too long",
+  USER_ALREADY_EXISTS: "User already exists.",
+  USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: "User already exists. Use another email.",
+  EMAIL_CAN_NOT_BE_UPDATED: "Email can not be updated",
+  CREDENTIAL_ACCOUNT_NOT_FOUND: "Credential account not found",
+  SESSION_EXPIRED: "Session expired. Re-authenticate to perform this action.",
+  FAILED_TO_UNLINK_LAST_ACCOUNT: "You can't unlink your last account",
+  ACCOUNT_NOT_FOUND: "Account not found",
+  USER_ALREADY_HAS_PASSWORD: "User already has a password. Provide that to delete the account.",
+  CROSS_SITE_NAVIGATION_LOGIN_BLOCKED: "Cross-site navigation login blocked. This request appears to be a CSRF attack.",
+  VERIFICATION_EMAIL_NOT_ENABLED: "Verification email isn't enabled",
+  EMAIL_ALREADY_VERIFIED: "Email is already verified",
+  EMAIL_MISMATCH: "Email mismatch",
+  SESSION_NOT_FRESH: "Session is not fresh",
+  LINKED_ACCOUNT_ALREADY_EXISTS: "Linked account already exists",
+  INVALID_ORIGIN: "Invalid origin",
+  INVALID_CALLBACK_URL: "Invalid callbackURL",
+  INVALID_REDIRECT_URL: "Invalid redirectURL",
+  INVALID_ERROR_CALLBACK_URL: "Invalid errorCallbackURL",
+  INVALID_NEW_USER_CALLBACK_URL: "Invalid newUserCallbackURL",
+  MISSING_OR_NULL_ORIGIN: "Missing or null Origin",
+  CALLBACK_URL_REQUIRED: "callbackURL is required",
+  FAILED_TO_CREATE_VERIFICATION: "Unable to create verification",
+  FIELD_NOT_ALLOWED: "Field not allowed to be set",
+  ASYNC_VALIDATION_NOT_SUPPORTED: "Async validation is not supported",
+  VALIDATION_ERROR: "Validation Error",
+  MISSING_FIELD: "Field is required"
+});
+var BetterAuthError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "BetterAuthError";
+    this.message = message;
+    this.cause = cause;
+    this.stack = "";
+  }
+};
+
+// ../../../node_modules/.pnpm/better-auth@1.4.10_drizzle-kit@0.31.8_drizzle-orm@0.45.1_@cloudflare+workers-types@4.20251119_hirg525kbrpwuqvxcih3czaike/node_modules/better-auth/dist/utils/url.mjs
+function checkHasPath(url) {
+  try {
+    return (new URL(url).pathname.replace(/\/+$/, "") || "/") !== "/";
+  } catch {
+    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 validateProxyHeader(header, type) {
+  if (!header || header.trim() === "") return false;
+  if (type === "proto") return header === "http" || header === "https";
+  if (type === "host") {
+    if ([
+      /\.\./,
+      /\0/,
+      /[\s]/,
+      /^[.]/,
+      /[<>'"]/,
+      /javascript:/i,
+      /file:/i,
+      /data:/i
+    ].some((pattern) => pattern.test(header))) return false;
+    return /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*(:[0-9]{1,5})?$/.test(header) || /^(\d{1,3}\.){3}\d{1,3}(:[0-9]{1,5})?$/.test(header) || /^\[[0-9a-fA-F:]+\](:[0-9]{1,5})?$/.test(header) || /^localhost(:[0-9]{1,5})?$/i.test(header);
+  }
+  return false;
+}
+function getBaseURL(url, path, request, loadEnv, trustedProxyHeaders) {
+  if (url) return withPath(url, path);
+  if (loadEnv !== false) {
+    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);
+  }
+  const fromRequest = request?.headers.get("x-forwarded-host");
+  const fromRequestProto = request?.headers.get("x-forwarded-proto");
+  if (fromRequest && fromRequestProto && trustedProxyHeaders) {
+    if (validateProxyHeader(fromRequestProto, "proto") && validateProxyHeader(fromRequest, "host")) try {
+      return withPath(`${fromRequestProto}://${fromRequest}`, path);
+    } catch (_error) {
+    }
+  }
+  if (request) {
+    const url$1 = getOrigin(request.url);
+    if (!url$1) throw new BetterAuthError("Could not get origin from request. Please provide a valid base URL.");
+    return withPath(url$1, path);
+  }
+  if (typeof window !== "undefined" && window.location) return withPath(window.location.origin, path);
+}
+function getOrigin(url) {
+  try {
+    const parsedUrl = new URL(url);
+    return parsedUrl.origin === "null" ? null : parsedUrl.origin;
+  } catch {
+    return null;
+  }
+}
+
+// ../../../node_modules/.pnpm/better-auth@1.4.10_drizzle-kit@0.31.8_drizzle-orm@0.45.1_@cloudflare+workers-types@4.20251119_hirg525kbrpwuqvxcih3czaike/node_modules/better-auth/dist/client/fetch-plugins.mjs
+var 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 {
+        }
+      }
+    }
+  } }
+};
+
+// ../../../node_modules/.pnpm/better-auth@1.4.10_drizzle-kit@0.31.8_drizzle-orm@0.45.1_@cloudflare+workers-types@4.20251119_hirg525kbrpwuqvxcih3czaike/node_modules/better-auth/dist/client/parser.mjs
+var 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*:/
+};
+var JSON_SIGNATURE = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
+var SPECIAL_VALUES = {
+  true: true,
+  false: false,
+  null: null,
+  undefined: void 0,
+  nan: NaN,
+  infinity: Number.POSITIVE_INFINITY,
+  "-infinity": Number.NEGATIVE_INFINITY
+};
+var 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);
+}
+
+// ../../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/clean-stores/index.js
+var clean = Symbol("clean");
+
+// ../../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/atom/index.js
+var listenerQueue = [];
+var lqIndex = 0;
+var QUEUE_ITEMS_PER_LISTENER = 4;
+var epoch = 0;
+var 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) {
+      epoch++;
+      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;
+};
+
+// ../../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/lifecycle/index.js
+var MOUNT = 5;
+var UNMOUNT = 6;
+var REVERT_MUTATION = 10;
+var 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];
+    }
+  };
+};
+var STORE_UNMOUNT_DELAY = 1e3;
+var 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;
+    };
+  });
+};
+
+// ../../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/listen-keys/index.js
+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);
+    }
+  });
+}
+
+// ../../../node_modules/.pnpm/better-auth@1.4.10_drizzle-kit@0.31.8_drizzle-orm@0.45.1_@cloudflare+workers-types@4.20251119_hirg525kbrpwuqvxcih3czaike/node_modules/better-auth/dist/client/query.mjs
+var isServer = () => typeof window === "undefined";
+var useAuthQuery = (initializedAtom, path, $fetch, options) => {
+  const value = 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;
+};
+
+// ../../../node_modules/.pnpm/better-auth@1.4.10_drizzle-kit@0.31.8_drizzle-orm@0.45.1_@cloudflare+workers-types@4.20251119_hirg525kbrpwuqvxcih3czaike/node_modules/better-auth/dist/client/broadcast-channel.mjs
+var kBroadcastChannel = Symbol.for("better-auth:broadcast-channel");
+var now = () => Math.floor(Date.now() / 1e3);
+var WindowBroadcastChannel = class {
+  constructor(name = "better-auth.message") {
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "name");
+    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()
+      }));
+    } 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];
+}
+
+// ../../../node_modules/.pnpm/better-auth@1.4.10_drizzle-kit@0.31.8_drizzle-orm@0.45.1_@cloudflare+workers-types@4.20251119_hirg525kbrpwuqvxcih3czaike/node_modules/better-auth/dist/client/focus-manager.mjs
+var kFocusManager = Symbol.for("better-auth:focus-manager");
+var WindowFocusManager = class {
+  constructor() {
+    __publicField(this, "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 visibilityHandler = () => {
+      if (document.visibilityState === "visible") this.setFocused(true);
+    };
+    document.addEventListener("visibilitychange", visibilityHandler, false);
+    return () => {
+      document.removeEventListener("visibilitychange", visibilityHandler, false);
+    };
+  }
+};
+function getGlobalFocusManager() {
+  if (!globalThis[kFocusManager]) globalThis[kFocusManager] = new WindowFocusManager();
+  return globalThis[kFocusManager];
+}
+
+// ../../../node_modules/.pnpm/better-auth@1.4.10_drizzle-kit@0.31.8_drizzle-orm@0.45.1_@cloudflare+workers-types@4.20251119_hirg525kbrpwuqvxcih3czaike/node_modules/better-auth/dist/client/online-manager.mjs
+var kOnlineManager = Symbol.for("better-auth:online-manager");
+var WindowOnlineManager = class {
+  constructor() {
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "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];
+}
+
+// ../../../node_modules/.pnpm/better-auth@1.4.10_drizzle-kit@0.31.8_drizzle-orm@0.45.1_@cloudflare+workers-types@4.20251119_hirg525kbrpwuqvxcih3czaike/node_modules/better-auth/dist/client/session-refresh.mjs
+var now2 = () => Math.floor(Date.now() / 1e3);
+var 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 = now2();
+      sessionSignal.set(!sessionSignal.get());
+      return;
+    }
+    const currentSession = sessionAtom.get();
+    if (event?.event === "poll") {
+      state.lastSessionRequest = now2();
+      $fetch("/get-session").then((res) => {
+        if (res.error) sessionAtom.set({
+          ...currentSession,
+          data: null,
+          error: res.error
+        });
+        else sessionAtom.set({
+          ...currentSession,
+          data: res.data,
+          error: null
+        });
+        state.lastSync = now2();
+        sessionSignal.set(!sessionSignal.get());
+      }).catch(() => {
+      });
+      return;
+    }
+    if (event?.event === "visibilitychange") {
+      if (now2() - state.lastSessionRequest < FOCUS_REFETCH_RATE_LIMIT_SECONDS) return;
+      state.lastSessionRequest = now2();
+    }
+    if (currentSession?.data === null || currentSession?.data === void 0 || event?.event === "visibilitychange") {
+      state.lastSync = now2();
+      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
+  };
+}
+
+// ../../../node_modules/.pnpm/better-auth@1.4.10_drizzle-kit@0.31.8_drizzle-orm@0.45.1_@cloudflare+workers-types@4.20251119_hirg525kbrpwuqvxcih3czaike/node_modules/better-auth/dist/client/session-atom.mjs
+function getSessionAtom($fetch, options) {
+  const $signal = 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
+  };
+}
+
+// ../../../node_modules/.pnpm/better-auth@1.4.10_drizzle-kit@0.31.8_drizzle-orm@0.45.1_@cloudflare+workers-types@4.20251119_hirg525kbrpwuqvxcih3czaike/node_modules/better-auth/dist/client/config.mjs
+import { createFetch } from "@better-fetch/fetch";
+var getClientConfig = (options, loadEnv) => {
+  const isCredentialsSupported = "credentials" in Request.prototype;
+  const baseURL = getBaseURL(options?.baseURL, options?.basePath, void 0, loadEnv) ?? "/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: _onSuccess, onError: _onError, onRequest: _onRequest, onResponse: _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 ? [] : [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
+  };
+};
+
+// ../../../node_modules/.pnpm/better-auth@1.4.10_drizzle-kit@0.31.8_drizzle-orm@0.45.1_@cloudflare+workers-types@4.20251119_hirg525kbrpwuqvxcih3czaike/node_modules/better-auth/dist/utils/is-atom.mjs
+function isAtom(value) {
+  return typeof value === "object" && value !== null && "get" in value && typeof value.get === "function" && "lc" in value && typeof value.lc === "number";
+}
+
+// ../../../node_modules/.pnpm/better-auth@1.4.10_drizzle-kit@0.31.8_drizzle-orm@0.45.1_@cloudflare+workers-types@4.20251119_hirg525kbrpwuqvxcih3czaike/node_modules/better-auth/dist/client/proxy.mjs
+function getMethod(path, knownPathMethods, args) {
+  const method = knownPathMethods[path];
+  const { fetchOptions, query: _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;
+            const visited = /* @__PURE__ */ new Set();
+            for (const match of matches) {
+              const signal = atoms[match.signal];
+              if (!signal) return;
+              if (visited.has(match.signal)) continue;
+              visited.add(match.signal);
+              const val = signal.get();
+              setTimeout(() => {
+                signal.set(!val);
+              }, 10);
+            }
+          }
+        });
+      }
+    });
+  }
+  return createProxy();
+}
+
+// ../../../node_modules/.pnpm/better-auth@1.4.10_drizzle-kit@0.31.8_drizzle-orm@0.45.1_@cloudflare+workers-types@4.20251119_hirg525kbrpwuqvxcih3czaike/node_modules/better-auth/dist/client/react/react-store.mjs
+import { useCallback, useRef, useSyncExternalStore } from "react";
+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);
+}
+
+// ../../../node_modules/.pnpm/better-auth@1.4.10_drizzle-kit@0.31.8_drizzle-orm@0.45.1_@cloudflare+workers-types@4.20251119_hirg525kbrpwuqvxcih3czaike/node_modules/better-auth/dist/client/react/index.mjs
+function getAtomKey(str) {
+  return `use${capitalizeFirstLetter(str)}`;
+}
+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);
+}
+
+export {
+  BetterAuthError,
+  atom,
+  useAuthQuery,
+  createAuthClient
+};
+//# sourceMappingURL=chunk-Y3WVYSUI.mjs.map