@stacksjs/browser 0.70.57 → 0.70.59

package/dist/index.js

@@ -1,2543 +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";
 
-// ../../../../node_modules/bun-query-builder/dist/src/browser.js
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-function configureBrowser(config) {
-  browserConfig = { ...browserConfig, ...config };
-}
-function getBrowserConfig() {
-  return browserConfig;
-}
-function isBrowser() {
-  return typeof window !== "undefined" && typeof document !== "undefined";
-}
-async function getAuthToken() {
-  if (browserConfig.getToken) {
-    const token = browserConfig.getToken();
-    return token instanceof Promise ? token : token;
-  }
-  if (typeof localStorage !== "undefined") {
-    return localStorage.getItem("auth_token");
-  }
-  return null;
-}
-async function buildHeaders() {
-  const headers = {
-    "Content-Type": "application/json",
-    Accept: "application/json",
-    ...browserConfig.headers
-  };
-  const token = await getAuthToken();
-  if (token) {
-    headers["Authorization"] = `Bearer ${token}`;
-  }
-  return headers;
-}
-async function handleResponse(response) {
-  if (response.status === 401) {
-    browserConfig.onUnauthorized?.();
-    throw new BrowserQueryError("Unauthorized", 401);
-  }
-  if (!response.ok) {
-    const error = await response.json().catch(() => ({ message: "Request failed" }));
-    throw new BrowserQueryError(error.message || `HTTP ${response.status}`, response.status);
-  }
-  const data = await response.json();
-  if (browserConfig.transformResponse) {
-    return browserConfig.transformResponse(data);
-  }
-  return data;
-}
-
-class BrowserQueryBuilder {
-  state;
-  constructor(table) {
-    this.state = {
-      table,
-      wheres: [],
-      orderBy: [],
-      selectColumns: ["*"],
-      withRelations: []
-    };
-  }
-  select(...columns) {
-    this.state.selectColumns = columns;
-    return this;
-  }
-  where(column, operatorOrValue, value) {
-    if (value === undefined) {
-      this.state.wheres.push({
-        column,
-        operator: "=",
-        value: operatorOrValue,
-        boolean: "and"
-      });
-    } else {
-      this.state.wheres.push({
-        column,
-        operator: operatorOrValue,
-        value,
-        boolean: "and"
-      });
-    }
-    return this;
-  }
-  orWhere(column, operatorOrValue, value) {
-    if (value === undefined) {
-      this.state.wheres.push({
-        column,
-        operator: "=",
-        value: operatorOrValue,
-        boolean: "or"
-      });
-    } else {
-      this.state.wheres.push({
-        column,
-        operator: operatorOrValue,
-        value,
-        boolean: "or"
-      });
-    }
-    return this;
-  }
-  andWhere(column, operatorOrValue, value) {
-    return this.where(column, operatorOrValue, value);
-  }
-  whereNull(column) {
-    return this.where(column, "is", null);
-  }
-  whereNotNull(column) {
-    return this.where(column, "is not", null);
-  }
-  whereIn(column, values) {
-    return this.where(column, "in", values);
-  }
-  whereNotIn(column, values) {
-    return this.where(column, "not in", values);
-  }
-  orderBy(column, direction = "asc") {
-    this.state.orderBy.push({ column, direction });
-    return this;
-  }
-  orderByDesc(column) {
-    return this.orderBy(column, "desc");
-  }
-  latest(column = "created_at") {
-    return this.orderBy(column, "desc");
-  }
-  oldest(column = "created_at") {
-    return this.orderBy(column, "asc");
-  }
-  limit(count) {
-    this.state.limitValue = count;
-    return this;
-  }
-  offset(count) {
-    this.state.offsetValue = count;
-    return this;
-  }
-  skip(count) {
-    return this.offset(count);
-  }
-  take(count) {
-    return this.limit(count);
-  }
-  with(...relations) {
-    this.state.withRelations.push(...relations);
-    return this;
-  }
-  buildQueryParams() {
-    const params = new URLSearchParams;
-    for (const where of this.state.wheres) {
-      if (where.operator === "=") {
-        params.append(where.column, String(where.value));
-      } else if (where.operator === "in" && Array.isArray(where.value)) {
-        params.append(`${where.column}[]`, where.value.join(","));
-      } else if (where.operator === "is" && where.value === null) {
-        params.append(`filter[${where.column}][is]`, "null");
-      } else if (where.operator === "is not" && where.value === null) {
-        params.append(`filter[${where.column}][is_not]`, "null");
-      } else {
-        params.append(`filter[${where.column}][${where.operator}]`, String(where.value));
-      }
-    }
-    if (this.state.orderBy.length > 0) {
-      const orderStr = this.state.orderBy.map((o) => `${o.direction === "desc" ? "-" : ""}${o.column}`).join(",");
-      params.append("sort", orderStr);
-    }
-    if (this.state.limitValue !== undefined) {
-      params.append("limit", String(this.state.limitValue));
-    }
-    if (this.state.offsetValue !== undefined) {
-      params.append("offset", String(this.state.offsetValue));
-    }
-    if (this.state.selectColumns.length > 0 && !this.state.selectColumns.includes("*")) {
-      params.append("fields", this.state.selectColumns.join(","));
-    }
-    if (this.state.withRelations.length > 0) {
-      params.append("include", this.state.withRelations.join(","));
-    }
-    return params;
-  }
-  buildUrl(path) {
-    const base = `${browserConfig.baseUrl}/${this.state.table}`;
-    if (path !== undefined) {
-      return `${base}/${path}`;
-    }
-    const params = this.buildQueryParams();
-    const queryString = params.toString();
-    return queryString ? `${base}?${queryString}` : base;
-  }
-  async get() {
-    const url = this.buildUrl();
-    const response = await fetch(url, {
-      method: "GET",
-      headers: await buildHeaders()
-    });
-    const result = await handleResponse(response);
-    return Array.isArray(result) ? result : result.data;
-  }
-  async first() {
-    this.limit(1);
-    const results = await this.get();
-    return results[0] ?? null;
-  }
-  async firstOrFail() {
-    const result = await this.first();
-    if (!result) {
-      throw new BrowserQueryError(`No ${this.state.table} found`, 404);
-    }
-    return result;
-  }
-  async find(id) {
-    const url = this.buildUrl(id);
-    try {
-      const response = await fetch(url, {
-        method: "GET",
-        headers: await buildHeaders()
-      });
-      if (response.status === 404) {
-        return null;
-      }
-      const result = await handleResponse(response);
-      return "data" in result && !Array.isArray(result.data) ? result.data : result;
-    } catch {
-      return null;
-    }
-  }
-  async findOrFail(id) {
-    const result = await this.find(id);
-    if (!result) {
-      throw new BrowserQueryError(`${this.state.table} with id ${id} not found`, 404);
-    }
-    return result;
-  }
-  async count() {
-    const params = this.buildQueryParams();
-    params.append("count", "true");
-    const url = `${browserConfig.baseUrl}/${this.state.table}?${params.toString()}`;
-    const response = await fetch(url, {
-      method: "GET",
-      headers: await buildHeaders()
-    });
-    const result = await handleResponse(response);
-    return result.count;
-  }
-  async exists() {
-    const count = await this.count();
-    return count > 0;
-  }
-  async create(data) {
-    const url = `${browserConfig.baseUrl}/${this.state.table}`;
-    const body = browserConfig.transformRequest ? browserConfig.transformRequest(data) : data;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: await buildHeaders(),
-      body: JSON.stringify(body)
-    });
-    const result = await handleResponse(response);
-    return "data" in result && !Array.isArray(result.data) ? result.data : result;
-  }
-  async insert(data) {
-    return this.create(data);
-  }
-  async update(id, data) {
-    const url = `${browserConfig.baseUrl}/${this.state.table}/${id}`;
-    const body = browserConfig.transformRequest ? browserConfig.transformRequest(data) : data;
-    const response = await fetch(url, {
-      method: "PATCH",
-      headers: await buildHeaders(),
-      body: JSON.stringify(body)
-    });
-    const result = await handleResponse(response);
-    return "data" in result && !Array.isArray(result.data) ? result.data : result;
-  }
-  async delete(id) {
-    const url = `${browserConfig.baseUrl}/${this.state.table}/${id}`;
-    const response = await fetch(url, {
-      method: "DELETE",
-      headers: await buildHeaders()
-    });
-    return response.ok;
-  }
-  async destroy(id) {
-    return this.delete(id);
-  }
-  async paginate(page = 1, perPage = 15) {
-    this.limit(perPage).offset((page - 1) * perPage);
-    const params = this.buildQueryParams();
-    params.append("paginate", "true");
-    const url = `${browserConfig.baseUrl}/${this.state.table}?${params.toString()}`;
-    const response = await fetch(url, {
-      method: "GET",
-      headers: await buildHeaders()
-    });
-    return handleResponse(response);
-  }
-  toState() {
-    return { ...this.state };
-  }
-}
-function browserQuery(table) {
-  return new BrowserQueryBuilder(table);
-}
-function createBrowserDb() {
-  return new Proxy({}, {
-    get: (_target, prop) => {
-      return () => browserQuery(prop);
-    }
-  });
-}
-
-class BrowserModelInstance {
-  _attributes;
-  _definition;
-  constructor(definition, attributes = {}) {
-    this._definition = definition;
-    this._attributes = { ...attributes };
-  }
-  get(key) {
-    return this._attributes[key];
-  }
-  set(key, value) {
-    this._attributes[key] = value;
-  }
-  get attributes() {
-    return { ...this._attributes };
-  }
-  get id() {
-    const pk = this._definition.primaryKey || "id";
-    return this._attributes[pk];
-  }
-  toJSON() {
-    const hidden = new Set;
-    for (const [key, attr] of Object.entries(this._definition.attributes)) {
-      if (attr.hidden)
-        hidden.add(key);
-    }
-    const json = {};
-    for (const [key, value] of Object.entries(this._attributes)) {
-      if (!hidden.has(key))
-        json[key] = value;
-    }
-    return json;
-  }
-}
-
-class BrowserModelQueryBuilder {
-  _definition;
-  _wheres = [];
-  _orderBy = [];
-  _limit;
-  _offset;
-  _select = ["*"];
-  _withRelations = [];
-  constructor(definition) {
-    this._definition = definition;
-  }
-  getTablePath() {
-    return typeof this._definition.traits?.useApi === "object" && this._definition.traits.useApi?.uri || this._definition.table;
-  }
-  where(column, operatorOrValue, value) {
-    if (value === undefined) {
-      this._wheres.push({ column, operator: "=", value: operatorOrValue, boolean: "and" });
-    } else {
-      this._wheres.push({ column, operator: operatorOrValue, value, boolean: "and" });
-    }
-    return this;
-  }
-  orWhere(column, operatorOrValue, value) {
-    if (value === undefined) {
-      this._wheres.push({ column, operator: "=", value: operatorOrValue, boolean: "or" });
-    } else {
-      this._wheres.push({ column, operator: operatorOrValue, value, boolean: "or" });
-    }
-    return this;
-  }
-  whereIn(column, values) {
-    this._wheres.push({ column, operator: "in", value: values, boolean: "and" });
-    return this;
-  }
-  whereNotIn(column, values) {
-    this._wheres.push({ column, operator: "not in", value: values, boolean: "and" });
-    return this;
-  }
-  whereNull(column) {
-    this._wheres.push({ column, operator: "is", value: null, boolean: "and" });
-    return this;
-  }
-  whereNotNull(column) {
-    this._wheres.push({ column, operator: "is not", value: null, boolean: "and" });
-    return this;
-  }
-  whereLike(column, pattern) {
-    this._wheres.push({ column, operator: "like", value: pattern, boolean: "and" });
-    return this;
-  }
-  orderBy(column, direction = "asc") {
-    this._orderBy.push({ column, direction });
-    return this;
-  }
-  orderByDesc(column) {
-    return this.orderBy(column, "desc");
-  }
-  orderByAsc(column) {
-    return this.orderBy(column, "asc");
-  }
-  limit(count) {
-    this._limit = count;
-    return this;
-  }
-  take(count) {
-    return this.limit(count);
-  }
-  offset(count) {
-    this._offset = count;
-    return this;
-  }
-  skip(count) {
-    return this.offset(count);
-  }
-  select(...columns) {
-    this._select = columns;
-    return this;
-  }
-  with(...relations) {
-    this._withRelations.push(...relations);
-    return this;
-  }
-  latest(column = "created_at") {
-    return this.orderByDesc(column);
-  }
-  oldest(column = "created_at") {
-    return this.orderByAsc(column);
-  }
-  buildQueryParams() {
-    const params = new URLSearchParams;
-    for (const where of this._wheres) {
-      if (where.operator === "=") {
-        params.append(where.column, String(where.value));
-      } else if ((where.operator === "in" || where.operator === "not in") && Array.isArray(where.value)) {
-        params.append(`${where.column}[]`, where.value.join(","));
-      } else if (where.operator === "is" && where.value === null) {
-        params.append(`filter[${where.column}][is]`, "null");
-      } else if (where.operator === "is not" && where.value === null) {
-        params.append(`filter[${where.column}][is_not]`, "null");
-      } else {
-        params.append(`filter[${where.column}][${where.operator}]`, String(where.value));
-      }
-    }
-    if (this._orderBy.length > 0) {
-      const orderStr = this._orderBy.map((o) => `${o.direction === "desc" ? "-" : ""}${o.column}`).join(",");
-      params.append("sort", orderStr);
-    }
-    if (this._limit !== undefined)
-      params.append("limit", String(this._limit));
-    if (this._offset !== undefined)
-      params.append("offset", String(this._offset));
-    if (this._select.length > 0 && !this._select.includes("*")) {
-      params.append("fields", this._select.join(","));
-    }
-    if (this._withRelations.length > 0) {
-      params.append("include", this._withRelations.join(","));
-    }
-    return params;
-  }
-  buildUrl(path) {
-    const base = `${browserConfig.baseUrl}/${this.getTablePath()}`;
-    if (path !== undefined)
-      return `${base}/${path}`;
-    const params = this.buildQueryParams();
-    const queryString = params.toString();
-    return queryString ? `${base}?${queryString}` : base;
-  }
-  async get() {
-    const url = this.buildUrl();
-    const response = await fetch(url, {
-      method: "GET",
-      headers: await buildHeaders()
-    });
-    const result = await handleResponse(response);
-    const rows = Array.isArray(result) ? result : result.data;
-    return rows.map((row) => new BrowserModelInstance(this._definition, row));
-  }
-  async first() {
-    this._limit = 1;
-    const results = await this.get();
-    return results[0] ?? null;
-  }
-  async firstOrFail() {
-    const result = await this.first();
-    if (!result)
-      throw new BrowserQueryError(`No ${this._definition.name} found`, 404);
-    return result;
-  }
-  async find(id) {
-    const url = this.buildUrl(id);
-    try {
-      const response = await fetch(url, {
-        method: "GET",
-        headers: await buildHeaders()
-      });
-      if (response.status === 404)
-        return null;
-      const result = await handleResponse(response);
-      const row = "data" in result && !Array.isArray(result.data) ? result.data : result;
-      return new BrowserModelInstance(this._definition, row);
-    } catch {
-      return null;
-    }
-  }
-  async findOrFail(id) {
-    const result = await this.find(id);
-    if (!result)
-      throw new BrowserQueryError(`${this._definition.name} with id ${id} not found`, 404);
-    return result;
-  }
-  async count() {
-    const params = this.buildQueryParams();
-    params.append("count", "true");
-    const url = `${browserConfig.baseUrl}/${this.getTablePath()}?${params.toString()}`;
-    const response = await fetch(url, {
-      method: "GET",
-      headers: await buildHeaders()
-    });
-    const result = await handleResponse(response);
-    return result.count;
-  }
-  async exists() {
-    const count = await this.count();
-    return count > 0;
-  }
-  async pluck(column) {
-    this._select = [column];
-    const results = await this.get();
-    return results.map((r) => r.get(column));
-  }
-  async paginate(page = 1, perPage = 15) {
-    this._limit = perPage;
-    this._offset = (page - 1) * perPage;
-    const params = this.buildQueryParams();
-    params.append("paginate", "true");
-    const url = `${browserConfig.baseUrl}/${this.getTablePath()}?${params.toString()}`;
-    const response = await fetch(url, {
-      method: "GET",
-      headers: await buildHeaders()
-    });
-    const result = await handleResponse(response);
-    return {
-      ...result,
-      data: result.data.map((row) => new BrowserModelInstance(this._definition, row))
-    };
-  }
-}
-function createBrowserModel(definition) {
-  const model = {
-    query: () => new BrowserModelQueryBuilder(definition),
-    where(column, operatorOrValue, value) {
-      return new BrowserModelQueryBuilder(definition).where(column, operatorOrValue, value);
-    },
-    orWhere(column, operatorOrValue, value) {
-      return new BrowserModelQueryBuilder(definition).orWhere(column, operatorOrValue, value);
-    },
-    whereIn(column, values) {
-      return new BrowserModelQueryBuilder(definition).whereIn(column, values);
-    },
-    whereNotIn(column, values) {
-      return new BrowserModelQueryBuilder(definition).whereNotIn(column, values);
-    },
-    whereNull(column) {
-      return new BrowserModelQueryBuilder(definition).whereNull(column);
-    },
-    whereNotNull(column) {
-      return new BrowserModelQueryBuilder(definition).whereNotNull(column);
-    },
-    whereLike(column, pattern) {
-      return new BrowserModelQueryBuilder(definition).whereLike(column, pattern);
-    },
-    orderBy(column, direction = "asc") {
-      return new BrowserModelQueryBuilder(definition).orderBy(column, direction);
-    },
-    orderByDesc(column) {
-      return new BrowserModelQueryBuilder(definition).orderByDesc(column);
-    },
-    select(...columns) {
-      return new BrowserModelQueryBuilder(definition).select(...columns);
-    },
-    limit: (count) => new BrowserModelQueryBuilder(definition).limit(count),
-    take: (count) => new BrowserModelQueryBuilder(definition).take(count),
-    skip: (count) => new BrowserModelQueryBuilder(definition).skip(count),
-    latest: (column = "created_at") => new BrowserModelQueryBuilder(definition).latest(column),
-    oldest: (column = "created_at") => new BrowserModelQueryBuilder(definition).oldest(column),
-    async find(id) {
-      return new BrowserModelQueryBuilder(definition).find(id);
-    },
-    async findOrFail(id) {
-      return new BrowserModelQueryBuilder(definition).findOrFail(id);
-    },
-    async all() {
-      return new BrowserModelQueryBuilder(definition).get();
-    },
-    async first() {
-      return new BrowserModelQueryBuilder(definition).first();
-    },
-    async firstOrFail() {
-      return new BrowserModelQueryBuilder(definition).firstOrFail();
-    },
-    async count() {
-      return new BrowserModelQueryBuilder(definition).count();
-    },
-    async exists() {
-      return new BrowserModelQueryBuilder(definition).exists();
-    },
-    async paginate(page, perPage) {
-      return new BrowserModelQueryBuilder(definition).paginate(page, perPage);
-    },
-    async pluck(column) {
-      return new BrowserModelQueryBuilder(definition).pluck(column);
-    },
-    async create(data) {
-      const tablePath = typeof definition.traits?.useApi === "object" && definition.traits.useApi?.uri || definition.table;
-      const url = `${browserConfig.baseUrl}/${tablePath}`;
-      const body = browserConfig.transformRequest ? browserConfig.transformRequest(data) : data;
-      const response = await fetch(url, {
-        method: "POST",
-        headers: await buildHeaders(),
-        body: JSON.stringify(body)
-      });
-      const result = await handleResponse(response);
-      const row = "data" in result && !Array.isArray(result.data) ? result.data : result;
-      return new BrowserModelInstance(definition, row);
-    },
-    async update(id, data) {
-      const tablePath = typeof definition.traits?.useApi === "object" && definition.traits.useApi?.uri || definition.table;
-      const url = `${browserConfig.baseUrl}/${tablePath}/${id}`;
-      const body = browserConfig.transformRequest ? browserConfig.transformRequest(data) : data;
-      const response = await fetch(url, {
-        method: "PATCH",
-        headers: await buildHeaders(),
-        body: JSON.stringify(body)
-      });
-      const result = await handleResponse(response);
-      const row = "data" in result && !Array.isArray(result.data) ? result.data : result;
-      return new BrowserModelInstance(definition, row);
-    },
-    async delete(id) {
-      const tablePath = typeof definition.traits?.useApi === "object" && definition.traits.useApi?.uri || definition.table;
-      const url = `${browserConfig.baseUrl}/${tablePath}/${id}`;
-      const response = await fetch(url, {
-        method: "DELETE",
-        headers: await buildHeaders()
-      });
-      return response.ok;
-    },
-    async destroy(id) {
-      return this.delete(id);
-    },
-    getDefinition: () => definition,
-    getTable: () => definition.table
-  };
-  return new Proxy(model, {
-    get(target, prop) {
-      if (typeof prop === "string" && prop.startsWith("where") && prop.length > 5) {
-        const columnPascal = prop.slice(5);
-        const column = columnPascal.charAt(0).toLowerCase() + columnPascal.slice(1);
-        if (column in definition.attributes || column === "id" || column === definition.primaryKey) {
-          return (value) => new BrowserModelQueryBuilder(definition).where(column, value);
-        }
-      }
-      return Reflect.get(target, prop);
-    }
-  });
-}
-var browserConfig;
-var BrowserQueryError;
-var browserAuth;
-var browser_default;
-var init_browser = __esm(() => {
-  browserConfig = {
-    baseUrl: ""
-  };
-  BrowserQueryError = class BrowserQueryError2 extends Error {
-    status;
-    constructor(message, status) {
-      super(message);
-      this.name = "BrowserQueryError";
-      this.status = status;
-    }
-  };
-  browserAuth = {
-    async login(credentials) {
-      const response = await fetch(`${browserConfig.baseUrl}/login`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "application/json",
-          ...browserConfig.headers
-        },
-        body: JSON.stringify(credentials)
-      });
-      if (!response.ok) {
-        const error = await response.json().catch(() => ({ message: "Login failed" }));
-        throw new BrowserQueryError(error.message || "Login failed", response.status);
-      }
-      const rawData = await response.json();
-      const data = rawData.data || rawData;
-      if (typeof localStorage !== "undefined" && data.token) {
-        localStorage.setItem("auth_token", data.token);
-      }
-      return data;
-    },
-    async register(data) {
-      const response = await fetch(`${browserConfig.baseUrl}/register`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "application/json",
-          ...browserConfig.headers
-        },
-        body: JSON.stringify(data)
-      });
-      if (!response.ok) {
-        const error = await response.json().catch(() => ({ message: "Registration failed" }));
-        throw new BrowserQueryError(error.message || "Registration failed", response.status);
-      }
-      const rawResult = await response.json();
-      const result = rawResult.data || rawResult;
-      if (typeof localStorage !== "undefined" && result.token) {
-        localStorage.setItem("auth_token", result.token);
-      }
-      return result;
-    },
-    async logout() {
-      const token = await getAuthToken();
-      if (token) {
-        try {
-          await fetch(`${browserConfig.baseUrl}/logout`, {
-            method: "POST",
-            headers: await buildHeaders()
-          });
-        } catch {}
-      }
-      if (typeof localStorage !== "undefined") {
-        localStorage.removeItem("auth_token");
-      }
-    },
-    async user() {
-      const token = await getAuthToken();
-      if (!token)
-        return null;
-      try {
-        const response = await fetch(`${browserConfig.baseUrl}/user`, {
-          method: "GET",
-          headers: await buildHeaders()
-        });
-        if (response.status === 401) {
-          browserConfig.onUnauthorized?.();
-          return null;
-        }
-        if (!response.ok)
-          return null;
-        const data = await response.json();
-        return data.user || data;
-      } catch {
-        return null;
-      }
-    },
-    async check() {
-      const user = await this.user();
-      return user !== null;
-    },
-    getToken: getAuthToken
-  };
-  browser_default = browserQuery;
-});
-init_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
-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
-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`;
-  configureBrowser({
-    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,
-    configureBrowser,
-    getBrowserConfig,
-    createBrowserDb,
-    createBrowserModel,
-    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));
-}
-// ../../../../pantry/@stripe/stripe-js/dist/index.mjs
-function _typeof(obj) {
-  "@babel/helpers - typeof";
-  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-    _typeof = function(obj2) {
-      return typeof obj2;
-    };
-  } else {
-    _typeof = function(obj2) {
-      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
-    };
-  }
-  return _typeof(obj);
-}
-var RELEASE_TRAIN = "clover";
-var runtimeVersionToUrlVersion = function runtimeVersionToUrlVersion2(version) {
-  return version === 3 ? "v3" : version;
-};
-var ORIGIN = "https://js.stripe.com";
-var STRIPE_JS_URL = "".concat(ORIGIN, "/").concat(RELEASE_TRAIN, "/stripe.js");
-var V3_URL_REGEX = /^https:\/\/js\.stripe\.com\/v3\/?(\?.*)?$/;
-var STRIPE_JS_URL_REGEX = /^https:\/\/js\.stripe\.com\/(v3|[a-z]+)\/stripe\.js(\?.*)?$/;
-var EXISTING_SCRIPT_MESSAGE = "loadStripe.setLoadParameters was called but an existing Stripe.js script already exists in the document; existing script parameters will be used";
-var isStripeJSURL = function isStripeJSURL2(url) {
-  return V3_URL_REGEX.test(url) || STRIPE_JS_URL_REGEX.test(url);
-};
-var findScript = function findScript2() {
-  var scripts = document.querySelectorAll('script[src^="'.concat(ORIGIN, '"]'));
-  for (var i = 0;i < scripts.length; i++) {
-    var script = scripts[i];
-    if (!isStripeJSURL(script.src)) {
-      continue;
-    }
-    return script;
-  }
-  return null;
-};
-var injectScript = function injectScript2(params) {
-  var queryString = params && !params.advancedFraudSignals ? "?advancedFraudSignals=false" : "";
-  var script = document.createElement("script");
-  script.src = "".concat(STRIPE_JS_URL).concat(queryString);
-  var headOrBody = document.head || document.body;
-  if (!headOrBody) {
-    throw new Error("Expected document.body not to be null. Stripe.js requires a <body> element.");
-  }
-  headOrBody.appendChild(script);
-  return script;
-};
-var registerWrapper = function registerWrapper2(stripe, startTime) {
-  if (!stripe || !stripe._registerWrapper) {
-    return;
-  }
-  stripe._registerWrapper({
-    name: "stripe-js",
-    version: "8.11.0",
-    startTime
-  });
-};
-var stripePromise$1 = null;
-var onErrorListener = null;
-var onLoadListener = null;
-var onError = function onError2(reject) {
-  return function(cause) {
-    reject(new Error("Failed to load Stripe.js", {
-      cause
-    }));
-  };
-};
-var onLoad = function onLoad2(resolve, reject) {
-  return function() {
-    if (window.Stripe) {
-      resolve(window.Stripe);
-    } else {
-      reject(new Error("Stripe.js not available"));
-    }
-  };
-};
-var loadScript = function loadScript2(params) {
-  if (stripePromise$1 !== null) {
-    return stripePromise$1;
-  }
-  stripePromise$1 = new Promise(function(resolve, reject) {
-    if (typeof window === "undefined" || typeof document === "undefined") {
-      resolve(null);
-      return;
-    }
-    if (window.Stripe && params) {
-      console.warn(EXISTING_SCRIPT_MESSAGE);
-    }
-    if (window.Stripe) {
-      resolve(window.Stripe);
-      return;
-    }
-    try {
-      var script = findScript();
-      if (script && params) {
-        console.warn(EXISTING_SCRIPT_MESSAGE);
-      } else if (!script) {
-        script = injectScript(params);
-      } else if (script && onLoadListener !== null && onErrorListener !== null) {
-        var _script$parentNode;
-        script.removeEventListener("load", onLoadListener);
-        script.removeEventListener("error", onErrorListener);
-        (_script$parentNode = script.parentNode) === null || _script$parentNode === undefined || _script$parentNode.removeChild(script);
-        script = injectScript(params);
-      }
-      onLoadListener = onLoad(resolve, reject);
-      onErrorListener = onError(reject);
-      script.addEventListener("load", onLoadListener);
-      script.addEventListener("error", onErrorListener);
-    } catch (error) {
-      reject(error);
-      return;
-    }
-  });
-  return stripePromise$1["catch"](function(error) {
-    stripePromise$1 = null;
-    return Promise.reject(error);
-  });
-};
-var initStripe = function initStripe2(maybeStripe, args, startTime) {
-  if (maybeStripe === null) {
-    return null;
-  }
-  var pk = args[0];
-  if (typeof pk !== "string") {
-    throw new Error("Expected publishable key to be of type string, got type ".concat(_typeof(pk), " instead."));
-  }
-  var isTestKey = pk.match(/^pk_test/);
-  var version = runtimeVersionToUrlVersion(maybeStripe.version);
-  var expectedVersion = RELEASE_TRAIN;
-  if (isTestKey && version !== expectedVersion) {
-    console.warn("Stripe.js@".concat(version, " was loaded on the page, but @stripe/stripe-js@").concat("8.11.0", " expected Stripe.js@").concat(expectedVersion, ". This may result in unexpected behavior. For more information, see https://docs.stripe.com/sdks/stripejs-versioning"));
-  }
-  var stripe = maybeStripe.apply(undefined, args);
-  registerWrapper(stripe, startTime);
-  return stripe;
-};
-var stripePromise;
-var loadCalled = false;
-var getStripePromise = function getStripePromise2() {
-  if (stripePromise) {
-    return stripePromise;
-  }
-  stripePromise = loadScript(null)["catch"](function(error) {
-    stripePromise = null;
-    return Promise.reject(error);
-  });
-  return stripePromise;
-};
-Promise.resolve().then(function() {
-  return getStripePromise();
-})["catch"](function(error) {
-  if (!loadCalled) {
-    console.warn(error);
-  }
-});
-var loadStripe = function loadStripe2() {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0;_key < _len; _key++) {
-    args[_key] = arguments[_key];
-  }
-  loadCalled = true;
-  var startTime = Date.now();
-  return getStripePromise().then(function(maybeStripe) {
-    return initStripe(maybeStripe, args, startTime);
-  });
-};
-// src/utils/billable.ts
-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;
-}
-// ../../../../pantry/magic-regexp/dist/flags-BP1_fHjc.mjs
-var NO_WRAP_RE = /^(?:\(.*\)|\\?.)$/;
-function wrap(s) {
-  const v = s.toString();
-  return NO_WRAP_RE.test(v) ? v : `(?:${v})`;
-}
-var GROUPED_AS_REPLACE_RE = /^(?:\(\?:(.+)\)|(.+))$/;
-var GROUPED_REPLACE_RE = /^(?:\(\?:(.+)\)([?+*]|\{[\d,]+\})?|(.+))$/;
-function createInput(s) {
-  const groupedAsFn = (key) => createInput(`(?<${key}>${`${s}`.replace(GROUPED_AS_REPLACE_RE, "$1$2")})`);
-  return {
-    toString: () => s.toString(),
-    and: Object.assign((...inputs) => createInput(`${s}${exactly(...inputs)}`), { referenceTo: (groupName) => createInput(`${s}\\k<${groupName}>`) }),
-    or: (...inputs) => createInput(`(?:${s}|${inputs.map((v) => exactly(v)).join("|")})`),
-    after: (...input) => createInput(`(?<=${exactly(...input)})${s}`),
-    before: (...input) => createInput(`${s}(?=${exactly(...input)})`),
-    notAfter: (...input) => createInput(`(?<!${exactly(...input)})${s}`),
-    notBefore: (...input) => createInput(`${s}(?!${exactly(...input)})`),
-    times: Object.assign((number) => createInput(`${wrap(s)}{${number}}`), {
-      any: () => createInput(`${wrap(s)}*`),
-      atLeast: (min) => createInput(`${wrap(s)}{${min},}`),
-      atMost: (max) => createInput(`${wrap(s)}{0,${max}}`),
-      between: (min, max) => createInput(`${wrap(s)}{${min},${max}}`)
-    }),
-    optionally: () => createInput(`${wrap(s)}?`),
-    as: groupedAsFn,
-    groupedAs: groupedAsFn,
-    grouped: () => createInput(`${s}`.replace(GROUPED_REPLACE_RE, "($1$3)$2")),
-    at: {
-      lineStart: () => createInput(`^${s}`),
-      lineEnd: () => createInput(`${s}$`)
-    }
-  };
-}
-var ESCAPE_REPLACE_RE = /[.*+?^${}()|[\]\\/]/g;
-function createCharInput(raw) {
-  const input = createInput(`[${raw}]`);
-  const from = (charFrom, charTo) => createCharInput(`${raw}${escapeCharInput(charFrom)}-${escapeCharInput(charTo)}`);
-  const orChar = Object.assign((chars) => createCharInput(`${raw}${escapeCharInput(chars)}`), { from });
-  return Object.assign(input, {
-    orChar,
-    from
-  });
-}
-function escapeCharInput(raw) {
-  return raw.replace(/[-\\^\]]/g, "\\$&");
-}
-var charIn = Object.assign((chars) => {
-  return createCharInput(escapeCharInput(chars));
-}, createCharInput(""));
-var charNotIn = Object.assign((chars) => {
-  return createCharInput(`^${escapeCharInput(chars)}`);
-}, createCharInput("^"));
-function anyOf(...inputs) {
-  return createInput(`(?:${inputs.map((a) => exactly(a)).join("|")})`);
-}
-var char = createInput(".");
-var word = createInput("\\b\\w+\\b");
-var wordChar = createInput("\\w");
-var wordBoundary = createInput("\\b");
-var digit = createInput("\\d");
-var whitespace = createInput("\\s");
-var letter = Object.assign(createInput("[a-zA-Z]"), {
-  lowercase: createInput("[a-z]"),
-  uppercase: createInput("[A-Z]")
-});
-var tab = createInput("\\t");
-var linefeed = createInput("\\n");
-var carriageReturn = createInput("\\r");
-var not = {
-  word: createInput("\\W+"),
-  wordChar: createInput("\\W"),
-  wordBoundary: createInput("\\B"),
-  digit: createInput("\\D"),
-  whitespace: createInput("\\S"),
-  letter: Object.assign(createInput("[^a-zA-Z]"), {
-    lowercase: createInput("[^a-z]"),
-    uppercase: createInput("[^A-Z]")
-  }),
-  tab: createInput("[^\\t]"),
-  linefeed: createInput("[^\\n]"),
-  carriageReturn: createInput("[^\\r]")
-};
-function maybe(...inputs) {
-  return createInput(`${wrap(exactly(...inputs))}?`);
-}
-function exactly(...inputs) {
-  return createInput(inputs.map((input) => typeof input === "string" ? input.replace(ESCAPE_REPLACE_RE, "\\$&") : input).join(""));
-}
-function oneOrMore(...inputs) {
-  return createInput(`${wrap(exactly(...inputs))}+`);
-}
-var withIndices = "d";
-var caseInsensitive = "i";
-var global = "g";
-var multiline = "m";
-var dotAll = "s";
-var unicode = "u";
-var sticky = "y";
-
-// src/utils/regex.ts
-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]}`;
-}
+export * from "./composables";
+export * from "./utils";
+export * from "./model-loader";
 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,
