@stacksjs/browser 0.70.58 → 0.70.59

package/dist/index.js

@@ -1,1556 +1,16 @@
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
+import"./auto-init";
 
-// src/auto-init.ts
-import {
+export * from "./composables";
+export * from "./utils";
+export * from "./model-loader";
+export {
   browserQuery,
   BrowserQueryBuilder,
   BrowserQueryError,
-  browserAuth as browserAuth2,
-  configureBrowser as configureBrowser2,
+  browserAuth,
+  configureBrowser,
   getBrowserConfig,
   createBrowserDb,
-  createBrowserModel as createBrowserModel2,
+  createBrowserModel,
   isBrowser
 } from "bun-query-builder/browser";
-
-// src/composables/index.ts
-var exports_composables = {};
-__export(exports_composables, {
-  useWindowSize: () => useWindowSize,
-  useWindowScroll: () => useWindowScroll,
-  useWindowFocus: () => useWindowFocus,
-  useWebWorkerFn: () => useWebWorkerFn,
-  useWebWorker: () => useWebWorker,
-  useWebSocket: () => useWebSocket,
-  useWebNotification: () => useWebNotification,
-  useWakeLock: () => useWakeLock,
-  useVibrate: () => useVibrate,
-  useUrlSearchParams: () => useUrlSearchParams,
-  useTransition: () => useTransition,
-  useToggle: () => useToggle,
-  useTitle: () => useTitle,
-  useTimestamp: () => useTimestamp,
-  useTimeoutPoll: () => useTimeoutPoll,
-  useTimeoutFn: () => useTimeoutFn,
-  useTimeout: () => useTimeout,
-  useTimeAgo: () => useTimeAgo,
-  useThrottleFn: () => useThrottleFn,
-  useTextSelection: () => useTextSelection,
-  useTextDirection: () => useTextDirection,
-  useSwipe: () => useSwipe,
-  useSupported: () => useSupported,
-  useStorage: () => useStorage2,
-  useStepper: () => useStepper,
-  useShare: () => useShare,
-  useSessionStorage: () => useSessionStorage,
-  useScrollLock: () => useScrollLock,
-  useScroll: () => useScroll,
-  useScreenOrientation: () => useScreenOrientation,
-  useRafFn: () => useRafFn,
-  usePreferredReducedMotion: () => usePreferredReducedMotion,
-  usePreferredLanguages: () => usePreferredLanguages,
-  usePreferredDark: () => usePreferredDark,
-  usePreferredContrast: () => usePreferredContrast,
-  usePreferredColorScheme: () => usePreferredColorScheme,
-  usePointerSwipe: () => usePointerSwipe,
-  usePointer: () => usePointer,
-  usePermission: () => usePermission,
-  usePageLeave: () => usePageLeave,
-  useOnline: () => useOnline,
-  useObjectUrl: () => useObjectUrl,
-  useNow: () => useNow,
-  useNetwork: () => useNetwork,
-  useNavigatorLanguage: () => useNavigatorLanguage,
-  useMousePressed: () => useMousePressed,
-  useMouseInElement: () => useMouseInElement,
-  useMouse: () => useMouse,
-  useMounted: () => useMounted,
-  useMemoize: () => useMemoize,
-  useMediaQuery: () => useMediaQuery,
-  useMagicKeys: () => useMagicKeys,
-  useLocalStorage: () => useLocalStorage,
-  useKeyModifier: () => useKeyModifier,
-  useIntervalFn: () => useIntervalFn,
-  useInterval: () => useInterval,
-  useInfiniteScroll: () => useInfiniteScroll,
-  useImage: () => useImage,
-  useIdle: () => useIdle,
-  useGeolocation: () => useGeolocation,
-  useFullscreen: () => useFullscreen,
-  useFocusWithin: () => useFocusWithin,
-  useFocus: () => useFocus,
-  useFileDialog: () => useFileDialog,
-  useFetch: () => useFetch,
-  useFavicon: () => useFavicon,
-  useEyeDropper: () => useEyeDropper,
-  useEventSource: () => useEventSource,
-  useEventListener: () => useEventListener,
-  useEventBus: () => useEventBus,
-  useElementVisibility: () => useElementVisibility,
-  useElementSize: () => useElementSize,
-  useElementHover: () => useElementHover,
-  useElementBounding: () => useElementBounding,
-  useDropZone: () => useDropZone,
-  useDraggable: () => useDraggable,
-  useDocumentVisibility: () => useDocumentVisibility,
-  useDevicePixelRatio: () => useDevicePixelRatio,
-  useDeviceOrientation: () => useDeviceOrientation,
-  useDeviceMotion: () => useDeviceMotion,
-  useDebounceFn: () => useDebounceFn,
-  useDateFormat: () => useDateFormat,
-  useDark: () => useDark,
-  useCycleList: () => useCycleList,
-  useCssVar: () => useCssVar,
-  useCounter: () => useCounter,
-  useConfirmDialog: () => useConfirmDialog,
-  useColorMode: () => useColorMode,
-  useClipboardItems: () => useClipboardItems,
-  useClipboard: () => useClipboard,
-  useBrowserLocation: () => useBrowserLocation,
-  useBroadcastChannel: () => useBroadcastChannel,
-  useBreakpoints: () => useBreakpoints,
-  useBattery: () => useBattery,
-  useBase64: () => useBase64,
-  useAuth: () => useAuth,
-  useAnimate: () => useAnimate,
-  useActiveElement: () => useActiveElement,
-  onStartTyping: () => onStartTyping,
-  onLongPress: () => onLongPress,
-  onKeyUp: () => onKeyUp,
-  onKeyStroke: () => onKeyStroke,
-  onKeyDown: () => onKeyDown,
-  onClickOutside: () => onClickOutside,
-  initApi: () => initApi,
-  getRelativeTime: () => getRelativeTime,
-  formatElevation: () => formatElevation,
-  formatDuration: () => formatDuration,
-  formatDistance: () => formatDistance,
-  formatAreaSize: () => formatAreaSize,
-  fetchData: () => fetchData,
-  breakpointsTailwind: () => breakpointsTailwind,
-  breakpointsBootstrapV5: () => breakpointsBootstrapV5,
-  authGuard: () => authGuard,
-  auth: () => auth,
-  TransitionPresets: () => TransitionPresets
-});
-
-// src/composables/useAuth.ts
-import { useStorage } from "@stacksjs/composables";
-import { ref } from "@stacksjs/stx";
-var token = useStorage("token", "");
-var stacksConfig = globalThis.__STACKS_CONFIG__ || {};
-var baseUrl = stacksConfig.API_URL || (typeof window !== "undefined" ? window.location.origin : `http://localhost:${process.env.PORT_API || "3008"}`);
-var user = ref(null);
-var isAuthenticated = ref(false);
-function useAuth() {
-  async function fetchAuthUser() {
-    try {
-      if (!token.value) {
-        isAuthenticated.value = false;
-        user.value = null;
-        return null;
-      }
-      const response = await fetch(`${baseUrl}/me`, {
-        headers: {
-          Authorization: `Bearer ${token.value}`,
-          Accept: "application/json"
-        }
-      });
-      if (!response.ok) {
-        token.value = "";
-        isAuthenticated.value = false;
-        user.value = null;
-        return null;
-      }
-      const data = await response.json();
-      user.value = data;
-      isAuthenticated.value = true;
-      return data;
-    } catch (error) {
-      console.error("Error fetching user:", error);
-      token.value = "";
-      isAuthenticated.value = false;
-      user.value = null;
-      return null;
-    }
-  }
-  async function checkAuthentication() {
-    try {
-      const userData = await fetchAuthUser();
-      return userData !== null;
-    } catch (error) {
-      console.error("Error checking authentication:", error);
-      return false;
-    }
-  }
-  async function register(user2) {
-    const url = `${baseUrl}/register`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(user2)
-    });
-    const data = await response.json();
-    if (isRegisterError(data)) {
-      return data;
-    }
-    if (isRegisterResponse(data)) {
-      token.value = data.token;
-      return data;
-    }
-    return data;
-  }
-  function isRegisterError(data) {
-    return "errors" in data;
-  }
-  function isRegisterResponse(data) {
-    return "token" in data && "user" in data;
-  }
-  async function login(user2) {
-    try {
-      const url = `${baseUrl}/login`;
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(user2)
-      });
-      if (!response.ok) {
-        const errorData = await response.json();
-        throw new Error(errorData.message || `HTTP error! status: ${response.status}`);
-      }
-      const data = await response.json();
-      token.value = data.token;
-      await fetchAuthUser();
-      return data;
-    } catch (error) {
-      return error;
-    }
-  }
-  async function logout() {
-    try {
-      const currentToken = token.value;
-      if (currentToken) {
-        await fetch(`${baseUrl}/logout`, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${currentToken}`,
-            Accept: "application/json"
-          }
-        });
-      }
-    } catch (error) {
-      console.error("Error during logout:", error);
-    } finally {
-      token.value = "";
-      user.value = null;
-      isAuthenticated.value = false;
-    }
-  }
-  return {
-    user,
-    isAuthenticated,
-    token,
-    getToken: () => token.value,
-    register,
-    login,
-    logout,
-    fetchAuthUser,
-    checkAuthentication
-  };
-}
-function authGuard(options = {}) {
-  const guest = options.guest ?? false;
-  const { isAuthenticated: isAuthenticated2 } = useAuth();
-  if (guest) {
-    if (isAuthenticated2.value) {
-      window.location.replace("/");
-    }
-    return;
-  }
-  if (!isAuthenticated2.value) {
-    window.location.replace("/login");
-  }
-}
-// src/composables/useApi.ts
-import { configureBrowser, browserAuth } from "bun-query-builder/browser";
-function initApi(options) {
-  const stacksConfig2 = globalThis.__STACKS_CONFIG__ || {};
-  const baseUrl2 = options?.baseUrl || (typeof window !== "undefined" ? `${window.location.origin}/api` : `http://localhost:${process.env.PORT_API || "3008"}/api`);
-  configureBrowser({
-    baseUrl: baseUrl2,
-    getToken: () => {
-      if (typeof localStorage !== "undefined") {
-        return localStorage.getItem("token");
-      }
-      return null;
-    },
-    onUnauthorized: options?.onUnauthorized || (() => {
-      if (typeof window !== "undefined") {
-        window.location.href = "/login";
-      }
-    }),
-    transformResponse: (data) => {
-      return data?.data ?? data;
-    }
-  });
-}
-var auth = browserAuth;
-function formatAreaSize(sqMeters) {
-  if (sqMeters >= 1e6) {
-    return `${(sqMeters / 1e6).toFixed(2)} km²`;
-  }
-  if (sqMeters >= 1e4) {
-    return `${(sqMeters / 1e4).toFixed(2)} ha`;
-  }
-  return `${sqMeters.toLocaleString()} m²`;
-}
-function formatDistance(miles) {
-  return `${miles.toFixed(1)} mi`;
-}
-function formatElevation(feet) {
-  return `${feet.toLocaleString()} ft`;
-}
-function formatDuration(seconds) {
-  const hours = Math.floor(seconds / 3600);
-  const minutes = Math.floor(seconds % 3600 / 60);
-  const secs = seconds % 60;
-  if (hours > 0) {
-    return `${hours}h ${minutes}m`;
-  }
-  if (minutes > 0) {
-    return `${minutes}m ${secs}s`;
-  }
-  return `${secs}s`;
-}
-function getRelativeTime(dateString) {
-  const date = new Date(dateString);
-  const now = new Date;
-  const diffMs = now.getTime() - date.getTime();
-  const diffSeconds = Math.floor(diffMs / 1000);
-  const diffMinutes = Math.floor(diffSeconds / 60);
-  const diffHours = Math.floor(diffMinutes / 60);
-  const diffDays = Math.floor(diffHours / 24);
-  const diffWeeks = Math.floor(diffDays / 7);
-  if (diffSeconds < 60)
-    return "just now";
-  if (diffMinutes < 60)
-    return `${diffMinutes} minute${diffMinutes === 1 ? "" : "s"} ago`;
-  if (diffHours < 24)
-    return `${diffHours} hour${diffHours === 1 ? "" : "s"} ago`;
-  if (diffDays < 7)
-    return `${diffDays} day${diffDays === 1 ? "" : "s"} ago`;
-  if (diffWeeks < 4)
-    return `${diffWeeks} week${diffWeeks === 1 ? "" : "s"} ago`;
-  return date.toLocaleDateString();
-}
-async function fetchData(fetcher, options) {
-  try {
-    return await fetcher();
-  } catch (error) {
-    if (options?.onError) {
-      options.onError(error);
-    } else {
-      console.error("API Error:", error);
-    }
-    return options?.fallback;
-  }
-}
-
-// src/composables/index.ts
-import {
-  useColorMode,
-  useDark,
-  usePreferredColorScheme,
-  usePreferredContrast,
-  usePreferredDark,
-  usePreferredReducedMotion,
-  useDateFormat,
-  useNow,
-  useTimeAgo,
-  useTimestamp,
-  useFetch,
-  useNetwork,
-  useOnline,
-  useLocalStorage,
-  useSessionStorage,
-  useStorage as useStorage2,
-  useToggle,
-  useCounter,
-  useStepper,
-  useCycleList,
-  useActiveElement,
-  useClipboard,
-  useClipboardItems,
-  useCssVar,
-  useDocumentVisibility,
-  useElementBounding,
-  useElementHover,
-  useElementSize,
-  useElementVisibility,
-  useFocus,
-  useFocusWithin,
-  useFullscreen,
-  useScroll,
-  useScrollLock,
-  useTitle,
-  useWindowFocus,
-  useWindowScroll,
-  useWindowSize,
-  onClickOutside,
-  onKeyDown,
-  onKeyStroke,
-  onKeyUp,
-  onLongPress,
-  onStartTyping,
-  useEventListener,
-  useKeyModifier,
-  useMagicKeys,
-  useDraggable,
-  useDropZone,
-  useMouse,
-  useMouseInElement,
-  useMousePressed,
-  usePointer,
-  usePointerSwipe,
-  useSwipe,
-  useBattery,
-  useDeviceMotion,
-  useDeviceOrientation,
-  useDevicePixelRatio,
-  useGeolocation,
-  useBreakpoints,
-  useMediaQuery,
-  breakpointsTailwind,
-  breakpointsBootstrapV5,
-  useBrowserLocation,
-  useIdle,
-  useInfiniteScroll,
-  useNavigatorLanguage,
-  usePageLeave,
-  usePreferredLanguages,
-  useScreenOrientation,
-  useTextDirection,
-  useTextSelection,
-  useUrlSearchParams,
-  useDebounceFn,
-  useInterval,
-  useIntervalFn,
-  useRafFn,
-  useThrottleFn,
-  useTimeout,
-  useTimeoutFn,
-  useTimeoutPoll,
-  useAnimate,
-  useTransition,
-  TransitionPresets,
-  useBase64,
-  useBroadcastChannel,
-  useConfirmDialog,
-  useEventBus,
-  useEventSource,
-  useEyeDropper,
-  useFavicon,
-  useFileDialog,
-  useImage,
-  useObjectUrl,
-  usePermission,
-  useShare,
-  useVibrate,
-  useWakeLock,
-  useWebNotification,
-  useWebSocket,
-  useWebWorker,
-  useWebWorkerFn,
-  useSupported,
-  useMemoize,
-  useMounted
-} from "@stacksjs/composables";
-
-// src/model-loader.ts
-import { createBrowserModel } from "bun-query-builder/browser";
-var modelModules = typeof import.meta.glob === "function" ? import.meta.glob("~/app/Models/*.ts", { eager: true }) : {};
-function loadBrowserModels() {
-  if (typeof window === "undefined")
-    return;
-  if (!window.StacksBrowser) {
-    window.StacksBrowser = {};
-  }
-  for (const [path, module] of Object.entries(modelModules)) {
-    const definition = module.default;
-    if (!definition || !definition.name) {
-      console.warn(`[model-loader] Skipping ${path}: no valid model definition`);
-      continue;
-    }
-    if (!definition.traits?.useApi?.uri) {
-      continue;
-    }
-    try {
-      const browserModel = createBrowserModel({
-        name: definition.name,
-        table: definition.table,
-        primaryKey: definition.primaryKey || "id",
-        traits: {
-          useUuid: definition.traits?.useUuid ?? false,
-          useTimestamps: definition.traits?.useTimestamps ?? true,
-          useSoftDeletes: definition.traits?.useSoftDeletes ?? false,
-          useApi: definition.traits?.useApi
-        },
-        attributes: extractBrowserAttributes(definition.attributes ?? {})
-      });
-      window.StacksBrowser[definition.name] = browserModel;
-    } catch (error) {
-      console.error(`[model-loader] Failed to create browser model for ${definition.name}:`, error);
-    }
-  }
-}
-function extractBrowserAttributes(attributes) {
-  const browserAttrs = {};
-  for (const [name, attr] of Object.entries(attributes)) {
-    browserAttrs[name] = {
-      fillable: attr.fillable ?? false,
-      hidden: attr.hidden ?? false,
-      guarded: attr.guarded ?? false,
-      nullable: attr.nullable ?? false
-    };
-  }
-  return browserAttrs;
-}
-function getBrowserModel(name) {
-  if (typeof window === "undefined")
-    return null;
-  return window.StacksBrowser?.[name] ?? null;
-}
-function getBrowserModelNames() {
-  if (typeof window === "undefined")
-    return [];
-  const stacksBrowser = window.StacksBrowser;
-  if (!stacksBrowser)
-    return [];
-  return Object.keys(stacksBrowser).filter((key) => {
-    const value = stacksBrowser[key];
-    return value != null && typeof value.all === "function" && typeof value.find === "function";
-  });
-}
-
-// src/auto-init.ts
-var isInitialized = false;
-function autoInit() {
-  if (isInitialized)
-    return;
-  if (typeof window === "undefined")
-    return;
-  if (typeof document === "undefined")
-    return;
-  isInitialized = true;
-  const baseUrl2 = window.__STACKS_API_URL__ || `${window.location.origin}/api`;
-  configureBrowser2({
-    baseUrl: baseUrl2,
-    getToken: () => {
-      try {
-        return localStorage.getItem("token");
-      } catch {
-        return null;
-      }
-    },
-    onUnauthorized: () => {
-      const loginUrl = window.__STACKS_LOGIN_URL__ || "/login";
-      if (!window.location.pathname.startsWith(loginUrl)) {
-        window.location.href = loginUrl;
-      }
-    },
-    transformResponse: (data) => {
-      return data?.data ?? data;
-    }
-  });
-  window.StacksBrowser = {
-    browserQuery,
-    BrowserQueryBuilder,
-    BrowserQueryError,
-    browserAuth: browserAuth2,
-    configureBrowser: configureBrowser2,
-    getBrowserConfig,
-    createBrowserDb,
-    createBrowserModel: createBrowserModel2,
-    isBrowser,
-    ...exports_composables
-  };
-  loadBrowserModels();
-  window.dispatchEvent(new CustomEvent("stacks:api-ready"));
-  if (window.__STACKS_DEBUG__) {
-    console.debug("[Stacks] Browser API initialized:", baseUrl2);
-  }
-}
-autoInit();
-// src/utils/base.ts
-import { toString } from "@stacksjs/strings";
-async function loop(times, callback) {
-  Array.from({ length: times }).forEach(async (_, i) => await callback(i));
-}
-// src/utils/billable.ts
-import { loadStripe } from "@stripe/stripe-js";
-var stacksConfig2 = globalThis.__STACKS_CONFIG__ || {};
-var publishableKey = stacksConfig2.FRONTEND_STRIPE_PUBLIC_KEY || "";
-var client;
-async function loadCardElement(clientSecret) {
-  client = await loadStripe(publishableKey);
-  const elements = client.elements({ clientSecret });
-  const cardElement = elements.create("card");
-  cardElement.mount("#card-element");
-  return cardElement;
-}
-async function loadPaymentElement(clientSecret) {
-  client = await loadStripe(publishableKey);
-  const elements = client.elements({ clientSecret });
-  const paymentElement = elements.create("payment", {
-    fields: { billingDetails: "auto" }
-  });
-  paymentElement.mount("#payment-element");
-  return elements;
-}
-async function confirmCardSetup(clientSecret, elements) {
-  const data = await client.confirmCardSetup(clientSecret, { payment_method: { card: elements } });
-  const { setupIntent, error } = data;
-  return { setupIntent, error };
-}
-async function confirmCardPayment(clientSecret, elements) {
-  try {
-    const data = await client.confirmCardPayment(clientSecret, {
-      payment_method: {
-        card: elements,
-        billing_details: {
-          name: stacksConfig2.USER_NAME || ""
-        }
-      }
-    });
-    const { paymentIntent, error } = data;
-    return { paymentIntent, error };
-  } catch (err) {
-    console.error("Error confirming card payment:", err);
-    return { paymentIntent: null, error: err };
-  }
-}
-async function createPaymentMethod(elements) {
-  try {
-    const data = await client.createPaymentMethod({
-      type: "card",
-      card: elements
-    });
-    const { paymentIntent, error } = data;
-    return { paymentIntent, error };
-  } catch (err) {
-    console.error("Error confirming card payment:", err);
-    return { paymentIntent: null, error: err };
-  }
-}
-async function confirmPayment(elements) {
-  try {
-    const data = await client.confirmPayment({
-      elements,
-      confirmParams: {
-        return_url: `${window.location.origin}/settings/billing`
-      }
-    });
-    const { paymentIntent, error } = data;
-    return { paymentIntent, error };
-  } catch (err) {
-    console.error("Error confirming card payment:", err);
-    return { paymentIntent: null, error: err };
-  }
-}
-// src/utils/date.ts
-import { useDateFormat as useDateFormat2, useNow as useNow2 } from "@stacksjs/composables";
-import { format, parse } from "@stacksjs/datetime";
-// src/utils/debounce.ts
-function debounce(fn, wait = 0, options = {}) {
-  const { leading = false, trailing = true } = options;
-  let timeout = null;
-  let lastArgs = null;
-  let lastThis = null;
-  let result;
-  const invokeFunc = () => {
-    if (lastArgs) {
-      result = fn.apply(lastThis, lastArgs);
-      lastArgs = null;
-      lastThis = null;
-    }
-    return result;
-  };
-  const cancel = () => {
-    if (timeout) {
-      clearTimeout(timeout);
-      timeout = null;
-    }
-    lastArgs = null;
-    lastThis = null;
-  };
-  const flush = () => {
-    if (timeout) {
-      clearTimeout(timeout);
-      timeout = null;
-      return invokeFunc();
-    }
-    return result;
-  };
-  const debounced = function(...args) {
-    lastArgs = args;
-    lastThis = this;
-    const shouldCallNow = leading && !timeout;
-    if (timeout)
-      clearTimeout(timeout);
-    timeout = setTimeout(() => {
-      timeout = null;
-      if (trailing && lastArgs)
-        invokeFunc();
-    }, wait);
-    if (shouldCallNow)
-      return invokeFunc();
-    return result;
-  };
-  debounced.cancel = cancel;
-  debounced.flush = flush;
-  return debounced;
-}
-// src/utils/fetch.ts
-var loading = false;
-var token2 = "";
-var baseURL = "/";
-function appendParam(search, key, value) {
-  if (value === undefined || value === null)
-    return;
-  if (Array.isArray(value)) {
-    for (const v of value)
-      appendParam(search, key, v);
-    return;
-  }
-  if (typeof value === "object") {
-    search.append(key, JSON.stringify(value));
-    return;
-  }
-  search.append(key, String(value));
-}
-function buildUrl(url, params) {
-  const absolute = /^https?:\/\//i.test(url);
-  const full = absolute ? url : `${baseURL.replace(/\/$/, "")}/${url.replace(/^\//, "")}`;
-  if (!params || Object.keys(params).length === 0)
-    return full;
-  const search = new URLSearchParams;
-  for (const [key, value] of Object.entries(params))
-    appendParam(search, key, value);
-  const qs = search.toString();
-  if (!qs)
-    return full;
-  return full.includes("?") ? `${full}&${qs}` : `${full}?${qs}`;
-}
-function applyAuth(headers) {
-  const h = headers ?? new Headers;
-  if (token2 && !h.has("Authorization"))
-    h.set("Authorization", `Bearer ${token2}`);
-  return h;
-}
-async function parseBody(response) {
-  const contentType = response.headers.get("content-type") ?? "";
-  if (contentType.includes("application/json"))
-    return await response.json();
-  if (contentType.startsWith("text/") || contentType.includes("xml"))
-    return await response.text();
-  return await response.blob();
-}
-async function request(method, url, params, headers) {
-  const sendsBody = method !== "GET" && method !== "DELETE";
-  const finalUrl = sendsBody ? buildUrl(url) : buildUrl(url, params);
-  const finalHeaders = applyAuth(headers);
-  const init = { method, headers: finalHeaders };
-  if (sendsBody && params !== undefined) {
-    if (!finalHeaders.has("Content-Type"))
-      finalHeaders.set("Content-Type", "application/json");
-    init.body = JSON.stringify(params);
-  }
-  if (sendsBody)
-    loading = true;
-  try {
-    const response = await fetch(finalUrl, init);
-    if (!response.ok) {
-      const errorBody = await parseBody(response).catch(() => null);
-      const error = new Error(`Request failed with status ${response.status}`);
-      error.status = response.status;
-      error.data = errorBody;
-      throw error;
-    }
-    return await parseBody(response);
-  } finally {
-    if (sendsBody)
-      loading = false;
-  }
-}
-async function get(url, params, headers) {
-  return await request("GET", url, params, headers);
-}
-async function post(url, params, headers) {
-  return await request("POST", url, params, headers);
-}
-async function patch(url, params, headers) {
-  return await request("PATCH", url, params, headers);
-}
-async function put(url, params, headers) {
-  return await request("PUT", url, params, headers);
-}
-async function destroy(url, params, headers) {
-  return await request("DELETE", url, params, headers);
-}
-function setToken(authToken) {
-  token2 = authToken;
-}
-var Fetch = {
-  get,
-  post,
-  patch,
-  put,
-  destroy,
-  baseURL,
-  token: token2,
-  setToken,
-  loading
-};
-// src/utils/function.ts
-function batchInvoke(functions) {
-  functions.forEach((fn) => fn?.());
-}
-function tap(value, callback) {
-  callback(value);
-  return value;
-}
-// src/utils/guards.ts
-function notNullish(v) {
-  return v != null;
-}
-function noNull(v) {
-  return v !== null;
-}
-function notUndefined(v) {
-  return v !== undefined;
-}
-function isTruthy(v) {
-  return Boolean(v);
-}
-// src/utils/lazy.ts
-function lazy(getter) {
-  return {
-    get value() {
-      const value = getter();
-      Object.defineProperty(this, "value", { value });
-      return value;
-    }
-  };
-}
-// src/utils/math.ts
-import {
-  and,
-  logicNot,
-  logicOr,
-  or,
-  useAbs,
-  useAverage,
-  useCeil,
-  useClamp,
-  useFloor,
-  useMax,
-  useMin,
-  usePrecision,
-  useRound,
-  useSum,
-  useTrunc
-} from "@stacksjs/composables";
-var clamp = (n, min, max) => Math.min(max, Math.max(min, n));
-function rand(min, max) {
-  min = Math.ceil(min);
-  max = Math.floor(max);
-  return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-// src/utils/plans.ts
-var saas = {
-  plans: [
-    {
-      productName: "Stacks Hobby",
-      description: "All the Stacks features.",
-      pricing: [
-        {
-          key: "stacks_hobby_early_monthly",
-          price: 1900,
-          interval: "month",
-          currency: "usd"
-        },
-        {
-          key: "stacks_hobby_launch_monthly",
-          price: 2900,
-          interval: "month",
-          currency: "usd"
-        },
-        {
-          key: "stacks_hobby_monthly",
-          price: 3900,
-          interval: "month",
-          currency: "usd"
-        },
-        {
-          key: "stacks_hobby_yearly",
-          price: 37900,
-          interval: "year",
-          currency: "usd"
-        }
-      ],
-      metadata: {
-        createdBy: "admin",
-        version: "1.0.0"
-      }
-    },
-    {
-      productName: "Stacks Pro",
-      description: "All the Stacks features, including being able to invite team members.",
-      pricing: [
-        {
-          key: "stacks_pro_early_monthly",
-          price: 3900,
-          interval: "month",
-          currency: "usd"
-        },
-        {
-          key: "stacks_pro_monthly",
-          price: 5900,
-          interval: "month",
-          currency: "usd"
-        },
-        {
-          key: "stacks_pro_yearly",
-          price: 57900,
-          interval: "year",
-          currency: "usd"
-        },
-        {
-          key: "stacks_pro_early_yearly",
-          price: 39000,
-          interval: "year",
-          currency: "usd"
-        }
-      ],
-      metadata: {
-        createdBy: "admin",
-        version: "1.0.0"
-      }
-    },
-    {
-      productName: "Stacks Lifetime",
-      description: "One-time lifetime access to all Stacks features.",
-      pricing: [
-        {
-          key: "stacks_hobby_early_lifetime",
-          price: 17900,
-          currency: "usd"
-        },
-        {
-          key: "stacks_hobby_launch_lifetime",
-          price: 27900,
-          currency: "usd"
-        },
-        {
-          key: "stacks_hobby_lifetime",
-          price: 47900,
-          currency: "usd"
-        },
-        {
-          key: "stacks_pro_early_lifetime",
-          price: 27900,
-          currency: "usd"
-        },
-        {
-          key: "stacks_pro_launch_lifetime",
-          price: 37900,
-          currency: "usd"
-        },
-        {
-          key: "stacks_pro_lifetime",
-          price: 74900,
-          currency: "usd"
-        }
-      ],
-      metadata: {
-        createdBy: "admin",
-        version: "1.0.0"
-      }
-    }
-  ],
-  webhook: {
-    endpoint: "your-webhook-endpoint",
-    secret: "your-webhook-secret"
-  },
-  currencies: ["usd"],
-  coupons: [],
-  products: [
-    {
-      name: "Stacks Hobby",
-      description: "All the Stacks features.",
-      images: ["image-url"]
-    },
-    {
-      name: "Stacks Pro",
-      description: "All the Stacks features, including team invites.",
-      images: ["image-url"]
-    },
-    {
-      name: "Stacks Lifetime",
-      description: "Lifetime access to Stacks features.",
-      images: ["image-url"]
-    }
-  ]
-};
-// src/utils/promise.ts
-function createSingletonPromise(fn) {
-  let _promise;
-  function wrapper() {
-    if (!_promise)
-      _promise = fn();
-    return _promise;
-  }
-  wrapper.reset = async () => {
-    const _prev = _promise;
-    _promise = undefined;
-    if (_prev)
-      await _prev;
-  };
-  return wrapper;
-}
-function createPromiseLock() {
-  let currentPromise = Promise.resolve();
-  const queue = [];
-  return {
-    async run(fn) {
-      const runTask = async () => {
-        await currentPromise;
-        return fn();
-      };
-      const taskPromise = runTask();
-      queue.push(taskPromise);
-      currentPromise = taskPromise.catch(() => {}).finally(() => {
-        const index = queue.indexOf(taskPromise);
-        if (index > -1)
-          queue.splice(index, 1);
-      });
-      return taskPromise;
-    },
-    async wait() {
-      while (queue.length > 0) {
-        await Promise.all(queue);
-      }
-    },
-    isWaiting() {
-      return queue.length > 0;
-    },
-    clear() {
-      queue.length = 0;
-      currentPromise = Promise.resolve();
-    }
-  };
-}
-function createControlledPromise() {
-  let resolve;
-  let reject;
-  const promise = new Promise((_resolve, _reject) => {
-    resolve = _resolve;
-    reject = _reject;
-  });
-  promise.resolve = resolve;
-  promise.reject = reject;
-  return promise;
-}
-// src/utils/random.ts
-var POOL_SIZE_MULTIPLIER = 128;
-var pool = null;
-var poolOffset = 0;
-var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-function fillPool(bytes) {
-  if (!pool || pool.length < bytes) {
-    pool = new Uint8Array(bytes * POOL_SIZE_MULTIPLIER);
-    globalThis.crypto.getRandomValues(pool);
-    poolOffset = 0;
-  } else if (poolOffset + bytes > pool.length) {
-    globalThis.crypto.getRandomValues(pool);
-    poolOffset = 0;
-  }
-  poolOffset += bytes;
-}
-function randomPool(bytes) {
-  fillPool(bytes |= 0);
-  if (!pool) {
-    throw new Error("Pool is not initialized");
-  }
-  return pool.subarray(poolOffset - bytes, poolOffset);
-}
-function customRandom(alphabet, defaultSize, getRandom) {
-  const mask = (2 << 31 - Math.clz32(alphabet.length - 1 | 1)) - 1;
-  const step = Math.ceil(1.6 * mask * defaultSize / alphabet.length);
-  return (size = defaultSize) => {
-    let id = "";
-    while (true) {
-      const bytes = getRandom(step);
-      let i = step;
-      while (i--) {
-        const byte = bytes[i];
-        if (byte === undefined)
-          continue;
-        id += alphabet[byte & mask] || "";
-        if (id.length >= size)
-          return id;
-      }
-    }
-  };
-}
-function customAlphabet(alphabet, size = 21) {
-  return customRandom(alphabet, size, randomPool);
-}
-function randomNonSecure(size = 21) {
-  let id = "";
-  let i = size | 0;
-  while (i--) {
-    id += urlAlphabet[Math.random() * 64 | 0];
-  }
-  return id;
-}
-function random(size = 21) {
-  fillPool(size |= 0);
-  if (!pool) {
-    return "";
-  }
-  let id = "";
-  for (let i = poolOffset - size;i < poolOffset; i++) {
-    const byte = pool[i];
-    if (byte === undefined)
-      continue;
-    id += urlAlphabet[byte & 63];
-  }
-  return id;
-}
-// src/utils/regex.ts
-import {
-  anyOf,
-  carriageReturn,
-  caseInsensitive,
-  char,
-  charIn,
-  charNotIn,
-  digit,
-  dotAll,
-  exactly,
-  global,
-  letter,
-  linefeed,
-  maybe,
-  multiline,
-  not,
-  oneOrMore,
-  sticky,
-  tab,
-  unicode,
-  whitespace,
-  withIndices,
-  word,
-  wordBoundary,
-  wordChar
-} from "magic-regexp";
-function createRegExp(pattern, options = {}) {
-  return new RegExp(pattern, options.flags);
-}
-// src/utils/retry.ts
-function retry(fn, options = {}) {
-  const { retries = 3, initialDelay = 1000, backoffFactor = 2, jitter = true } = options;
-  return new Promise((resolve, reject) => {
-    let attemptCount = 0;
-    const attempt = async () => {
-      try {
-        resolve(await fn());
-      } catch (err) {
-        if (attemptCount >= retries) {
-          reject(err);
-        } else {
-          const delay = calculateDelay(attemptCount, initialDelay, backoffFactor, jitter);
-          setTimeout(() => attempt(), delay);
-          attemptCount++;
-        }
-      }
-    };
-    attempt();
-  });
-}
-function calculateDelay(attemptCount, initialDelay, backoffFactor, jitter) {
-  let delay = initialDelay * backoffFactor ** attemptCount;
-  if (jitter) {
-    const random2 = Math.random();
-    const jitterValue = delay * 0.3;
-    delay = delay + jitterValue * (random2 - 0.5) * 2;
-  }
-  return delay;
-}
-// src/utils/sleep.ts
-function sleep(ms) {
-  if (ms < 0 || !Number.isInteger(ms)) {
-    throw new Error("sleep() requires a non-negative integer");
-  }
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function wait(ms) {
-  if (ms < 0 || !Number.isInteger(ms)) {
-    throw new Error("wait() requires a non-negative integer");
-  }
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function delay(ms) {
-  if (ms < 0 || !Number.isInteger(ms)) {
-    throw new Error("delay() requires a non-negative integer");
-  }
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function waitUntil(condition, options = {}) {
-  return new Promise((resolve) => {
-    const { interval, timeout } = normalizeOptions(options);
-    if (condition()) {
-      resolve();
-      return;
-    }
-    const check = () => {
-      if (condition()) {
-        resolve();
-      } else {
-        setTimeout(check, interval);
-      }
-    };
-    if (timeout) {
-      setTimeout(resolve, timeout);
-    }
-    check();
-  });
-}
-function normalizeOptions(options) {
-  if (typeof options === "number") {
-    return { interval: options, timeout: 0 };
-  }
-  return {
-    interval: options.interval ?? 100,
-    timeout: options.timeout ?? 0
-  };
-}
-function waitWhile(condition, options = {}) {
-  return new Promise((resolve) => {
-    const { interval = 100, timeout = 0 } = options;
-    if (!condition()) {
-      resolve();
-      return;
-    }
-    const check = () => {
-      if (!condition()) {
-        resolve();
-      } else {
-        setTimeout(check, interval);
-      }
-    };
-    if (timeout) {
-      setTimeout(resolve, timeout);
-    }
-    check();
-  });
-}
-// src/utils/throttle.ts
-function throttle(fn, wait2 = 300) {
-  let inThrottle;
-  let lastFn;
-  let lastTime;
-  return function(...args) {
-    if (!inThrottle) {
-      fn.apply(this, args);
-      lastTime = Date.now();
-      inThrottle = true;
-    } else {
-      clearTimeout(lastFn);
-      lastFn = setTimeout(() => {
-        if (Date.now() - lastTime >= wait2) {
-          fn.apply(this, args);
-          lastTime = Date.now();
-        }
-      }, Math.max(wait2 - (Date.now() - lastTime), 0));
-    }
-  };
-}
-// src/utils/vendors.ts
-import {
-  useDark as useDark2,
-  useDateFormat as useDateFormat3,
-  useFetch as useFetch2,
-  useNow as useNow3,
-  useOnline as useOnline2,
-  usePreferredDark as usePreferredDark2,
-  useStorage as useStorage3,
-  useToggle as useToggle2
-} from "@stacksjs/composables";
-import {
-  useHead,
-  useHead as useHead2,
-  renderHead
-} from "@stacksjs/stx";
-var DECIMAL_UNITS = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
-var BINARY_UNITS = ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"];
-function readableSize(bytes, options = {}) {
-  const {
-    precision = 1,
-    binary = false,
-    space = true,
-    locale = "en-US",
-    minimumFractionDigits = 0,
-    maximumFractionDigits = precision
-  } = options;
-  if (!Number.isFinite(bytes))
-    throw new TypeError(`Expected a finite number, got ${typeof bytes}: ${bytes}`);
-  const isNegative = bytes < 0;
-  const prefix = isNegative ? "-" : "";
-  if (isNegative)
-    bytes = -bytes;
-  if (bytes < 1) {
-    const numberString2 = bytes.toLocaleString(locale, { minimumFractionDigits, maximumFractionDigits });
-    return `${prefix}${numberString2}${space ? " " : ""}B`;
-  }
-  const base = binary ? 1024 : 1000;
-  const units = binary ? BINARY_UNITS : DECIMAL_UNITS;
-  const exponent = Math.min(Math.floor(Math.log(bytes) / Math.log(base)), units.length - 1);
-  const value = bytes / base ** exponent;
-  const numberString = value.toLocaleString(locale, { minimumFractionDigits, maximumFractionDigits });
-  return `${prefix}${numberString}${space ? " " : ""}${units[exponent]}`;
-}
-// src/index.ts
-import {
-  browserQuery as browserQuery2,
-  BrowserQueryBuilder as BrowserQueryBuilder2,
-  BrowserQueryError as BrowserQueryError2,
-  browserAuth as browserAuth3,
-  configureBrowser as configureBrowser3,
-  getBrowserConfig as getBrowserConfig2,
-  createBrowserDb as createBrowserDb2,
-  createBrowserModel as createBrowserModel3,
-  isBrowser as isBrowser2
-} from "bun-query-builder/browser";
-export {
-  wordChar,
-  wordBoundary,
-  word,
-  withIndices,
-  whitespace,
-  waitWhile,
-  waitUntil,
-  wait,
-  useWindowSize,
-  useWindowScroll,
-  useWindowFocus,
-  useWebWorkerFn,
-  useWebWorker,
-  useWebSocket,
-  useWebNotification,
-  useWakeLock,
-  useVibrate,
-  useUrlSearchParams,
-  useTrunc,
-  useTransition,
-  useTitle,
-  useTimestamp,
-  useTimeoutPoll,
-  useTimeoutFn,
-  useTimeout,
-  useTimeAgo,
-  useThrottleFn,
-  useTextSelection,
-  useTextDirection,
-  useSwipe,
-  useSupported,
-  useSum,
-  useStepper,
-  useShare,
-  useSessionStorage,
-  useScrollLock,
-  useScroll,
-  useScreenOrientation,
-  useRound,
-  useRafFn,
-  usePreferredReducedMotion,
-  usePreferredLanguages,
-  usePreferredContrast,
-  usePreferredColorScheme,
-  usePrecision,
-  usePointerSwipe,
-  usePointer,
-  usePermission,
-  usePageLeave,
-  useObjectUrl,
-  useNetwork,
-  useNavigatorLanguage,
-  useMousePressed,
-  useMouseInElement,
-  useMouse,
-  useMounted,
-  useMin,
-  useMemoize,
-  useMediaQuery,
-  useMax,
-  useMagicKeys,
-  useLocalStorage,
-  useKeyModifier,
-  useIntervalFn,
-  useInterval,
-  useInfiniteScroll,
-  useImage,
-  useIdle,
-  useGeolocation,
-  useFullscreen,
-  useFocusWithin,
-  useFocus,
-  useFloor,
-  useFileDialog,
-  useFavicon,
-  useEyeDropper,
-  useEventSource,
-  useEventListener,
-  useEventBus,
-  useElementVisibility,
-  useElementSize,
-  useElementHover,
-  useElementBounding,
-  useDropZone,
-  useDraggable,
-  useDocumentVisibility,
-  useDevicePixelRatio,
-  useDeviceOrientation,
-  useDeviceMotion,
-  useDebounceFn,
-  useCycleList,
-  useCssVar,
-  useCounter,
-  useConfirmDialog,
-  useColorMode,
-  useClipboardItems,
-  useClipboard,
-  useClamp,
-  useCeil,
-  useBrowserLocation,
-  useBroadcastChannel,
-  useBreakpoints,
-  useBattery,
-  useBase64,
-  useAverage,
-  useAuth,
-  useAnimate,
-  useActiveElement,
-  useAbs,
-  unicode,
-  toString,
-  throttle,
-  tap,
-  tab,
-  sticky,
-  sleep,
-  saas,
-  retry,
-  renderHead as renderHeadToString,
-  readableSize,
-  randomNonSecure,
-  random,
-  rand,
-  publishableKey,
-  parse,
-  or,
-  oneOrMore,
-  onStartTyping,
-  onLongPress,
-  onKeyUp,
-  onKeyStroke,
-  onKeyDown,
-  onClickOutside,
-  notUndefined,
-  notNullish,
-  not,
-  noNull,
-  multiline,
-  maybe,
-  loop,
-  logicOr,
-  logicNot,
-  loadPaymentElement,
-  loadCardElement,
-  loadBrowserModels,
-  linefeed,
-  letter,
-  lazy,
-  isTruthy,
-  isBrowser2 as isBrowser,
-  initApi,
-  global,
-  getRelativeTime,
-  getBrowserModelNames,
-  getBrowserModel,
-  getBrowserConfig2 as getBrowserConfig,
-  formatElevation,
-  formatDuration,
-  formatDistance,
-  formatAreaSize,
-  format,
-  fetchData,
-  exactly,
-  dotAll,
-  digit,
-  delay,
-  debounce,
-  customRandom,
-  customAlphabet,
-  createSingletonPromise,
-  createRegExp,
-  createPromiseLock,
-  createPaymentMethod,
-  useHead as createHead,
-  createControlledPromise,
-  createBrowserModel3 as createBrowserModel,
-  createBrowserDb2 as createBrowserDb,
-  confirmPayment,
-  confirmCardSetup,
-  confirmCardPayment,
-  configureBrowser3 as configureBrowser,
-  clamp,
-  charNotIn,
-  charIn,
-  char,
-  caseInsensitive,
-  carriageReturn,
-  calculateDelay,
-  browserQuery2 as browserQuery,
-  browserAuth3 as browserAuth,
-  breakpointsTailwind,
-  breakpointsBootstrapV5,
-  batchInvoke,
-  authGuard,
-  auth,
-  anyOf,
-  and,
-  TransitionPresets,
-  useHead2 as Head,
-  Fetch,
-  BrowserQueryError2 as BrowserQueryError,
-  BrowserQueryBuilder2 as BrowserQueryBuilder
-};