@intlayer/design-system 5.7.2 → 5.7.4

package/dist/hooks/auth.cjs

@@ -0,0 +1,1783 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const configuration = require("@intlayer/config/built");
+const betterAuth_8zoxzgF = require("../better-auth.8zoxzg-F-BEBqzpjz.cjs");
+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
+    })
+  };
+};
+class BetterAuthError extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "BetterAuthError";
+    this.message = message;
+    this.cause = cause;
+    this.stack = "";
+  }
+}
+function checkHasPath(url) {
+  try {
+    const parsedUrl = new URL(url);
+    return parsedUrl.pathname !== "/";
+  } catch (error) {
+    throw new BetterAuthError(
+      `Invalid base URL: ${url}. Please provide a valid base URL.`
+    );
+  }
+}
+function withPath(url, path = "/api/auth") {
+  const hasPath = checkHasPath(url);
+  if (hasPath) {
+    return url;
+  }
+  path = path.startsWith("/") ? path : `/${path}`;
+  return `${url.replace(/\/+$/, "")}${path}`;
+}
+function getBaseURL(url, path, request) {
+  if (url) {
+    return withPath(url, path);
+  }
+  const fromEnv = betterAuth_8zoxzgF.env.BETTER_AUTH_URL || betterAuth_8zoxzgF.env.NEXT_PUBLIC_BETTER_AUTH_URL || betterAuth_8zoxzgF.env.PUBLIC_BETTER_AUTH_URL || betterAuth_8zoxzgF.env.NUXT_PUBLIC_BETTER_AUTH_URL || betterAuth_8zoxzgF.env.NUXT_PUBLIC_AUTH_URL || (betterAuth_8zoxzgF.env.BASE_URL !== "/" ? betterAuth_8zoxzgF.env.BASE_URL : void 0);
+  if (fromEnv) {
+    return withPath(fromEnv, path);
+  }
+  if (typeof window !== "undefined" && window.location) {
+    return withPath(window.location.origin, path);
+  }
+  return void 0;
+}
+var dist = {};
+var lifecycle = {};
+var cleanStores = {};
+var task = {};
+var hasRequiredTask;
+function requireTask() {
+  if (hasRequiredTask) return task;
+  hasRequiredTask = 1;
+  Object.defineProperty(task, "__esModule", { value: true });
+  task.cleanTasks = task.allTasks = task.task = task.startTask = void 0;
+  let tasks = 0;
+  let resolves = [];
+  function startTask() {
+    tasks += 1;
+    return () => {
+      tasks -= 1;
+      if (tasks === 0) {
+        let prevResolves = resolves;
+        resolves = [];
+        for (let i of prevResolves)
+          i();
+      }
+    };
+  }
+  task.startTask = startTask;
+  function task$1(cb) {
+    let endTask = startTask();
+    return cb().finally(endTask);
+  }
+  task.task = task$1;
+  function allTasks() {
+    if (tasks === 0) {
+      return Promise.resolve();
+    } else {
+      return new Promise((resolve) => {
+        resolves.push(resolve);
+      });
+    }
+  }
+  task.allTasks = allTasks;
+  function cleanTasks() {
+    tasks = 0;
+  }
+  task.cleanTasks = cleanTasks;
+  return task;
+}
+var hasRequiredCleanStores;
+function requireCleanStores() {
+  if (hasRequiredCleanStores) return cleanStores;
+  hasRequiredCleanStores = 1;
+  (function(exports2) {
+    var define_process_env_default = {};
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.cleanStores = exports2.clean = void 0;
+    const index_js_1 = /* @__PURE__ */ requireTask();
+    exports2.clean = Symbol("clean");
+    let cleanStores2 = (...stores) => {
+      if (define_process_env_default.NODE_ENV === "production") {
+        throw new Error("cleanStores() can be used only during development or tests");
+      }
+      (0, index_js_1.cleanTasks)();
+      for (let store of stores) {
+        if (store) {
+          if (store.mocked)
+            delete store.mocked;
+          if (store[exports2.clean])
+            store[exports2.clean]();
+        }
+      }
+    };
+    exports2.cleanStores = cleanStores2;
+  })(cleanStores);
+  return cleanStores;
+}
+var hasRequiredLifecycle;
+function requireLifecycle() {
+  if (hasRequiredLifecycle) return lifecycle;
+  hasRequiredLifecycle = 1;
+  (function(exports2) {
+    var define_process_env_default = {};
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.onMount = exports2.STORE_UNMOUNT_DELAY = exports2.onBuild = exports2.onNotify = exports2.onSet = exports2.onStop = exports2.onStart = void 0;
+    const index_js_1 = /* @__PURE__ */ requireCleanStores();
+    const START = 0;
+    const STOP = 1;
+    const SET = 2;
+    const NOTIFY = 3;
+    const BUILD = 4;
+    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 onStart = (store, listener) => on(store, listener, START, (runListeners) => {
+      let originListen = store.listen;
+      store.listen = (arg) => {
+        if (!store.lc && !store.starting) {
+          store.starting = true;
+          runListeners();
+          delete store.starting;
+        }
+        return originListen(arg);
+      };
+      return () => {
+        store.listen = originListen;
+      };
+    });
+    exports2.onStart = onStart;
+    let onStop = (store, listener) => on(store, listener, STOP, (runListeners) => {
+      let originOff = store.off;
+      store.off = () => {
+        runListeners();
+        originOff();
+      };
+      return () => {
+        store.off = originOff;
+      };
+    });
+    exports2.onStop = onStop;
+    let onSet = (store, listener) => on(store, listener, SET, (runListeners) => {
+      let originSet = store.set;
+      let originSetKey = store.setKey;
+      if (store.setKey) {
+        store.setKey = (changed, changedValue) => {
+          let isAborted;
+          let abort = () => {
+            isAborted = true;
+          };
+          runListeners({
+            abort,
+            changed,
+            newValue: { ...store.value, [changed]: changedValue }
+          });
+          if (!isAborted)
+            return originSetKey(changed, changedValue);
+        };
+      }
+      store.set = (newValue) => {
+        let isAborted;
+        let abort = () => {
+          isAborted = true;
+        };
+        runListeners({ abort, newValue });
+        if (!isAborted)
+          return originSet(newValue);
+      };
+      return () => {
+        store.set = originSet;
+        store.setKey = originSetKey;
+      };
+    });
+    exports2.onSet = onSet;
+    let onNotify = (store, listener) => on(store, listener, NOTIFY, (runListeners) => {
+      let originNotify = store.notify;
+      store.notify = (changed) => {
+        let isAborted;
+        let abort = () => {
+          isAborted = true;
+        };
+        runListeners({ abort, changed });
+        if (!isAborted)
+          return originNotify(changed);
+      };
+      return () => {
+        store.notify = originNotify;
+      };
+    });
+    exports2.onNotify = onNotify;
+    let onBuild = (Template, listener) => on(Template, listener, BUILD, (runListeners) => {
+      let originBuild = Template.build;
+      Template.build = (...args) => {
+        let store = originBuild(...args);
+        runListeners({ store });
+        return store;
+      };
+      return () => {
+        Template.build = originBuild;
+      };
+    });
+    exports2.onBuild = onBuild;
+    exports2.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 = (arg) => {
+          if (!store.lc && !store.active) {
+            store.active = true;
+            runListeners();
+          }
+          return originListen(arg);
+        };
+        let originOff = store.off;
+        store.events[UNMOUNT] = [];
+        store.off = () => {
+          setTimeout(() => {
+            if (store.active && !store.lc) {
+              store.active = false;
+              for (let destroy of store.events[UNMOUNT])
+                destroy();
+              store.events[UNMOUNT] = [];
+              originOff();
+            }
+          }, exports2.STORE_UNMOUNT_DELAY);
+        };
+        if (define_process_env_default.NODE_ENV !== "production") {
+          let originClean = store[index_js_1.clean];
+          store[index_js_1.clean] = () => {
+            for (let destroy of store.events[UNMOUNT])
+              destroy();
+            store.events[UNMOUNT] = [];
+            store.active = false;
+            originClean();
+          };
+        }
+        return () => {
+          store.listen = originListen;
+          store.off = originOff;
+        };
+      });
+    };
+    exports2.onMount = onMount;
+  })(lifecycle);
+  return lifecycle;
+}
+var action = {};
+var hasRequiredAction;
+function requireAction() {
+  if (hasRequiredAction) return action;
+  hasRequiredAction = 1;
+  (function(exports2) {
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.actionFor = exports2.action = exports2.lastAction = void 0;
+    const index_js_1 = /* @__PURE__ */ requireTask();
+    exports2.lastAction = Symbol();
+    let doAction = (store, actionName, cb, args) => {
+      let tracker = { ...store };
+      tracker.set = (...setArgs) => {
+        store[exports2.lastAction] = actionName;
+        store.set(...setArgs);
+        delete store[exports2.lastAction];
+      };
+      if (store.setKey) {
+        tracker.setKey = (...setArgs) => {
+          store[exports2.lastAction] = actionName;
+          store.setKey(...setArgs);
+          delete store[exports2.lastAction];
+        };
+      }
+      let result = cb(tracker, ...args);
+      if (result instanceof Promise) {
+        let endTask = (0, index_js_1.startTask)();
+        return result.finally(endTask);
+      }
+      return result;
+    };
+    let action2 = (store, actionName, cb) => (...args) => doAction(store, actionName, cb, args);
+    exports2.action = action2;
+    let actionFor = (Template, actionName, cb) => {
+      return (store, ...rest) => doAction(store, actionName, cb, rest);
+    };
+    exports2.actionFor = actionFor;
+  })(action);
+  return action;
+}
+var mapTemplate = {};
+var map = {};
+var atom = {};
+var hasRequiredAtom;
+function requireAtom() {
+  if (hasRequiredAtom) return atom;
+  hasRequiredAtom = 1;
+  (function(exports2) {
+    var define_process_env_default = {};
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.atom = exports2.notifyId = void 0;
+    const index_js_1 = /* @__PURE__ */ requireCleanStores();
+    let listenerQueue = [];
+    exports2.notifyId = 0;
+    let atom2 = (initialValue) => {
+      let currentListeners;
+      let nextListeners = [];
+      let store = {
+        lc: 0,
+        value: initialValue,
+        set(data) {
+          store.value = data;
+          store.notify();
+        },
+        get() {
+          if (!store.lc) {
+            store.listen(() => {
+            })();
+          }
+          return store.value;
+        },
+        notify(changedKey) {
+          currentListeners = nextListeners;
+          let runListenerQueue = !listenerQueue.length;
+          for (let i = 0; i < currentListeners.length; i++) {
+            listenerQueue.push(currentListeners[i], store.value, changedKey);
+          }
+          if (runListenerQueue) {
+            exports2.notifyId++;
+            for (let i = 0; i < listenerQueue.length; i += 3) {
+              listenerQueue[i](listenerQueue[i + 1], listenerQueue[i + 2]);
+            }
+            listenerQueue.length = 0;
+          }
+        },
+        listen(listener) {
+          if (nextListeners === currentListeners) {
+            nextListeners = nextListeners.slice();
+          }
+          store.lc = nextListeners.push(listener);
+          return () => {
+            if (nextListeners === currentListeners) {
+              nextListeners = nextListeners.slice();
+            }
+            let index = nextListeners.indexOf(listener);
+            if (~index) {
+              nextListeners.splice(index, 1);
+              store.lc--;
+              if (!store.lc)
+                store.off();
+            }
+          };
+        },
+        subscribe(cb) {
+          let unbind = store.listen(cb);
+          cb(store.value);
+          return unbind;
+        },
+        off() {
+        }
+        /* It will be called on last listener unsubscribing.
+          We will redefine it in onMount and onStop. */
+      };
+      if (define_process_env_default.NODE_ENV !== "production") {
+        store[index_js_1.clean] = () => {
+          nextListeners = [];
+          store.lc = 0;
+          store.off();
+        };
+      }
+      return store;
+    };
+    exports2.atom = atom2;
+  })(atom);
+  return atom;
+}
+var hasRequiredMap;
+function requireMap() {
+  if (hasRequiredMap) return map;
+  hasRequiredMap = 1;
+  Object.defineProperty(map, "__esModule", { value: true });
+  map.map = void 0;
+  const index_js_1 = /* @__PURE__ */ requireAtom();
+  let map$1 = (value = {}) => {
+    let store = (0, index_js_1.atom)(value);
+    store.setKey = function(key, newValue) {
+      if (typeof newValue === "undefined") {
+        if (key in store.value) {
+          store.value = { ...store.value };
+          delete store.value[key];
+          store.notify(key);
+        }
+      } else if (store.value[key] !== newValue) {
+        store.value = {
+          ...store.value,
+          [key]: newValue
+        };
+        store.notify(key);
+      }
+    };
+    return store;
+  };
+  map.map = map$1;
+  return map;
+}
+var hasRequiredMapTemplate;
+function requireMapTemplate() {
+  if (hasRequiredMapTemplate) return mapTemplate;
+  hasRequiredMapTemplate = 1;
+  var define_process_env_default = {};
+  Object.defineProperty(mapTemplate, "__esModule", { value: true });
+  mapTemplate.mapTemplate = void 0;
+  const index_js_1 = /* @__PURE__ */ requireLifecycle();
+  const index_js_2 = /* @__PURE__ */ requireCleanStores();
+  const index_js_3 = /* @__PURE__ */ requireMap();
+  function mapTemplate$1(init) {
+    let Template = (id, ...args) => {
+      if (!Template.cache[id]) {
+        Template.cache[id] = Template.build(id, ...args);
+      }
+      return Template.cache[id];
+    };
+    Template.build = (id, ...args) => {
+      let store = (0, index_js_3.map)({ id });
+      (0, index_js_1.onMount)(store, () => {
+        let destroy;
+        if (init)
+          destroy = init(store, id, ...args);
+        return () => {
+          delete Template.cache[id];
+          if (destroy)
+            destroy();
+        };
+      });
+      return store;
+    };
+    Template.cache = {};
+    if (define_process_env_default.NODE_ENV !== "production") {
+      Template[index_js_2.clean] = () => {
+        for (let id in Template.cache) {
+          Template.cache[id][index_js_2.clean]();
+        }
+        Template.cache = {};
+      };
+    }
+    return Template;
+  }
+  mapTemplate.mapTemplate = mapTemplate$1;
+  return mapTemplate;
+}
+var listenKeys = {};
+var hasRequiredListenKeys;
+function requireListenKeys() {
+  if (hasRequiredListenKeys) return listenKeys;
+  hasRequiredListenKeys = 1;
+  Object.defineProperty(listenKeys, "__esModule", { value: true });
+  listenKeys.listenKeys = void 0;
+  function listenKeys$1(store, keys, listener) {
+    let keysSet = /* @__PURE__ */ new Set([...keys, void 0]);
+    return store.listen((value, changed) => {
+      if (keysSet.has(changed)) {
+        listener(value, changed);
+      }
+    });
+  }
+  listenKeys.listenKeys = listenKeys$1;
+  return listenKeys;
+}
+var keepMount = {};
+var hasRequiredKeepMount;
+function requireKeepMount() {
+  if (hasRequiredKeepMount) return keepMount;
+  hasRequiredKeepMount = 1;
+  Object.defineProperty(keepMount, "__esModule", { value: true });
+  keepMount.keepMount = void 0;
+  let keepMount$1 = (store) => {
+    store.listen(() => {
+    });
+  };
+  keepMount.keepMount = keepMount$1;
+  return keepMount;
+}
+var computed = {};
+var hasRequiredComputed;
+function requireComputed() {
+  if (hasRequiredComputed) return computed;
+  hasRequiredComputed = 1;
+  Object.defineProperty(computed, "__esModule", { value: true });
+  computed.computed = void 0;
+  const index_js_1 = /* @__PURE__ */ requireLifecycle();
+  const index_js_2 = /* @__PURE__ */ requireAtom();
+  let computed$1 = (stores, cb) => {
+    if (!Array.isArray(stores))
+      stores = [stores];
+    let diamondNotifyId;
+    let diamondArgs = [];
+    let run = () => {
+      let args = stores.map((store) => store.get());
+      if (diamondNotifyId !== index_js_2.notifyId || args.some((arg, i) => arg !== diamondArgs[i])) {
+        diamondNotifyId = index_js_2.notifyId;
+        diamondArgs = args;
+        derived.set(cb(...args));
+      }
+    };
+    let derived = (0, index_js_2.atom)();
+    (0, index_js_1.onMount)(derived, () => {
+      let unbinds = stores.map((store) => store.listen(run, cb));
+      run();
+      return () => {
+        for (let unbind of unbinds)
+          unbind();
+      };
+    });
+    return derived;
+  };
+  computed.computed = computed$1;
+  return computed;
+}
+var hasRequiredDist;
+function requireDist() {
+  if (hasRequiredDist) return dist;
+  hasRequiredDist = 1;
+  (function(exports2) {
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.map = exports2.atom = exports2.computed = exports2.keepMount = exports2.listenKeys = exports2.mapTemplate = exports2.cleanStores = exports2.clean = exports2.lastAction = exports2.actionFor = exports2.action = exports2.task = exports2.allTasks = exports2.startTask = exports2.cleanTasks = exports2.onSet = exports2.onStop = exports2.onBuild = exports2.onMount = exports2.onStart = exports2.onNotify = exports2.STORE_UNMOUNT_DELAY = void 0;
+    var index_js_1 = /* @__PURE__ */ requireLifecycle();
+    Object.defineProperty(exports2, "STORE_UNMOUNT_DELAY", { enumerable: true, get: function() {
+      return index_js_1.STORE_UNMOUNT_DELAY;
+    } });
+    Object.defineProperty(exports2, "onNotify", { enumerable: true, get: function() {
+      return index_js_1.onNotify;
+    } });
+    Object.defineProperty(exports2, "onStart", { enumerable: true, get: function() {
+      return index_js_1.onStart;
+    } });
+    Object.defineProperty(exports2, "onMount", { enumerable: true, get: function() {
+      return index_js_1.onMount;
+    } });
+    Object.defineProperty(exports2, "onBuild", { enumerable: true, get: function() {
+      return index_js_1.onBuild;
+    } });
+    Object.defineProperty(exports2, "onStop", { enumerable: true, get: function() {
+      return index_js_1.onStop;
+    } });
+    Object.defineProperty(exports2, "onSet", { enumerable: true, get: function() {
+      return index_js_1.onSet;
+    } });
+    var index_js_2 = /* @__PURE__ */ requireTask();
+    Object.defineProperty(exports2, "cleanTasks", { enumerable: true, get: function() {
+      return index_js_2.cleanTasks;
+    } });
+    Object.defineProperty(exports2, "startTask", { enumerable: true, get: function() {
+      return index_js_2.startTask;
+    } });
+    Object.defineProperty(exports2, "allTasks", { enumerable: true, get: function() {
+      return index_js_2.allTasks;
+    } });
+    Object.defineProperty(exports2, "task", { enumerable: true, get: function() {
+      return index_js_2.task;
+    } });
+    var index_js_3 = /* @__PURE__ */ requireAction();
+    Object.defineProperty(exports2, "action", { enumerable: true, get: function() {
+      return index_js_3.action;
+    } });
+    Object.defineProperty(exports2, "actionFor", { enumerable: true, get: function() {
+      return index_js_3.actionFor;
+    } });
+    Object.defineProperty(exports2, "lastAction", { enumerable: true, get: function() {
+      return index_js_3.lastAction;
+    } });
+    var index_js_4 = /* @__PURE__ */ requireCleanStores();
+    Object.defineProperty(exports2, "clean", { enumerable: true, get: function() {
+      return index_js_4.clean;
+    } });
+    Object.defineProperty(exports2, "cleanStores", { enumerable: true, get: function() {
+      return index_js_4.cleanStores;
+    } });
+    var index_js_5 = /* @__PURE__ */ requireMapTemplate();
+    Object.defineProperty(exports2, "mapTemplate", { enumerable: true, get: function() {
+      return index_js_5.mapTemplate;
+    } });
+    var index_js_6 = /* @__PURE__ */ requireListenKeys();
+    Object.defineProperty(exports2, "listenKeys", { enumerable: true, get: function() {
+      return index_js_6.listenKeys;
+    } });
+    var index_js_7 = /* @__PURE__ */ requireKeepMount();
+    Object.defineProperty(exports2, "keepMount", { enumerable: true, get: function() {
+      return index_js_7.keepMount;
+    } });
+    var index_js_8 = /* @__PURE__ */ requireComputed();
+    Object.defineProperty(exports2, "computed", { enumerable: true, get: function() {
+      return index_js_8.computed;
+    } });
+    var index_js_9 = /* @__PURE__ */ requireAtom();
+    Object.defineProperty(exports2, "atom", { enumerable: true, get: function() {
+      return index_js_9.atom;
+    } });
+    var index_js_10 = /* @__PURE__ */ requireMap();
+    Object.defineProperty(exports2, "map", { enumerable: true, get: function() {
+      return index_js_10.map;
+    } });
+  })(dist);
+  return dist;
+}
+var distExports = /* @__PURE__ */ requireDist();
+const isServer = typeof window === "undefined";
+const useAuthQuery = (initializedAtom, path, $fetch, options) => {
+  const value = distExports.atom({
+    data: null,
+    error: null,
+    isPending: true,
+    isRefetching: false,
+    refetch: () => {
+      return fn();
+    }
+  });
+  const fn = () => {
+    const opts = typeof options === "function" ? options({
+      data: value.get().data,
+      error: value.get().error,
+      isPending: value.get().isPending
+    }) : options;
+    return $fetch(path, {
+      ...opts,
+      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);
+      }
+    });
+  };
+  initializedAtom = Array.isArray(initializedAtom) ? initializedAtom : [initializedAtom];
+  let isMounted = false;
+  for (const initAtom of initializedAtom) {
+    initAtom.subscribe(() => {
+      if (isServer) {
+        return;
+      }
+      if (isMounted) {
+        fn();
+      } else {
+        distExports.onMount(value, () => {
+          setTimeout(() => {
+            fn();
+          }, 0);
+          isMounted = true;
+          return () => {
+            value.off();
+            initAtom.off();
+          };
+        });
+      }
+    });
+  }
+  return value;
+};
+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: Number.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[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;
+  }
+  const hasProtoPattern = 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;
+    }
+  );
+  if (hasProtoPattern && strict) {
+    throw new Error(
+      "[better-json] Potential prototype pollution attempt detected"
+    );
+  }
+  try {
+    const secureReviver = (key, value2) => {
+      if (key === "__proto__" || key === "constructor" && value2 && typeof value2 === "object" && "prototype" in value2) {
+        if (warnings) {
+          console.warn(
+            `[better-json] Dropping "${key}" key to prevent prototype pollution`
+          );
+        }
+        return void 0;
+      }
+      if (parseDates && typeof value2 === "string") {
+        const date = parseISODate(value2);
+        if (date) {
+          return date;
+        }
+      }
+      return reviver ? reviver(key, value2) : value2;
+    };
+    return JSON.parse(trimmed, secureReviver);
+  } catch (error) {
+    if (strict) {
+      throw error;
+    }
+    return value;
+  }
+}
+function parseJSON(value, options = { strict: true }) {
+  return betterJSONParse(value, options);
+}
+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 {
+            }
+          }
+        }
+      }
+    }
+  }
+};
+function getSessionAtom($fetch) {
+  const $signal = distExports.atom(false);
+  const session = useAuthQuery($signal, "/get-session", $fetch, {
+    method: "GET"
+  });
+  return {
+    session,
+    $sessionSignal: $signal
+  };
+}
+const getClientConfig = (options) => {
+  const isCredentialsSupported = "credentials" in Request.prototype;
+  const baseURL = getBaseURL(options?.baseURL, options?.basePath);
+  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: async (input, init) => {
+      try {
+        return await fetch(input, init);
+      } catch (error) {
+        return Response.error();
+      }
+    },
+    ...restOfFetchOptions,
+    plugins: [
+      lifeCyclePlugin,
+      ...restOfFetchOptions.plugins || [],
+      ...options?.disableDefaultFetchPlugins ? [] : [redirectPlugin],
+      ...pluginsFetchPlugins
+    ]
+  });
+  const { $sessionSignal, session } = getSessionAtom($fetch);
+  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.startsWith("/sign-in") || path.startsWith("/sign-up") || path === "/delete-user" || path === "/verify-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 {
+    pluginsActions,
+    pluginsAtoms,
+    pluginPathMethods,
+    atomListeners,
+    $fetch,
+    $store
+  };
+};
+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(target, prop) {
+        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;
+        }
+        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);
+            const matches = atomListeners?.find((s) => s.matcher(routePath));
+            if (!matches) return;
+            const signal = atoms[matches.signal];
+            if (!signal) return;
+            const val = signal.get();
+            setTimeout(() => {
+              signal.set(!val);
+            }, 10);
+          }
+        });
+      }
+    });
+  }
+  return createProxy();
+}
+function capitalizeFirstLetter(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function createAuthClient(options) {
+  const {
+    pluginPathMethods,
+    pluginsActions,
+    pluginsAtoms,
+    $fetch,
+    atomListeners,
+    $store
+  } = getClientConfig(options);
+  let resolvedHooks = {};
+  for (const [key, value] of Object.entries(pluginsAtoms)) {
+    resolvedHooks[`use${capitalizeFirstLetter(key)}`] = value;
+  }
+  const routes = {
+    ...pluginsActions,
+    ...resolvedHooks,
+    $fetch,
+    $store
+  };
+  const proxy = createDynamicPathProxy(
+    routes,
+    $fetch,
+    pluginPathMethods,
+    pluginsAtoms,
+    atomListeners
+  );
+  return proxy;
+}
+const getAuthAPI = (intlayerConfig) => {
+  const backendURL = intlayerConfig?.editor?.backendURL ?? configuration.editor?.backendURL;
+  if (!backendURL) {
+    throw new Error(
+      "Backend URL is not defined in the Intlayer configuration."
+    );
+  }
+  const getAuthClient = () => {
+    return createAuthClient({
+      baseURL: backendURL,
+      withCredentials: true
+      // makes fetch forward cookies
+    });
+  };
+  const signInEmail = async (...args) => {
+    const client = getAuthClient();
+    return client.signIn.email(...args);
+  };
+  const signInSocial = async (...args) => {
+    const client = getAuthClient();
+    return client.signIn.social(...args);
+  };
+  const signUpEmail = async (...args) => {
+    const client = getAuthClient();
+    return client.signUp.email(...args);
+  };
+  const signOut = async (...args) => {
+    const client = getAuthClient();
+    return client.signOut(...args);
+  };
+  const changePasswordSession = async (...args) => {
+    const client = getAuthClient();
+    return client.changePassword(...args);
+  };
+  const requestPasswordResetSession = async (...args) => {
+    const client = getAuthClient();
+    return client.requestPasswordReset(...args);
+  };
+  const resetPassword = async (...args) => {
+    const client = getAuthClient();
+    return client.resetPassword(...args);
+  };
+  const verifyEmailSession = async (...args) => {
+    const client = getAuthClient();
+    return client.verifyEmail(...args);
+  };
+  const getSession = async (...args) => {
+    const client = getAuthClient();
+    return client.getSession(...args);
+  };
+  const forgetPassword = async (...args) => {
+    const client = getAuthClient();
+    return client.forgetPassword(...args);
+  };
+  const sendVerificationEmail = async (...args) => {
+    const client = getAuthClient();
+    return client.sendVerificationEmail(...args);
+  };
+  const changeEmail = async (...args) => {
+    const client = getAuthClient();
+    return client.changeEmail(...args);
+  };
+  const deleteUser = async (...args) => {
+    const client = getAuthClient();
+    return client.deleteUser(...args);
+  };
+  const revokeSession = async (...args) => {
+    const client = getAuthClient();
+    return client.revokeSession(...args);
+  };
+  const revokeSessions = async (...args) => {
+    const client = getAuthClient();
+    return client.revokeSessions(...args);
+  };
+  const revokeOtherSessions = async (...args) => {
+    const client = getAuthClient();
+    return client.revokeOtherSessions(...args);
+  };
+  const linkSocial = async (...args) => {
+    const client = getAuthClient();
+    return client.linkSocial(...args);
+  };
+  const listAccounts = async (...args) => {
+    const client = getAuthClient();
+    return client.listAccounts(...args);
+  };
+  const unlinkAccount = async (...args) => {
+    const client = getAuthClient();
+    return client.unlinkAccount(...args);
+  };
+  const refreshToken = async (...args) => {
+    const client = getAuthClient();
+    return client.refreshToken(...args);
+  };
+  const getAccessToken = async (...args) => {
+    const client = getAuthClient();
+    return client.getAccessToken(...args);
+  };
+  const accountInfo = async (...args) => {
+    const client = getAuthClient();
+    return client.accountInfo(...args);
+  };
+  const updateUser = async (...args) => {
+    const client = getAuthClient();
+    return client.updateUser(...args);
+  };
+  const listSessions = async (...args) => {
+    const client = getAuthClient();
+    return client.listSessions(...args);
+  };
+  return {
+    signInEmail,
+    signUpEmail,
+    signOut,
+    signInSocial,
+    linkSocial,
+    changePasswordSession,
+    requestPasswordResetSession,
+    resetPassword,
+    verifyEmailSession,
+    getSession,
+    forgetPassword,
+    sendVerificationEmail,
+    changeEmail,
+    deleteUser,
+    revokeSession,
+    revokeSessions,
+    revokeOtherSessions,
+    listAccounts,
+    unlinkAccount,
+    refreshToken,
+    getAccessToken,
+    accountInfo,
+    updateUser,
+    listSessions
+  };
+};
+exports.getAuthAPI = getAuthAPI;
+//# sourceMappingURL=auth.cjs.map