-  isBrowser,
-  initApi,
-  global,
-  getRelativeTime,
-  getBrowserModelNames,
-  getBrowserModel,
-  getBrowserConfig,
-  formatElevation,
-  formatDuration,
-  formatDistance,
-  formatAreaSize,
-  format,
-  fetchData,
-  exactly,
-  dotAll,
-  digit,
-  delay,
-  debounce,
-  customRandom,
-  customAlphabet,
-  createSingletonPromise,
-  createRegExp,
-  createPromiseLock,
-  createPaymentMethod,
-  useHead as createHead,
-  createControlledPromise,
-  createBrowserModel,
-  createBrowserDb,
-  confirmPayment,
-  confirmCardSetup,
-  confirmCardPayment,
-  configureBrowser,
-  clamp,
-  charNotIn,
-  charIn,
-  char,
-  caseInsensitive,
-  carriageReturn,
-  calculateDelay,
   browserQuery,
-  browserAuth,
-  breakpointsTailwind,
-  breakpointsBootstrapV5,
-  batchInvoke,
-  authGuard,
-  auth,
-  anyOf,
-  and,
-  TransitionPresets,
-  useHead2 as Head,
-  Fetch,
+  BrowserQueryBuilder,
   BrowserQueryError,
-  BrowserQueryBuilder
-};
+  browserAuth,
+  configureBrowser,
+  getBrowserConfig,
+  createBrowserDb,
+  createBrowserModel,
+  isBrowser
+} from "bun-query-builder/browser";