@onmax/nuxt-better-auth 0.0.2-alpha.30 → 0.0.2-alpha.32

package/dist/runtime/app/internal/session-fetch.js

@@ -0,0 +1,56 @@
+import { useRequestFetch, useRequestHeaders } from "#imports";
+import { normalizeAuthActionError } from "./auth-action-error.js";
+export function stripToken(session) {
+  const { token: _, ...safe } = session;
+  return safe;
+}
+function isExpectedSignedOutSessionError(error) {
+  const normalizedError = normalizeAuthActionError(error);
+  if (normalizedError.status === 401)
+    return true;
+  return normalizedError.code === "UNAUTHORIZED";
+}
+export async function fetchSessionServer(session, user, authReady, options = {}) {
+  try {
+    const headers = options.headers || useRequestHeaders(["cookie"]);
+    const requestFetch = useRequestFetch();
+    const data = await requestFetch("/api/auth/get-session", { headers });
+    if (data?.session && data?.user) {
+      session.value = stripToken(data.session);
+      user.value = data.user;
+    } else {
+      session.value = null;
+      user.value = null;
+    }
+  } catch {
+    session.value = null;
+    user.value = null;
+  } finally {
+    if (!authReady.value)
+      authReady.value = true;
+  }
+}
+export async function fetchSessionClient(client, session, user, authReady, options = {}) {
+  try {
+    const headers = options.headers || useRequestHeaders(["cookie"]);
+    const fetchOptions = headers ? { headers } : void 0;
+    const query = options.force ? { disableCookieCache: true } : void 0;
+    const result = await client.getSession({ query }, fetchOptions);
+    const data = result.data;
+    if (data?.session && data?.user) {
+      session.value = stripToken(data.session);
+      user.value = data.user;
+    } else {
+      session.value = null;
+      user.value = null;
+    }
+  } catch (error) {
+    session.value = null;
+    user.value = null;
+    if (!isExpectedSignedOutSessionError(error))
+      console.error("[nuxt-better-auth] Failed to fetch session:", error);
+  } finally {
+    if (!authReady.value)
+      authReady.value = true;
+  }
+}

package/dist/runtime/app/internal/utils.d.ts

@@ -0,0 +1 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/runtime/app/internal/utils.js

@@ -0,0 +1,3 @@
+export function isRecord(value) {
+  return Boolean(value && typeof value === "object");
+}

package/dist/runtime/app/internal/vue-safe-auth-proxy.d.ts

@@ -0,0 +1,3 @@
+export declare function isAuthProxyProbeKey(prop: PropertyKey): boolean;
+export declare function createVueSafeAuthFacade<T extends object>(resolve: (prop: PropertyKey, receiver: object) => unknown): T;
+export declare function createVueSafeAuthProxy<T>(target: T): T;

package/dist/runtime/app/internal/vue-safe-auth-proxy.js

@@ -0,0 +1,68 @@
+const promiseProbeKeys = /* @__PURE__ */ new Set(["then", "catch", "finally"]);
+export function isAuthProxyProbeKey(prop) {
+  return typeof prop !== "string" || promiseProbeKeys.has(prop) || prop.startsWith("__v");
+}
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+export function createVueSafeAuthFacade(resolve) {
+  const propertyCache = /* @__PURE__ */ new Map();
+  const facadeTarget = {};
+  Object.defineProperty(facadeTarget, "__v_skip", {
+    value: true,
+    configurable: true
+  });
+  return new Proxy(facadeTarget, {
+    get(_target, prop, receiver) {
+      if (prop === "__v_skip")
+        return true;
+      if (isAuthProxyProbeKey(prop))
+        return void 0;
+      if (propertyCache.has(prop))
+        return propertyCache.get(prop);
+      const value = resolve(prop, receiver);
+      propertyCache.set(prop, value);
+      return value;
+    }
+  });
+}
+export function createVueSafeAuthProxy(target) {
+  if (!isObjectLike(target))
+    return target;
+  const cache = /* @__PURE__ */ new WeakMap();
+  const wrap = (value) => {
+    if (!isObjectLike(value))
+      return value;
+    const cached = cache.get(value);
+    if (cached)
+      return cached;
+    const propertyCache = /* @__PURE__ */ new Map();
+    const handler = {
+      get(target2, prop, receiver) {
+        if (prop === "__v_skip")
+          return true;
+        if (isAuthProxyProbeKey(prop))
+          return void 0;
+        if (propertyCache.has(prop))
+          return propertyCache.get(prop);
+        const wrapped = wrap(Reflect.get(target2, prop, receiver));
+        propertyCache.set(prop, wrapped);
+        return wrapped;
+      }
+    };
+    if (typeof value === "function") {
+      handler.apply = (target2, thisArg, args) => Reflect.apply(target2, thisArg, args);
+    }
+    const proxy = new Proxy(value, handler);
+    cache.set(value, proxy);
+    return proxy;
+  };
+  const createRootFacade = (value) => {
+    if (!isObjectLike(value))
+      return value;
+    const proxy = createVueSafeAuthFacade((prop, receiver) => wrap(Reflect.get(value, prop, receiver)));
+    cache.set(value, proxy);
+    return proxy;
+  };
+  return createRootFacade(target);
+}

package/dist/runtime/app/internal/wrap-auth-method.d.ts

@@ -0,0 +1,15 @@
+import type { ComputedRef } from 'vue';
+export declare function wrapOnSuccess(fetchSession: (options?: {
+    force?: boolean;
+}) => Promise<void>, loggedIn: ComputedRef<boolean>, waitForSession: () => Promise<void>, cb: (ctx: unknown) => void | Promise<void>): (ctx: unknown) => Promise<void>;
+export declare function wrapAuthMethod<T extends (...args: unknown[]) => Promise<unknown>>(method: T, deps: {
+    fetchSession: (options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    loggedIn: ComputedRef<boolean>;
+    waitForSession: () => Promise<void>;
+    resolvePostAuthSuccessRedirect: () => (() => Promise<void>) | undefined;
+}, wrapOptions?: {
+    shouldSkipSessionSync?: (data: unknown, options: unknown) => boolean;
+    transformData?: (data: unknown, options: unknown) => unknown;
+}): T;

package/dist/runtime/app/internal/wrap-auth-method.js

@@ -0,0 +1,66 @@
+import { nextTick } from "#imports";
+import { isRecord } from "./utils.js";
+export function wrapOnSuccess(fetchSession, loggedIn, waitForSession, cb) {
+  return async (ctx) => {
+    await fetchSession({ force: true });
+    if (!loggedIn.value)
+      await waitForSession();
+    await nextTick();
+    await cb(ctx);
+  };
+}
+export function wrapAuthMethod(method, deps, wrapOptions = {}) {
+  return (async (...args) => {
+    const originalData = args[0];
+    const options = args[1];
+    const data = wrapOptions.transformData?.(originalData, options) ?? originalData;
+    const dataRecord = isRecord(data) ? data : void 0;
+    const optionsRecord = isRecord(options) ? options : void 0;
+    if (wrapOptions.shouldSkipSessionSync?.(data, options))
+      return method(data, options);
+    const fetchOptions = isRecord(dataRecord?.fetchOptions) ? dataRecord.fetchOptions : void 0;
+    const nestedOnSuccess = fetchOptions?.onSuccess;
+    const topLevelOnSuccess = optionsRecord?.onSuccess;
+    const fallbackOnSuccess = deps.resolvePostAuthSuccessRedirect();
+    const wrappedFallbackOnSuccess = fallbackOnSuccess && wrapOnSuccess(deps.fetchSession, deps.loggedIn, deps.waitForSession, async () => {
+      if (!deps.loggedIn.value)
+        return;
+      await fallbackOnSuccess();
+    });
+    if (typeof nestedOnSuccess === "function") {
+      const nextData = {
+        ...dataRecord,
+        fetchOptions: {
+          ...fetchOptions,
+          onSuccess: wrapOnSuccess(deps.fetchSession, deps.loggedIn, deps.waitForSession, nestedOnSuccess)
+        }
+      };
+      return method(nextData, options);
+    }
+    if (typeof topLevelOnSuccess === "function") {
+      const nextOptions = {
+        ...optionsRecord,
+        onSuccess: wrapOnSuccess(deps.fetchSession, deps.loggedIn, deps.waitForSession, topLevelOnSuccess)
+      };
+      return method(data, nextOptions);
+    }
+    if (wrappedFallbackOnSuccess) {
+      if (fetchOptions) {
+        const nextData = {
+          ...dataRecord,
+          fetchOptions: {
+            ...fetchOptions,
+            onSuccess: wrappedFallbackOnSuccess
+          }
+        };
+        return method(nextData, options);
+      }
+      const nextOptions = {
+        ...optionsRecord,
+        onSuccess: wrappedFallbackOnSuccess
+      };
+      return method(data, nextOptions);
+    }
+    return method(data, options);
+  });
+}

package/dist/runtime/app/middleware/auth.global.js

@@ -1,7 +1,8 @@
-import { createError, defineNuxtRouteMiddleware, getRouteRules, navigateTo, useNuxtApp, useRequestHeaders, useRuntimeConfig, useUserSession } from "#imports";
 import { defu } from "defu";
 import { createRouter, toRouteMatcher } from "radix3";
+import { createError, defineNuxtRouteMiddleware, getRouteRules, navigateTo, useNuxtApp, useRequestHeaders, useRuntimeConfig } from "#imports";
 import { matchesUser } from "../../utils/match-user.js";
+import { useUserSession } from "../composables/useUserSession.js";
 let authRouteRulesPromise = null;
 let routeRulesMatcherPromise = null;
 export default defineNuxtRouteMiddleware(async (to) => {
@@ -25,13 +26,13 @@ export default defineNuxtRouteMiddleware(async (to) => {
     return;
   const config = useRuntimeConfig().public.auth;
   const { fetchSession, user, loggedIn } = useUserSession();
-  if (!loggedIn.value) {
+  const mode = typeof auth === "string" ? auth : auth?.only ?? "user";
+  const redirectTo = typeof auth === "object" ? auth.redirectTo : void 0;
+  if (!loggedIn.value || mode === "guest") {
     const headers = import.meta.server ? useRequestHeaders(["cookie"]) : void 0;
     const isHydratedPrerenderPayload = (import.meta.client || !import.meta.server) && nuxtApp.isHydrating && Boolean(nuxtApp.payload.prerenderedAt || nuxtApp.payload.isCached);
     await fetchSession({ headers, ...isHydratedPrerenderPayload ? { force: true } : {} });
   }
-  const mode = typeof auth === "string" ? auth : auth?.only ?? "user";
-  const redirectTo = typeof auth === "object" ? auth.redirectTo : void 0;
   if (mode === "guest") {
     if (loggedIn.value)
       return navigateTo(redirectTo ?? config?.redirects?.guest ?? "/");

package/dist/runtime/app/plugins/session.client.js

@@ -1,4 +1,5 @@
-import { defineNuxtPlugin, useUserSession } from "#imports";
+import { defineNuxtPlugin } from "#imports";
+import { useUserSession } from "../composables/useUserSession.js";
 export default defineNuxtPlugin(async (nuxtApp) => {
   const { fetchSession } = useUserSession();
   const safeFetch = async () => {

package/dist/runtime/composables.d.ts

@@ -0,0 +1,11 @@
+export { useAction } from './app/composables/useAction.js';
+export { useAuthAsyncData } from './app/composables/useAuthAsyncData.js';
+export { useAuthClient } from './app/composables/useAuthClient.js';
+export { useAuthClientAction } from './app/composables/useAuthClientAction.js';
+export { useAuthRequestFetch } from './app/composables/useAuthRequestFetch.js';
+export { useSignIn } from './app/composables/useSignIn.js';
+export { useSignUp } from './app/composables/useSignUp.js';
+export { useUserSession } from './app/composables/useUserSession.js';
+export type { SignOutOptions, UseUserSessionReturn } from './app/composables/useUserSession.js';
+export { useUserSessionState } from './app/composables/useUserSessionState.js';
+export type { UseUserSessionStateReturn } from './app/composables/useUserSessionState.js';

package/dist/runtime/composables.js

@@ -0,0 +1,9 @@
+export { useAction } from "./app/composables/useAction.js";
+export { useAuthAsyncData } from "./app/composables/useAuthAsyncData.js";
+export { useAuthClient } from "./app/composables/useAuthClient.js";
+export { useAuthClientAction } from "./app/composables/useAuthClientAction.js";
+export { useAuthRequestFetch } from "./app/composables/useAuthRequestFetch.js";
+export { useSignIn } from "./app/composables/useSignIn.js";
+export { useSignUp } from "./app/composables/useSignUp.js";
+export { useUserSession } from "./app/composables/useUserSession.js";
+export { useUserSessionState } from "./app/composables/useUserSessionState.js";

package/dist/runtime/config.d.ts

@@ -1,9 +1,11 @@
 import type { BetterAuthOptions, BetterAuthPlugin } from 'better-auth';
 import type { BetterAuthClientOptions } from 'better-auth/client';
-import type { CasingOption } from '../schema-generator.js';
-import type { ServerAuthContext } from './types/augment.js';
+import type { Casing } from 'drizzle-orm/utils';
+import type { ServerAuthContext as BaseServerAuthContext } from './types/augment.js';
 import { createAuthClient } from 'better-auth/vue';
-export type { ServerAuthContext };
+export interface ServerAuthContextExtension {
+}
+export type ServerAuthContext = BaseServerAuthContext & ServerAuthContextExtension;
 export interface ClientAuthContext {
     siteUrl: string;
 }
@@ -20,9 +22,9 @@ export type EffectiveDatabaseProviderId = 'user' | ModuleDatabaseProviderId;
 export interface BetterAuthModuleOptions {
     /** Client-only mode - skip server setup for external auth backends */
     clientOnly?: boolean;
-    /** Server config path relative to rootDir. Default: 'server/auth.config' */
+    /** Server config path. Relative paths resolve from the layer that declares them. Default: 'server/auth.config' */
     serverConfig?: string;
-    /** Client config path relative to rootDir. Default: 'app/auth.config' */
+    /** Client config path. Relative paths resolve from the layer that declares them. Default: 'app/auth.config' */
     clientConfig?: string;
     redirects?: {
         /** Where to redirect unauthenticated users. Default: '/login' */
@@ -69,7 +71,7 @@ export interface BetterAuthModuleOptions {
         /** Plural table names: user → users. Default: false */
         usePlural?: boolean;
         /** Column/table name casing. Explicit value takes precedence over hub.db.casing. */
-        casing?: CasingOption;
+        casing?: Casing;
     };
 }
 export interface AuthRuntimeConfig {

package/dist/runtime/config.js

@@ -6,6 +6,8 @@ export function defineClientAuth(config) {
   return (baseURL) => {
     const ctx = { siteUrl: baseURL };
     const resolved = typeof config === "function" ? config(ctx) : config;
-    return createAuthClient({ ...resolved, baseURL });
+    const { baseURL: configuredBaseURL, ...resolvedOptions } = resolved;
+    const clientOptions = { ...resolvedOptions, baseURL: configuredBaseURL ?? baseURL };
+    return createAuthClient(clientOptions);
   };
 }

package/dist/runtime/server/api/_better-auth/_schema.d.ts

@@ -1,8 +1,4 @@
 import { z } from 'zod';
-export declare const paginationQuerySchema: z.ZodObject<{
-    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    search: z.ZodDefault<z.ZodString>;
-}, z.core.$strip>;
+export declare const paginationQuerySchema: any;
 export type PaginationQuery = z.infer<typeof paginationQuerySchema>;
 export declare function sanitizeSearchPattern(search: string): string;

package/dist/runtime/server/api/_better-auth/_schema.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+const SQL_LIKE_ESCAPE_RE = /[%_\\]/g;
 export const paginationQuerySchema = z.object({
   page: z.coerce.number().int().min(1).default(1),
   limit: z.coerce.number().int().min(1).max(100).default(20),
@@ -7,5 +8,5 @@ export const paginationQuerySchema = z.object({
 export function sanitizeSearchPattern(search) {
   if (!search)
     return "";
-  return `%${search.replace(/[%_\\]/g, "\\$&")}%`;
+  return `%${search.replace(SQL_LIKE_ESCAPE_RE, "\\$&")}%`;
 }

package/dist/runtime/server/api/_better-auth/accounts.get.d.ts

@@ -7,8 +7,8 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
 } | {
     accounts: any;
     total: any;
-    page: number;
-    limit: number;
+    page: any;
+    limit: any;
     error?: undefined;
 }>>;
 export default _default;

package/dist/runtime/server/api/_better-auth/config.get.js

@@ -1,5 +1,5 @@
 import { defineEventHandler } from "h3";
-import { useRuntimeConfig } from "nitropack/runtime";
+import { useRuntimeConfig } from "#imports";
 import { serverAuth } from "../../utils/auth.js";
 export default defineEventHandler(async (event) => {
   try {

package/dist/runtime/server/api/_better-auth/sessions.get.d.ts

@@ -9,8 +9,8 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
 } | {
     sessions: SafeSession[];
     total: any;
-    page: number;
-    limit: number;
+    page: any;
+    limit: any;
     error?: undefined;
 }>>;
 export default _default;

package/dist/runtime/server/api/_better-auth/users.get.d.ts

@@ -7,8 +7,8 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
 } | {
     users: any;
     total: any;
-    page: number;
-    limit: number;
+    page: any;
+    limit: any;
     error?: undefined;
 }>>;
 export default _default;

package/dist/runtime/server/middleware/route-access.js

@@ -1,5 +1,5 @@
 import { createError, defineEventHandler, getRequestURL } from "h3";
-import { getRouteRules } from "nitropack/runtime";
+import { getRouteRules } from "#imports";
 import { matchesUser } from "../../utils/match-user.js";
 import { getUserSession, requireUserSession } from "../utils/session.js";
 export default defineEventHandler(async (event) => {

package/dist/runtime/server/utils/auth.d.ts

@@ -1,8 +1,19 @@
+import type { BetterAuthOptions } from 'better-auth';
 import type { H3Event } from 'h3';
-import createServerAuth from '#auth/server';
 import { betterAuth } from 'better-auth';
+import createServerAuth from '#auth/server';
 type AuthOptions = ReturnType<typeof createServerAuth>;
-type AuthInstance = ReturnType<typeof betterAuth<AuthOptions>>;
+type UserAuthConfig = AuthOptions & {
+    trustedOrigins?: BetterAuthOptions['trustedOrigins'];
+    secondaryStorage?: BetterAuthOptions['secondaryStorage'];
+};
+type ResolvedAuthOptions = UserAuthConfig & {
+    secret: string;
+    baseURL: string;
+    trustedOrigins?: BetterAuthOptions['trustedOrigins'];
+    database?: BetterAuthOptions['database'];
+};
+type AuthInstance = ReturnType<typeof betterAuth<ResolvedAuthOptions>>;
 /** Returns Better Auth instance. Caches per resolved host (or single instance when siteUrl is explicit). */
 export declare function serverAuth(event?: H3Event): AuthInstance;
 export {};

package/dist/runtime/server/utils/auth.js

@@ -1,14 +1,27 @@
-import { createDatabase, db } from "#auth/database";
-import { createSecondaryStorage } from "#auth/secondary-storage";
-import createServerAuth from "#auth/server";
 import { betterAuth } from "better-auth";
 import { getRequestHost, getRequestProtocol } from "h3";
 import { useRuntimeConfig } from "nitropack/runtime";
 import { withoutProtocol } from "ufo";
+import { createDatabase, db } from "#auth/database";
+import { createSecondaryStorage } from "#auth/secondary-storage";
+import createServerAuth from "#auth/server";
 import { resolveCustomSecondaryStorageRequirement } from "./custom-secondary-storage.js";
 const _authCache = /* @__PURE__ */ new Map();
+const requestAuthKey = Symbol.for("nuxt-better-auth.requestAuth");
 let _baseURLInferenceLogged = false;
 let _customSecondaryStorageMisconfigWarned = false;
+const fallbackRequestAuthContext = /* @__PURE__ */ new WeakMap();
+function getRequestAuthContext(event) {
+  const eventWithContext = event;
+  if (eventWithContext.context && typeof eventWithContext.context === "object")
+    return eventWithContext.context;
+  let context = fallbackRequestAuthContext.get(event);
+  if (!context) {
+    context = {};
+    fallbackRequestAuthContext.set(event, context);
+  }
+  return context;
+}
 function normalizeLoopbackOrigin(origin) {
   if (!import.meta.dev)
     return origin;
@@ -155,8 +168,8 @@ function getRequestOrigin(request) {
     return void 0;
   }
 }
-function withDevTrustedOrigins(trustedOrigins, hasExplicitSiteUrl) {
-  if (!import.meta.dev || !hasExplicitSiteUrl)
+function withDevTrustedOrigins(trustedOrigins) {
+  if (!import.meta.dev)
     return trustedOrigins;
   const devOrigins = getDevTrustedOrigins();
   const mergeOrigins = (origins, request) => {
@@ -183,14 +196,15 @@ function withDevTrustedOrigins(trustedOrigins, hasExplicitSiteUrl) {
 export function serverAuth(event) {
   const runtimeConfig = useRuntimeConfig();
   const siteUrl = getBaseURL(event);
+  const requestOrigin = resolveEventOrigin(event);
   const hasExplicitSiteUrl = runtimeConfig.public.siteUrl && typeof runtimeConfig.public.siteUrl === "string";
   const cacheKey = hasExplicitSiteUrl ? "__explicit__" : siteUrl;
-  const cached = _authCache.get(cacheKey);
-  if (cached)
-    return cached;
-  const database = createDatabase();
-  const userConfig = createServerAuth({ runtimeConfig, db });
-  const trustedOrigins = withDevTrustedOrigins(userConfig.trustedOrigins, Boolean(hasExplicitSiteUrl));
+  const requestContext = event ? getRequestAuthContext(event) : void 0;
+  if (requestContext?.[requestAuthKey])
+    return requestContext[requestAuthKey];
+  const database = createDatabase(event);
+  const userConfig = createServerAuth({ runtimeConfig, db, requestOrigin });
+  const trustedOrigins = withDevTrustedOrigins(userConfig.trustedOrigins);
   const hubSecondaryStorage = runtimeConfig.auth?.hubSecondaryStorage;
   const customSecondaryStorage = resolveCustomSecondaryStorageRequirement(hubSecondaryStorage, userConfig.secondaryStorage != null, Boolean(import.meta.dev));
   if (customSecondaryStorage?.shouldThrow)
@@ -199,14 +213,26 @@ export function serverAuth(event) {
     _customSecondaryStorageMisconfigWarned = true;
     console.warn(customSecondaryStorage.message);
   }
-  const auth = betterAuth({
+  if (!database) {
+    const cached = _authCache.get(cacheKey);
+    if (cached) {
+      if (requestContext)
+        requestContext[requestAuthKey] = cached;
+      return cached;
+    }
+  }
+  const authOptions = {
     ...userConfig,
-    ...database && { database },
-    ...hubSecondaryStorage === true && { secondaryStorage: createSecondaryStorage() },
+    ...database ? { database } : {},
+    ...hubSecondaryStorage === true ? { secondaryStorage: createSecondaryStorage() } : {},
     secret: runtimeConfig.betterAuthSecret,
     baseURL: siteUrl,
     trustedOrigins
-  });
-  _authCache.set(cacheKey, auth);
+  };
+  const auth = betterAuth(authOptions);
+  if (requestContext)
+    requestContext[requestAuthKey] = auth;
+  if (!database)
+    _authCache.set(cacheKey, auth);
   return auth;
 }

package/dist/runtime/server/utils/session.d.ts

@@ -1,5 +1,7 @@
-import type { AppSession, RequireSessionOptions } from '#nuxt-better-auth';
 import type { H3Event } from 'h3';
+import type { AppSession, AuthSession, RequireSessionOptions } from '#nuxt-better-auth';
 export declare function getRequestSession(event: H3Event): Promise<AppSession | null>;
 export declare function getUserSession(event: H3Event): Promise<AppSession | null>;
+export declare function setSessionCookie(event: H3Event, token: string): Promise<void>;
+export declare function createSession(event: H3Event, userId: string): Promise<AuthSession>;
 export declare function requireUserSession(event: H3Event, options?: RequireSessionOptions): Promise<AppSession>;