Init

node_modules/@supabase/supabase-js/dist/cors.cjs

@@ -0,0 +1,90 @@
+const require_index = require('./index.cjs');
+
+//#region src/cors.ts
+/**
+* Canonical CORS configuration for Supabase Edge Functions
+*
+* This module exports CORS headers that stay synchronized with the Supabase SDK.
+* When new headers are added to the SDK, they are automatically included here,
+* preventing CORS errors in Edge Functions.
+*
+* @example Basic usage
+* ```typescript
+* import { corsHeaders } from '@supabase/supabase-js/cors'
+*
+* Deno.serve(async (req) => {
+*   if (req.method === 'OPTIONS') {
+*     return new Response('ok', { headers: corsHeaders })
+*   }
+*
+*   return new Response(
+*     JSON.stringify({ data: 'Hello' }),
+*     { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
+*   )
+* })
+* ```
+*
+* @module cors
+*/
+/**
+* All custom headers sent by the Supabase SDK.
+* These headers need to be included in CORS configuration to prevent preflight failures.
+*
+* Headers:
+* - authorization: Bearer token for authentication
+* - x-client-info: Library version information
+* - apikey: Project API key
+* - content-type: Standard HTTP content type
+* - x-retry-count: Retry attempt number sent by postgrest-js on retried requests
+*/
+const SUPABASE_HEADERS = [
+	"authorization",
+	"x-client-info",
+	"apikey",
+	"content-type",
+	"x-retry-count"
+].join(", ");
+/**
+* All HTTP methods used by the Supabase SDK
+*/
+const SUPABASE_METHODS = [
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE",
+	"OPTIONS"
+].join(", ");
+/**
+* Default CORS headers for Supabase Edge Functions.
+*
+* Includes all headers sent by Supabase client libraries and allows all standard HTTP methods.
+* Use this for simple CORS configurations with wildcard origin.
+*
+* @example Basic usage
+* ```typescript
+* import { corsHeaders } from '@supabase/supabase-js/cors'
+*
+* Deno.serve(async (req) => {
+*   if (req.method === 'OPTIONS') {
+*     return new Response('ok', { headers: corsHeaders })
+*   }
+*
+*   return new Response(
+*     JSON.stringify({ data: 'Hello' }),
+*     { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
+*   )
+* })
+* ```
+*
+* @category Edge Functions
+*/
+const corsHeaders = {
+	"Access-Control-Allow-Origin": "*",
+	"Access-Control-Allow-Headers": SUPABASE_HEADERS,
+	"Access-Control-Allow-Methods": SUPABASE_METHODS
+};
+
+//#endregion
+exports.corsHeaders = corsHeaders;
+//# sourceMappingURL=cors.cjs.map

node_modules/@supabase/supabase-js/dist/cors.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cors.cjs","names":["corsHeaders: CorsHeaders"],"sources":["../src/cors.ts"],"sourcesContent":["/**\n * Canonical CORS configuration for Supabase Edge Functions\n *\n * This module exports CORS headers that stay synchronized with the Supabase SDK.\n * When new headers are added to the SDK, they are automatically included here,\n * preventing CORS errors in Edge Functions.\n *\n * @example Basic usage\n * ```typescript\n * import { corsHeaders } from '@supabase/supabase-js/cors'\n *\n * Deno.serve(async (req) => {\n *   if (req.method === 'OPTIONS') {\n *     return new Response('ok', { headers: corsHeaders })\n *   }\n *\n *   return new Response(\n *     JSON.stringify({ data: 'Hello' }),\n *     { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }\n *   )\n * })\n * ```\n *\n * @module cors\n */\n\n/**\n * All custom headers sent by the Supabase SDK.\n * These headers need to be included in CORS configuration to prevent preflight failures.\n *\n * Headers:\n * - authorization: Bearer token for authentication\n * - x-client-info: Library version information\n * - apikey: Project API key\n * - content-type: Standard HTTP content type\n * - x-retry-count: Retry attempt number sent by postgrest-js on retried requests\n */\nconst SUPABASE_HEADERS = [\n  'authorization',\n  'x-client-info',\n  'apikey',\n  'content-type',\n  'x-retry-count',\n].join(', ')\n\n/**\n * All HTTP methods used by the Supabase SDK\n */\nconst SUPABASE_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'].join(', ')\n\n/**\n * Type representing CORS headers as a record of header names to values\n */\nexport type CorsHeaders = Record<string, string>\n\n/**\n * Default CORS headers for Supabase Edge Functions.\n *\n * Includes all headers sent by Supabase client libraries and allows all standard HTTP methods.\n * Use this for simple CORS configurations with wildcard origin.\n *\n * @example Basic usage\n * ```typescript\n * import { corsHeaders } from '@supabase/supabase-js/cors'\n *\n * Deno.serve(async (req) => {\n *   if (req.method === 'OPTIONS') {\n *     return new Response('ok', { headers: corsHeaders })\n *   }\n *\n *   return new Response(\n *     JSON.stringify({ data: 'Hello' }),\n *     { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }\n *   )\n * })\n * ```\n *\n * @category Edge Functions\n */\nexport const corsHeaders: CorsHeaders = {\n  'Access-Control-Allow-Origin': '*',\n  'Access-Control-Allow-Headers': SUPABASE_HEADERS,\n  'Access-Control-Allow-Methods': SUPABASE_METHODS,\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,MAAM,mBAAmB;CACvB;CACA;CACA;CACA;CACA;CACD,CAAC,KAAK,KAAK;;;;AAKZ,MAAM,mBAAmB;CAAC;CAAO;CAAQ;CAAO;CAAS;CAAU;CAAU,CAAC,KAAK,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;AA+BxF,MAAaA,cAA2B;CACtC,+BAA+B;CAC/B,gCAAgC;CAChC,gCAAgC;CACjC"}

node_modules/@supabase/supabase-js/dist/cors.d.cts

@@ -0,0 +1,58 @@
+//#region src/cors.d.ts
+/**
+ * Canonical CORS configuration for Supabase Edge Functions
+ *
+ * This module exports CORS headers that stay synchronized with the Supabase SDK.
+ * When new headers are added to the SDK, they are automatically included here,
+ * preventing CORS errors in Edge Functions.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { corsHeaders } from '@supabase/supabase-js/cors'
+ *
+ * Deno.serve(async (req) => {
+ *   if (req.method === 'OPTIONS') {
+ *     return new Response('ok', { headers: corsHeaders })
+ *   }
+ *
+ *   return new Response(
+ *     JSON.stringify({ data: 'Hello' }),
+ *     { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
+ *   )
+ * })
+ * ```
+ *
+ * @module cors
+ */
+/**
+ * Type representing CORS headers as a record of header names to values
+ */
+type CorsHeaders = Record<string, string>;
+/**
+ * Default CORS headers for Supabase Edge Functions.
+ *
+ * Includes all headers sent by Supabase client libraries and allows all standard HTTP methods.
+ * Use this for simple CORS configurations with wildcard origin.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { corsHeaders } from '@supabase/supabase-js/cors'
+ *
+ * Deno.serve(async (req) => {
+ *   if (req.method === 'OPTIONS') {
+ *     return new Response('ok', { headers: corsHeaders })
+ *   }
+ *
+ *   return new Response(
+ *     JSON.stringify({ data: 'Hello' }),
+ *     { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
+ *   )
+ * })
+ * ```
+ *
+ * @category Edge Functions
+ */
+declare const corsHeaders: CorsHeaders;
+//#endregion
+export { CorsHeaders, corsHeaders };
+//# sourceMappingURL=cors.d.cts.map

node_modules/@supabase/supabase-js/dist/cors.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cors.d.cts","names":[],"sources":["../src/cors.ts"],"sourcesContent":[],"mappings":";;AAqDA;AA0BA;;;;;;;;;;;;;;;;;;;;;;;;;;KA1BY,WAAA,GAAc;;;;;;;;;;;;;;;;;;;;;;;;;cA0Bb,aAAa"}

node_modules/@supabase/supabase-js/dist/cors.d.mts

@@ -0,0 +1,58 @@
+//#region src/cors.d.ts
+/**
+ * Canonical CORS configuration for Supabase Edge Functions
+ *
+ * This module exports CORS headers that stay synchronized with the Supabase SDK.
+ * When new headers are added to the SDK, they are automatically included here,
+ * preventing CORS errors in Edge Functions.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { corsHeaders } from '@supabase/supabase-js/cors'
+ *
+ * Deno.serve(async (req) => {
+ *   if (req.method === 'OPTIONS') {
+ *     return new Response('ok', { headers: corsHeaders })
+ *   }
+ *
+ *   return new Response(
+ *     JSON.stringify({ data: 'Hello' }),
+ *     { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
+ *   )
+ * })
+ * ```
+ *
+ * @module cors
+ */
+/**
+ * Type representing CORS headers as a record of header names to values
+ */
+type CorsHeaders = Record<string, string>;
+/**
+ * Default CORS headers for Supabase Edge Functions.
+ *
+ * Includes all headers sent by Supabase client libraries and allows all standard HTTP methods.
+ * Use this for simple CORS configurations with wildcard origin.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { corsHeaders } from '@supabase/supabase-js/cors'
+ *
+ * Deno.serve(async (req) => {
+ *   if (req.method === 'OPTIONS') {
+ *     return new Response('ok', { headers: corsHeaders })
+ *   }
+ *
+ *   return new Response(
+ *     JSON.stringify({ data: 'Hello' }),
+ *     { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
+ *   )
+ * })
+ * ```
+ *
+ * @category Edge Functions
+ */
+declare const corsHeaders: CorsHeaders;
+//#endregion
+export { CorsHeaders, corsHeaders };
+//# sourceMappingURL=cors.d.mts.map

node_modules/@supabase/supabase-js/dist/cors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cors.d.mts","names":[],"sources":["../src/cors.ts"],"sourcesContent":[],"mappings":";;AAqDA;AA0BA;;;;;;;;;;;;;;;;;;;;;;;;;;KA1BY,WAAA,GAAc;;;;;;;;;;;;;;;;;;;;;;;;;cA0Bb,aAAa"}

node_modules/@supabase/supabase-js/dist/cors.mjs

@@ -0,0 +1,88 @@
+//#region src/cors.ts
+/**
+* Canonical CORS configuration for Supabase Edge Functions
+*
+* This module exports CORS headers that stay synchronized with the Supabase SDK.
+* When new headers are added to the SDK, they are automatically included here,
+* preventing CORS errors in Edge Functions.
+*
+* @example Basic usage
+* ```typescript
+* import { corsHeaders } from '@supabase/supabase-js/cors'
+*
+* Deno.serve(async (req) => {
+*   if (req.method === 'OPTIONS') {
+*     return new Response('ok', { headers: corsHeaders })
+*   }
+*
+*   return new Response(
+*     JSON.stringify({ data: 'Hello' }),
+*     { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
+*   )
+* })
+* ```
+*
+* @module cors
+*/
+/**
+* All custom headers sent by the Supabase SDK.
+* These headers need to be included in CORS configuration to prevent preflight failures.
+*
+* Headers:
+* - authorization: Bearer token for authentication
+* - x-client-info: Library version information
+* - apikey: Project API key
+* - content-type: Standard HTTP content type
+* - x-retry-count: Retry attempt number sent by postgrest-js on retried requests
+*/
+const SUPABASE_HEADERS = [
+	"authorization",
+	"x-client-info",
+	"apikey",
+	"content-type",
+	"x-retry-count"
+].join(", ");
+/**
+* All HTTP methods used by the Supabase SDK
+*/
+const SUPABASE_METHODS = [
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE",
+	"OPTIONS"
+].join(", ");
+/**
+* Default CORS headers for Supabase Edge Functions.
+*
+* Includes all headers sent by Supabase client libraries and allows all standard HTTP methods.
+* Use this for simple CORS configurations with wildcard origin.
+*
+* @example Basic usage
+* ```typescript
+* import { corsHeaders } from '@supabase/supabase-js/cors'
+*
+* Deno.serve(async (req) => {
+*   if (req.method === 'OPTIONS') {
+*     return new Response('ok', { headers: corsHeaders })
+*   }
+*
+*   return new Response(
+*     JSON.stringify({ data: 'Hello' }),
+*     { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
+*   )
+* })
+* ```
+*
+* @category Edge Functions
+*/
+const corsHeaders = {
+	"Access-Control-Allow-Origin": "*",
+	"Access-Control-Allow-Headers": SUPABASE_HEADERS,
+	"Access-Control-Allow-Methods": SUPABASE_METHODS
+};
+
+//#endregion
+export { corsHeaders };
+//# sourceMappingURL=cors.mjs.map

node_modules/@supabase/supabase-js/dist/cors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cors.mjs","names":["corsHeaders: CorsHeaders"],"sources":["../src/cors.ts"],"sourcesContent":["/**\n * Canonical CORS configuration for Supabase Edge Functions\n *\n * This module exports CORS headers that stay synchronized with the Supabase SDK.\n * When new headers are added to the SDK, they are automatically included here,\n * preventing CORS errors in Edge Functions.\n *\n * @example Basic usage\n * ```typescript\n * import { corsHeaders } from '@supabase/supabase-js/cors'\n *\n * Deno.serve(async (req) => {\n *   if (req.method === 'OPTIONS') {\n *     return new Response('ok', { headers: corsHeaders })\n *   }\n *\n *   return new Response(\n *     JSON.stringify({ data: 'Hello' }),\n *     { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }\n *   )\n * })\n * ```\n *\n * @module cors\n */\n\n/**\n * All custom headers sent by the Supabase SDK.\n * These headers need to be included in CORS configuration to prevent preflight failures.\n *\n * Headers:\n * - authorization: Bearer token for authentication\n * - x-client-info: Library version information\n * - apikey: Project API key\n * - content-type: Standard HTTP content type\n * - x-retry-count: Retry attempt number sent by postgrest-js on retried requests\n */\nconst SUPABASE_HEADERS = [\n  'authorization',\n  'x-client-info',\n  'apikey',\n  'content-type',\n  'x-retry-count',\n].join(', ')\n\n/**\n * All HTTP methods used by the Supabase SDK\n */\nconst SUPABASE_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'].join(', ')\n\n/**\n * Type representing CORS headers as a record of header names to values\n */\nexport type CorsHeaders = Record<string, string>\n\n/**\n * Default CORS headers for Supabase Edge Functions.\n *\n * Includes all headers sent by Supabase client libraries and allows all standard HTTP methods.\n * Use this for simple CORS configurations with wildcard origin.\n *\n * @example Basic usage\n * ```typescript\n * import { corsHeaders } from '@supabase/supabase-js/cors'\n *\n * Deno.serve(async (req) => {\n *   if (req.method === 'OPTIONS') {\n *     return new Response('ok', { headers: corsHeaders })\n *   }\n *\n *   return new Response(\n *     JSON.stringify({ data: 'Hello' }),\n *     { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }\n *   )\n * })\n * ```\n *\n * @category Edge Functions\n */\nexport const corsHeaders: CorsHeaders = {\n  'Access-Control-Allow-Origin': '*',\n  'Access-Control-Allow-Headers': SUPABASE_HEADERS,\n  'Access-Control-Allow-Methods': SUPABASE_METHODS,\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,MAAM,mBAAmB;CACvB;CACA;CACA;CACA;CACA;CACD,CAAC,KAAK,KAAK;;;;AAKZ,MAAM,mBAAmB;CAAC;CAAO;CAAQ;CAAO;CAAS;CAAU;CAAU,CAAC,KAAK,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;AA+BxF,MAAaA,cAA2B;CACtC,+BAA+B;CAC/B,gCAAgC;CAChC,gCAAgC;CACjC"}

node_modules/@supabase/supabase-js/dist/index.d.cts

@@ -0,0 +1,776 @@
+import { FunctionInvokeOptions, FunctionRegion, FunctionsClient, FunctionsError, FunctionsFetchError, FunctionsHttpError, FunctionsRelayError } from "@supabase/functions-js";
+import { PostgrestBuilder, PostgrestClient, PostgrestError, PostgrestError as PostgrestError$1, PostgrestFilterBuilder, PostgrestFilterBuilder as PostgrestFilterBuilder$1, PostgrestMaybeSingleResponse, PostgrestQueryBuilder, PostgrestQueryBuilder as PostgrestQueryBuilder$1, PostgrestResponse, PostgrestSingleResponse, PostgrestTransformBuilder } from "@supabase/postgrest-js";
+import { RealtimeChannel, RealtimeChannelOptions, RealtimeClient, RealtimeClientOptions, RealtimeRemoveChannelResponse } from "@supabase/realtime-js";
+import { StorageApiError, StorageClient, StorageClientOptions } from "@supabase/storage-js";
+import { AuthClient, GoTrueClientOptions, Session as AuthSession, User as AuthUser } from "@supabase/auth-js";
+export * from "@supabase/realtime-js";
+export * from "@supabase/auth-js";
+
+//#region src/lib/rest/types/common/common.d.ts
+
+type GenericRelationship = {
+  foreignKeyName: string;
+  columns: string[];
+  isOneToOne?: boolean;
+  referencedRelation: string;
+  referencedColumns: string[];
+};
+type GenericTable = {
+  Row: Record<string, unknown>;
+  Insert: Record<string, unknown>;
+  Update: Record<string, unknown>;
+  Relationships: GenericRelationship[];
+};
+type GenericUpdatableView = {
+  Row: Record<string, unknown>;
+  Insert: Record<string, unknown>;
+  Update: Record<string, unknown>;
+  Relationships: GenericRelationship[];
+};
+type GenericNonUpdatableView = {
+  Row: Record<string, unknown>;
+  Relationships: GenericRelationship[];
+};
+type GenericView = GenericUpdatableView | GenericNonUpdatableView;
+type GenericSetofOption = {
+  isSetofReturn?: boolean | undefined;
+  isOneToOne?: boolean | undefined;
+  isNotNullable?: boolean | undefined;
+  to: string;
+  from: string;
+};
+type GenericFunction = {
+  Args: Record<string, unknown> | never;
+  Returns: unknown;
+  SetofOptions?: GenericSetofOption;
+};
+type GenericSchema = {
+  Tables: Record<string, GenericTable>;
+  Views: Record<string, GenericView>;
+  Functions: Record<string, GenericFunction>;
+};
+//#endregion
+//#region src/lib/types.d.ts
+interface SupabaseAuthClientOptions extends GoTrueClientOptions {}
+type Fetch = typeof fetch;
+/**
+ * Configuration options for trace context propagation.
+ *
+ * Enables distributed tracing across Supabase services using W3C Trace Context
+ * and OpenTelemetry standards. When enabled, the SDK automatically attaches
+ * trace context headers (`traceparent`, `tracestate`, `baggage`) to outgoing
+ * requests to Supabase domains. The resulting `trace_id` appears in API
+ * Gateway and Edge Function logs, so logs forwarded through Log Drains can
+ * be correlated back to the originating client-side span.
+ *
+ * Requires `@opentelemetry/api` to be installed in the consuming application.
+ * If it is not installed, or there is no active context at request time,
+ * propagation silently no-ops.
+ *
+ * @example Enable with defaults
+ * ```ts
+ * const supabase = createClient(url, key, {
+ *   tracePropagation: { enabled: true },
+ * })
+ * ```
+ *
+ * @see https://www.w3.org/TR/trace-context/
+ * @see https://opentelemetry.io/docs/concepts/context-propagation/
+ * @see https://supabase.com/docs/guides/telemetry/client-side-tracing
+ */
+interface TracePropagationOptions {
+  /**
+   * Enable trace propagation. Disabled by default.
+   *
+   * When enabled, automatically detects and propagates active trace context
+   * from the OpenTelemetry API to outgoing Supabase requests. Trace context
+   * is only propagated to Supabase domains (`*.supabase.co`, `*.supabase.in`,
+   * `localhost`) for security — third-party hosts never receive trace headers.
+   *
+   * @default false
+   *
+   * @example
+   * ```ts
+   * const supabase = createClient(url, key, {
+   *   tracePropagation: { enabled: true },
+   * })
+   * ```
+   */
+  enabled?: boolean;
+  /**
+   * Respect upstream sampling decisions.
+   *
+   * When true (the default), trace context is not propagated if the upstream
+   * trace indicates non-sampling (sampled flag = `0` in the `traceparent`
+   * header). This avoids overhead when traces are being recorded but dropped.
+   *
+   * Set to `false` to always propagate, regardless of the sampling decision
+   * — useful when you want every Supabase request tagged with a `trace_id`
+   * for log correlation, even if the trace itself will not be exported.
+   *
+   * @default true
+   *
+   * @example Always propagate, ignore sampling
+   * ```ts
+   * const supabase = createClient(url, key, {
+   *   tracePropagation: { enabled: true, respectSamplingDecision: false },
+   * })
+   * ```
+   */
+  respectSamplingDecision?: boolean;
+}
+type SupabaseClientOptions<SchemaName> = {
+  /**
+   * The Postgres schema which your tables belong to. Must be on the list of exposed schemas in Supabase. Defaults to `public`.
+   */
+  db?: {
+    schema?: SchemaName;
+    /**
+     * Optional timeout in milliseconds for PostgREST requests.
+     * When set, requests will automatically abort after this duration to prevent indefinite hangs.
+     *
+     * @example With timeout
+     * ```ts
+     * const supabase = createClient(url, key, {
+     *   db: { timeout: 30000 } // 30 second timeout
+     * })
+     * ```
+     */
+    timeout?: number;
+    /**
+     * Maximum URL length in characters before warnings/errors are triggered.
+     * Defaults to 8000 characters. Used to provide helpful hints when URLs
+     * exceed server limits.
+     *
+     * @example With custom URL length limit
+     * ```ts
+     * const supabase = createClient(url, key, {
+     *   db: { urlLengthLimit: 10000 } // Custom limit
+     * })
+     * ```
+     */
+    urlLengthLimit?: number;
+  };
+  auth?: {
+    /**
+     * Automatically refreshes the token for logged-in users. Defaults to true.
+     */
+    autoRefreshToken?: boolean;
+    /**
+     * Optional key name used for storing tokens in local storage.
+     */
+    storageKey?: string;
+    /**
+     * Whether to persist a logged-in session to storage. Defaults to true.
+     */
+    persistSession?: boolean;
+    /**
+     * Detect a session from the URL. Used for OAuth login callbacks. Defaults to true.
+     *
+     * Can be set to a function to provide custom logic for determining if a URL contains
+     * a Supabase auth callback. The function receives the current URL and parsed parameters,
+     * and should return true if the URL should be processed as a Supabase auth callback.
+     *
+     * This is useful when your app uses other OAuth providers (e.g., Facebook Login) that
+     * also return access_token in the URL fragment, which would otherwise be incorrectly
+     * intercepted by Supabase Auth.
+     *
+     * @example With custom detection logic
+     * ```ts
+     * detectSessionInUrl: (url, params) => {
+     *   // Ignore Facebook OAuth redirects
+     *   if (url.pathname === '/facebook/redirect') return false
+     *   // Use default detection for other URLs
+     *   return Boolean(params.access_token || params.error_description)
+     * }
+     * ```
+     */
+    detectSessionInUrl?: boolean | ((url: URL, params: {
+      [parameter: string]: string;
+    }) => boolean);
+    /**
+     * A storage provider. Used to store the logged-in session.
+     */
+    storage?: SupabaseAuthClientOptions['storage'];
+    /**
+     * A storage provider to store the user profile separately from the session.
+     * Useful when you need to store the session information in cookies,
+     * without bloating the data with the redundant user object.
+     *
+     * @experimental
+     */
+    userStorage?: SupabaseAuthClientOptions['userStorage'];
+    /**
+     * OAuth flow to use - defaults to implicit flow. PKCE is recommended for mobile and server-side applications.
+     */
+    flowType?: SupabaseAuthClientOptions['flowType'];
+    /**
+     * If debug messages for authentication client are emitted. Can be used to inspect the behavior of the library.
+     */
+    debug?: SupabaseAuthClientOptions['debug'];
+    /**
+     * Provide your own locking mechanism based on the environment. By default
+     * the auth client coordinates refreshes itself and the server resolves
+     * cross-tab races. Passing a custom `lock` opts into a legacy path that
+     * wraps every auth operation in your supplied lock.
+     *
+     * @deprecated Custom locks still work in v2.x for backwards compatibility.
+     * The legacy lock path will be removed in v3 — drop this option from your
+     * `createClient` options before upgrading.
+     */
+    lock?: SupabaseAuthClientOptions['lock'];
+    /**
+     * If there is an error with the query, throwOnError will reject the promise by
+     * throwing the error instead of returning it as part of a successful response.
+     */
+    throwOnError?: SupabaseAuthClientOptions['throwOnError'];
+    /**
+     * Opt-in flags for experimental features. These APIs may change without
+     * notice and are disabled by default.
+     *
+     * @experimental
+     */
+    experimental?: SupabaseAuthClientOptions['experimental'];
+    /**
+     * Maximum time in milliseconds to wait for acquiring the custom lock
+     * supplied via `lock`. Only consulted when a custom `lock` is passed.
+     *
+     * @default 5000
+     *
+     * @deprecated Only used by the legacy lock path. Will be removed in v3
+     * along with the `lock` option.
+     */
+    lockAcquireTimeout?: SupabaseAuthClientOptions['lockAcquireTimeout'];
+    /**
+     * If true, skips automatic initialization in the auth client constructor.
+     * Useful for SSR contexts where initialization timing must be controlled to
+     * prevent race conditions with HTTP response generation.
+     *
+     * @default false
+     */
+    skipAutoInitialize?: SupabaseAuthClientOptions['skipAutoInitialize'];
+  };
+  /**
+   * Options passed to the realtime-js instance
+   */
+  realtime?: RealtimeClientOptions;
+  storage?: StorageClientOptions;
+  global?: {
+    /**
+     * A custom `fetch` implementation.
+     */
+    fetch?: Fetch;
+    /**
+     * Optional headers for initializing the client.
+     */
+    headers?: Record<string, string>;
+  };
+  /**
+   * Optional function for using a third-party authentication system with
+   * Supabase. The function should return an access token or ID token (JWT) by
+   * obtaining it from the third-party auth SDK. Note that this
+   * function may be called concurrently and many times. Use memoization and
+   * locking techniques if this is not supported by the SDKs.
+   *
+   * When set, the `auth` namespace of the Supabase client cannot be used.
+   * Create another client if you wish to use Supabase Auth and third-party
+   * authentications concurrently in the same application.
+   */
+  accessToken?: () => Promise<string | null>;
+  /**
+   * Enable OpenTelemetry / W3C trace context propagation to Supabase services.
+   *
+   * Disabled by default. Pass `true` for the common case (auto-detect an
+   * active OpenTelemetry context and inject `traceparent` / `tracestate` /
+   * `baggage` headers) or an object for fine-grained control.
+   *
+   * Requires `@opentelemetry/api` to be installed in your application; if
+   * not present, the SDK silently no-ops. Trace headers are only attached
+   * to requests targeting Supabase domains, so third-party hosts called
+   * through a custom `fetch` are never tagged.
+   *
+   * The resulting `trace_id` appears in Supabase logs (API Gateway, Edge
+   * Functions), letting you correlate client-side spans with server-side
+   * log entries — including logs forwarded via Log Drains.
+   *
+   * @example Shorthand — opt in with defaults
+   * ```ts
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const supabase = createClient(url, key, { tracePropagation: true })
+   * ```
+   *
+   * @example With an active OpenTelemetry span
+   * ```ts
+   * import { createClient } from '@supabase/supabase-js'
+   * import { trace } from '@opentelemetry/api'
+   *
+   * const supabase = createClient(url, key, { tracePropagation: true })
+   * const tracer = trace.getTracer('my-app')
+   *
+   * await tracer.startActiveSpan('fetch-users', async (span) => {
+   *   // Request carries the active trace context.
+   *   const { data, error } = await supabase.from('users').select('*')
+   *   span.end()
+   * })
+   * ```
+   *
+   * @example Advanced — always propagate, even for non-sampled traces
+   * ```ts
+   * const supabase = createClient(url, key, {
+   *   tracePropagation: { enabled: true, respectSamplingDecision: false },
+   * })
+   * ```
+   *
+   * @see https://supabase.com/docs/guides/telemetry/client-side-tracing
+   * @see https://www.w3.org/TR/trace-context/
+   */
+  tracePropagation?: TracePropagationOptions | boolean;
+};
+/**
+ * Helper types for query results.
+ */
+type QueryResult<T> = T extends PromiseLike<infer U> ? U : never;
+type QueryData<T> = T extends PromiseLike<{
+  data: infer U;
+}> ? Exclude<U, null> : never;
+type QueryError = PostgrestError$1;
+/**
+ * Strips internal Supabase metadata from Database types.
+ * Useful for libraries defining generic constraints on Database types.
+ *
+ * @example Stripping internal Supabase metadata
+ * ```typescript
+ * type CleanDB = DatabaseWithoutInternals<Database>
+ * ```
+ */
+type DatabaseWithoutInternals<DB> = Omit<DB, '__InternalSupabase'>;
+//#endregion
+//#region src/lib/helpers.d.ts
+type ResolvedSupabaseClientOptions<SchemaName> = Omit<Required<SupabaseClientOptions<SchemaName>>, 'tracePropagation'> & {
+  tracePropagation: TracePropagationOptions;
+};
+//#endregion
+//#region src/lib/SupabaseAuthClient.d.ts
+declare class SupabaseAuthClient extends AuthClient {
+  constructor(options: SupabaseAuthClientOptions);
+}
+//#endregion
+//#region src/lib/rest/types/common/rpc.d.ts
+type IsMatchingArgs<FnArgs extends GenericFunction['Args'], PassedArgs extends GenericFunction['Args']> = [FnArgs] extends [Record<PropertyKey, never>] ? PassedArgs extends Record<PropertyKey, never> ? true : false : keyof PassedArgs extends keyof FnArgs ? PassedArgs extends FnArgs ? true : false : false;
+type MatchingFunctionArgs<Fn$1 extends GenericFunction, Args extends GenericFunction['Args']> = Fn$1 extends {
+  Args: infer A extends GenericFunction['Args'];
+} ? IsMatchingArgs<A, Args> extends true ? Fn$1 : never : false;
+type FindMatchingFunctionByArgs<FnUnion, Args extends GenericFunction['Args']> = FnUnion extends infer Fn extends GenericFunction ? MatchingFunctionArgs<Fn, Args> : false;
+type TablesAndViews<Schema extends GenericSchema> = Schema['Tables'] & Exclude<Schema['Views'], ''>;
+type UnionToIntersection<U$1> = (U$1 extends any ? (k: U$1) => void : never) extends ((k: infer I) => void) ? I : never;
+type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends (() => infer R) ? R : never;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type ExactMatch<T, S> = [T] extends [S] ? ([S] extends [T] ? true : false) : false;
+type ExtractExactFunction<Fns, Args> = Fns extends infer F ? F extends GenericFunction ? ExactMatch<F['Args'], Args> extends true ? F : never : never : never;
+type IsNever<T> = [T] extends [never] ? true : false;
+type RpcFunctionNotFound<FnName> = {
+  Row: any;
+  Result: {
+    error: true;
+  } & "Couldn't infer function definition matching provided arguments";
+  RelationName: FnName;
+  Relationships: null;
+};
+type CrossSchemaError<TableRef extends string> = {
+  error: true;
+} & `Function returns SETOF from a different schema ('${TableRef}'). Use .overrideTypes<YourReturnType>() to specify the return type explicitly.`;
+type GetRpcFunctionFilterBuilderByArgs<Schema extends GenericSchema, FnName extends string & keyof Schema['Functions'], Args> = {
+  0: Schema['Functions'][FnName];
+  1: IsAny<Schema> extends true ? any : IsNever<Args> extends true ? IsNever<ExtractExactFunction<Schema['Functions'][FnName], Args>> extends true ? LastOf<Schema['Functions'][FnName]> : ExtractExactFunction<Schema['Functions'][FnName], Args> : Args extends Record<PropertyKey, never> ? LastOf<Schema['Functions'][FnName]> : Args extends GenericFunction['Args'] ? IsNever<LastOf<FindMatchingFunctionByArgs<Schema['Functions'][FnName], Args>>> extends true ? LastOf<Schema['Functions'][FnName]> : LastOf<FindMatchingFunctionByArgs<Schema['Functions'][FnName], Args>> : ExtractExactFunction<Schema['Functions'][FnName], Args> extends GenericFunction ? ExtractExactFunction<Schema['Functions'][FnName], Args> : any;
+}[1] extends infer Fn ? IsAny<Fn> extends true ? {
+  Row: any;
+  Result: any;
+  RelationName: FnName;
+  Relationships: null;
+} : Fn extends GenericFunction ? {
+  Row: Fn['SetofOptions'] extends GenericSetofOption ? Fn['SetofOptions']['to'] extends keyof TablesAndViews<Schema> ? TablesAndViews<Schema>[Fn['SetofOptions']['to']]['Row'] : Fn['Returns'] extends any[] ? Fn['Returns'][number] extends Record<string, unknown> ? Fn['Returns'][number] : CrossSchemaError<Fn['SetofOptions']['to'] & string> : Fn['Returns'] extends Record<string, unknown> ? Fn['Returns'] : CrossSchemaError<Fn['SetofOptions']['to'] & string> : Fn['Returns'] extends any[] ? Fn['Returns'][number] extends Record<string, unknown> ? Fn['Returns'][number] : never : Fn['Returns'] extends Record<string, unknown> ? Fn['Returns'] : never;
+  Result: Fn['SetofOptions'] extends GenericSetofOption ? Fn['SetofOptions']['isSetofReturn'] extends true ? Fn['SetofOptions']['isOneToOne'] extends true ? Fn['Returns'][] : Fn['Returns'] : Fn['Returns'] : Fn['Returns'];
+  RelationName: Fn['SetofOptions'] extends GenericSetofOption ? Fn['SetofOptions']['to'] : FnName;
+  Relationships: Fn['SetofOptions'] extends GenericSetofOption ? Fn['SetofOptions']['to'] extends keyof Schema['Tables'] ? Schema['Tables'][Fn['SetofOptions']['to']]['Relationships'] : Fn['SetofOptions']['to'] extends keyof Schema['Views'] ? Schema['Views'][Fn['SetofOptions']['to']]['Relationships'] : null : null;
+} : Fn extends false ? RpcFunctionNotFound<FnName> : RpcFunctionNotFound<FnName> : RpcFunctionNotFound<FnName>;
+//#endregion
+//#region src/SupabaseClient.d.ts
+/**
+ * Supabase Client.
+ *
+ * An isomorphic Javascript client for interacting with Postgres.
+ */
+declare class SupabaseClient<Database = any, SchemaNameOrClientOptions extends (string & keyof Omit<Database, '__InternalSupabase'>) | {
+  PostgrestVersion: string;
+} = ('public' extends keyof Omit<Database, '__InternalSupabase'> ? 'public' : string & keyof Omit<Database, '__InternalSupabase'>), SchemaName extends string & keyof Omit<Database, '__InternalSupabase'> = (SchemaNameOrClientOptions extends string & keyof Omit<Database, '__InternalSupabase'> ? SchemaNameOrClientOptions : 'public' extends keyof Omit<Database, '__InternalSupabase'> ? 'public' : string & keyof Omit<Omit<Database, '__InternalSupabase'>, '__InternalSupabase'>), Schema extends (Omit<Database, '__InternalSupabase'>[SchemaName] extends GenericSchema ? Omit<Database, '__InternalSupabase'>[SchemaName] : never) = (Omit<Database, '__InternalSupabase'>[SchemaName] extends GenericSchema ? Omit<Database, '__InternalSupabase'>[SchemaName] : never), ClientOptions extends {
+  PostgrestVersion: string;
+} = (SchemaNameOrClientOptions extends string & keyof Omit<Database, '__InternalSupabase'> ? Database extends {
+  __InternalSupabase: {
+    PostgrestVersion: string;
+  };
+} ? Database['__InternalSupabase'] : {
+  PostgrestVersion: '12';
+} : SchemaNameOrClientOptions extends {
+  PostgrestVersion: string;
+} ? SchemaNameOrClientOptions : never)> {
+  protected supabaseUrl: string;
+  protected supabaseKey: string;
+  /**
+   * Supabase Auth allows you to create and manage user sessions for access to data that is secured by access policies.
+   */
+  auth: SupabaseAuthClient;
+  realtime: RealtimeClient;
+  /**
+   * Supabase Storage allows you to manage user-generated content, such as photos or videos.
+   */
+  storage: StorageClient;
+  protected realtimeUrl: URL;
+  protected authUrl: URL;
+  protected storageUrl: URL;
+  protected functionsUrl: URL;
+  protected rest: PostgrestClient<Database, ClientOptions, SchemaName>;
+  protected storageKey: string;
+  protected fetch?: Fetch;
+  protected functionsFetch?: Fetch;
+  protected changedAccessToken?: string;
+  protected accessToken?: () => Promise<string | null>;
+  protected headers: Record<string, string>;
+  protected settings?: ResolvedSupabaseClientOptions<SchemaName>;
+  /**
+   * Create a new client for use in the browser.
+   *
+   * @category Initializing
+   *
+   * @param supabaseUrl The unique Supabase URL which is supplied when you create a new project in your project dashboard.
+   * @param supabaseKey The unique Supabase Key which is supplied when you create a new project in your project dashboard.
+   * @param options Optional configuration for the client:
+   * - `db.schema` — You can switch in between schemas. The schema needs to be on the list of exposed schemas inside Supabase.
+   * - `auth.autoRefreshToken` — Set to `true` if you want to automatically refresh the token before expiring.
+   * - `auth.persistSession` — Set to `true` if you want to automatically save the user session into local storage.
+   * - `auth.detectSessionInUrl` — Set to `true` if you want to automatically detect OAuth grants in the URL and sign in the user.
+   * - `realtime` — Options passed along to the realtime-js constructor.
+   * - `storage` — Options passed along to the storage-js constructor.
+   * - `global.fetch` — A custom fetch implementation.
+   * - `global.headers` — Any additional headers to send with each network request.
+   *
+   * @example Creating a client
+   * ```js
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * // Create a single supabase client for interacting with your database
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key')
+   * ```
+   *
+   * @example With a custom domain
+   * ```js
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * // Use a custom domain as the supabase URL
+   * const supabase = createClient('https://my-custom-domain.com', 'your-publishable-key')
+   * ```
+   *
+   * @example With additional parameters
+   * ```js
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const options = {
+   *   db: {
+   *     schema: 'public',
+   *   },
+   *   auth: {
+   *     autoRefreshToken: true,
+   *     persistSession: true,
+   *     detectSessionInUrl: true
+   *   },
+   *   global: {
+   *     headers: { 'x-my-custom-header': 'my-app-name' },
+   *   },
+   * }
+   * const supabase = createClient("https://xyzcompany.supabase.co", "your-publishable-key", options)
+   * ```
+   *
+   * @exampleDescription With custom schemas
+   * By default the API server points to the `public` schema. You can enable other database schemas within the Dashboard.
+   * Go to [Settings > API > Exposed schemas](/dashboard/project/_/settings/api) and add the schema which you want to expose to the API.
+   *
+   * Note: each client connection can only access a single schema, so the code above can access the `other_schema` schema but cannot access the `public` schema.
+   *
+   * @example With custom schemas
+   * ```js
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key', {
+   *   // Provide a custom schema. Defaults to "public".
+   *   db: { schema: 'other_schema' }
+   * })
+   * ```
+   *
+   * @exampleDescription Custom fetch implementation
+   * `supabase-js` uses the runtime's global `fetch` to make HTTP requests,
+   * but an alternative `fetch` implementation can be provided as an option.
+   * This is useful in environments where the global `fetch` is unavailable or where you want to customize request behavior.
+   *
+   * @example Custom fetch implementation
+   * ```js
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key', {
+   *   global: { fetch: fetch.bind(globalThis) }
+   * })
+   * ```
+   *
+   * @exampleDescription React Native options with AsyncStorage
+   * For React Native we recommend using `AsyncStorage` as the storage implementation for Supabase Auth.
+   *
+   * @example React Native options with AsyncStorage
+   * ```js
+   * import 'react-native-url-polyfill/auto'
+   * import { createClient } from '@supabase/supabase-js'
+   * import AsyncStorage from "@react-native-async-storage/async-storage";
+   *
+   * const supabase = createClient("https://xyzcompany.supabase.co", "your-publishable-key", {
+   *   auth: {
+   *     storage: AsyncStorage,
+   *     autoRefreshToken: true,
+   *     persistSession: true,
+   *     detectSessionInUrl: false,
+   *   },
+   * });
+   * ```
+   *
+   * @exampleDescription React Native options with Expo SecureStore
+   * If you wish to encrypt the user's session information, you can use `aes-js` and store the encryption key in Expo SecureStore.
+   * The `aes-js` library, a reputable JavaScript-only implementation of the AES encryption algorithm in CTR mode.
+   * A new 256-bit encryption key is generated using the `react-native-get-random-values` library.
+   * This key is stored inside Expo's SecureStore, while the value is encrypted and placed inside AsyncStorage.
+   *
+   * Please make sure that:
+   * - You keep the `expo-secure-store`, `aes-js` and `react-native-get-random-values` libraries up-to-date.
+   * - Choose the correct [`SecureStoreOptions`](https://docs.expo.dev/versions/latest/sdk/securestore/#securestoreoptions) for your app's needs.
+   *   E.g. [`SecureStore.WHEN_UNLOCKED`](https://docs.expo.dev/versions/latest/sdk/securestore/#securestorewhen_unlocked) regulates when the data can be accessed.
+   * - Carefully consider optimizations or other modifications to the above example, as those can lead to introducing subtle security vulnerabilities.
+   *
+   * @example React Native options with Expo SecureStore
+   * ```ts
+   * import 'react-native-url-polyfill/auto'
+   * import { createClient } from '@supabase/supabase-js'
+   * import AsyncStorage from '@react-native-async-storage/async-storage';
+   * import * as SecureStore from 'expo-secure-store';
+   * import * as aesjs from 'aes-js';
+   * import 'react-native-get-random-values';
+   *
+   * // As Expo's SecureStore does not support values larger than 2048
+   * // bytes, an AES-256 key is generated and stored in SecureStore, while
+   * // it is used to encrypt/decrypt values stored in AsyncStorage.
+   * class LargeSecureStore {
+   *   private async _encrypt(key: string, value: string) {
+   *     const encryptionKey = crypto.getRandomValues(new Uint8Array(256 / 8));
+   *
+   *     const cipher = new aesjs.ModeOfOperation.ctr(encryptionKey, new aesjs.Counter(1));
+   *     const encryptedBytes = cipher.encrypt(aesjs.utils.utf8.toBytes(value));
+   *
+   *     await SecureStore.setItemAsync(key, aesjs.utils.hex.fromBytes(encryptionKey));
+   *
+   *     return aesjs.utils.hex.fromBytes(encryptedBytes);
+   *   }
+   *
+   *   private async _decrypt(key: string, value: string) {
+   *     const encryptionKeyHex = await SecureStore.getItemAsync(key);
+   *     if (!encryptionKeyHex) {
+   *       return encryptionKeyHex;
+   *     }
+   *
+   *     const cipher = new aesjs.ModeOfOperation.ctr(aesjs.utils.hex.toBytes(encryptionKeyHex), new aesjs.Counter(1));
+   *     const decryptedBytes = cipher.decrypt(aesjs.utils.hex.toBytes(value));
+   *
+   *     return aesjs.utils.utf8.fromBytes(decryptedBytes);
+   *   }
+   *
+   *   async getItem(key: string) {
+   *     const encrypted = await AsyncStorage.getItem(key);
+   *     if (!encrypted) { return encrypted; }
+   *
+   *     return await this._decrypt(key, encrypted);
+   *   }
+   *
+   *   async removeItem(key: string) {
+   *     await AsyncStorage.removeItem(key);
+   *     await SecureStore.deleteItemAsync(key);
+   *   }
+   *
+   *   async setItem(key: string, value: string) {
+   *     const encrypted = await this._encrypt(key, value);
+   *
+   *     await AsyncStorage.setItem(key, encrypted);
+   *   }
+   * }
+   *
+   * const supabase = createClient("https://xyzcompany.supabase.co", "your-publishable-key", {
+   *   auth: {
+   *     storage: new LargeSecureStore(),
+   *     autoRefreshToken: true,
+   *     persistSession: true,
+   *     detectSessionInUrl: false,
+   *   },
+   * });
+   * ```
+   *
+   * @example With a database query
+   * ```ts
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key')
+   *
+   * const { data } = await supabase.from('profiles').select('*')
+   * ```
+   *
+   * @exampleDescription With OpenTelemetry tracing
+   * Opt in to W3C trace context propagation so the `trace_id` from your
+   * client-side spans is attached to Supabase requests and appears in API
+   * Gateway and Edge Function logs. Requires `@opentelemetry/api` to be
+   * installed in your application. See [Tracing with the JS SDK](https://supabase.com/docs/guides/telemetry/client-side-tracing).
+   *
+   * @example With OpenTelemetry tracing
+   * ```ts
+   * import { createClient } from '@supabase/supabase-js'
+   * import { trace } from '@opentelemetry/api'
+   *
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key', {
+   *   tracePropagation: true,
+   * })
+   *
+   * const tracer = trace.getTracer('my-app')
+   *
+   * await tracer.startActiveSpan('fetch-users', async (span) => {
+   *   // Outgoing request carries the active trace context.
+   *   const { data, error } = await supabase.from('users').select('*')
+   *   span.end()
+   * })
+   * ```
+   */
+  constructor(supabaseUrl: string, supabaseKey: string, options?: SupabaseClientOptions<SchemaName>);
+  /**
+   * Supabase Functions allows you to deploy and invoke edge functions.
+   */
+  get functions(): FunctionsClient;
+  from<TableName extends string & keyof Schema['Tables'], Table extends Schema['Tables'][TableName]>(relation: TableName): PostgrestQueryBuilder$1<ClientOptions, Schema, Table, TableName>;
+  from<ViewName extends string & keyof Schema['Views'], View extends Schema['Views'][ViewName]>(relation: ViewName): PostgrestQueryBuilder$1<ClientOptions, Schema, View, ViewName>;
+  /**
+   * Select a schema to query or perform an function (rpc) call.
+   *
+   * The schema needs to be on the list of exposed schemas inside Supabase.
+   *
+   * @param schema - The schema to query
+   */
+  schema<DynamicSchema extends string & keyof Omit<Database, '__InternalSupabase'>>(schema: DynamicSchema): PostgrestClient<Database, ClientOptions, DynamicSchema, Database[DynamicSchema] extends GenericSchema ? Database[DynamicSchema] : any>;
+  /**
+   * Perform a function call.
+   *
+   * @param fn - The function name to call
+   * @param args - The arguments to pass to the function call
+   * @param options - Named parameters
+   * @param options.head - When set to `true`, `data` will not be returned.
+   * Useful if you only need the count.
+   * @param options.get - When set to `true`, the function will be called with
+   * read-only access mode.
+   * @param options.count - Count algorithm to use to count rows returned by the
+   * function. Only applicable for [set-returning
+   * functions](https://www.postgresql.org/docs/current/functions-srf.html).
+   *
+   * `"exact"`: Exact but slow count algorithm. Performs a `COUNT(*)` under the
+   * hood.
+   *
+   * `"planned"`: Approximated but fast count algorithm. Uses the Postgres
+   * statistics under the hood.
+   *
+   * `"estimated"`: Uses exact count for low numbers and planned count for high
+   * numbers.
+   */
+  rpc<FnName extends string & keyof Schema['Functions'], Args extends Schema['Functions'][FnName]['Args'] = never, FilterBuilder extends GetRpcFunctionFilterBuilderByArgs<Schema, FnName, Args> = GetRpcFunctionFilterBuilderByArgs<Schema, FnName, Args>>(fn: FnName, args?: Args, options?: {
+    head?: boolean;
+    get?: boolean;
+    count?: 'exact' | 'planned' | 'estimated';
+  }): PostgrestFilterBuilder$1<ClientOptions, Schema, FilterBuilder['Row'], FilterBuilder['Result'], FilterBuilder['RelationName'], FilterBuilder['Relationships'], 'RPC'>;
+  /**
+   * Creates a Realtime channel with Broadcast, Presence, and Postgres Changes.
+   *
+   * @param {string} name - The name of the Realtime channel.
+   * @param {Object} opts - The options to pass to the Realtime channel.
+   *
+   * @category Realtime
+   */
+  channel(name: string, opts?: RealtimeChannelOptions): RealtimeChannel;
+  /**
+   * Returns all Realtime channels.
+   *
+   * @category Realtime
+   *
+   * @example Get all channels
+   * ```js
+   * const channels = supabase.getChannels()
+   * ```
+   */
+  getChannels(): RealtimeChannel[];
+  /**
+   * Unsubscribes and removes Realtime channel from Realtime client.
+   *
+   * @param {RealtimeChannel} channel - The name of the Realtime channel.
+   *
+   *
+   * @category Realtime
+   *
+   * @remarks
+   * - Removing a channel is a great way to maintain the performance of your project's Realtime service as well as your database if you're listening to Postgres changes. Supabase will automatically handle cleanup 30 seconds after a client is disconnected, but unused channels may cause degradation as more clients are simultaneously subscribed.
+   *
+   * @example Removes a channel
+   * ```js
+   * supabase.removeChannel(myChannel)
+   * ```
+   */
+  removeChannel(channel: RealtimeChannel): Promise<RealtimeRemoveChannelResponse>;
+  /**
+   * Unsubscribes and removes all Realtime channels from Realtime client.
+   *
+   * @category Realtime
+   *
+   * @remarks
+   * - Removing channels is a great way to maintain the performance of your project's Realtime service as well as your database if you're listening to Postgres changes. Supabase will automatically handle cleanup 30 seconds after a client is disconnected, but unused channels may cause degradation as more clients are simultaneously subscribed.
+   *
+   * @example Remove all channels
+   * ```js
+   * supabase.removeAllChannels()
+   * ```
+   */
+  removeAllChannels(): Promise<RealtimeRemoveChannelResponse[]>;
+  /**
+   * The raw session token — the custom `accessToken` result or the signed-in user's JWT —
+   * or `null` when there is no session. Unlike {@link _getAccessToken} it does not fall back
+   * to `supabaseKey`, so callers can distinguish "no session" from "has session".
+   */
+  private _getSessionToken;
+  private _getAccessToken;
+  private _initSupabaseAuthClient;
+  private _initRealtimeClient;
+  private _listenForAuthEvents;
+  private _handleTokenChanged;
+}
+//#endregion
+//#region src/index.d.ts
+/**
+ * Creates a new Supabase Client.
+ *
+ * @example Creating a Supabase client
+ * ```ts
+ * import { createClient } from '@supabase/supabase-js'
+ *
+ * const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key')
+ * const { data, error } = await supabase.from('profiles').select('*')
+ * ```
+ */
+declare const createClient: <Database = any, SchemaNameOrClientOptions extends (string & keyof Omit<Database, "__InternalSupabase">) | {
+  PostgrestVersion: string;
+} = ("public" extends keyof Omit<Database, "__InternalSupabase"> ? "public" : string & keyof Omit<Database, "__InternalSupabase">), SchemaName extends string & keyof Omit<Database, "__InternalSupabase"> = (SchemaNameOrClientOptions extends string & keyof Omit<Database, "__InternalSupabase"> ? SchemaNameOrClientOptions : "public" extends keyof Omit<Database, "__InternalSupabase"> ? "public" : string & keyof Omit<Omit<Database, "__InternalSupabase">, "__InternalSupabase">)>(supabaseUrl: string, supabaseKey: string, options?: SupabaseClientOptions<SchemaName>) => SupabaseClient<Database, SchemaNameOrClientOptions, SchemaName>;
+//#endregion
+export { type AuthSession, type AuthUser, type DatabaseWithoutInternals, type FunctionInvokeOptions, FunctionRegion, FunctionsError, FunctionsFetchError, FunctionsHttpError, FunctionsRelayError, type PostgrestBuilder, PostgrestError, type PostgrestFilterBuilder, type PostgrestMaybeSingleResponse, type PostgrestQueryBuilder, type PostgrestResponse, type PostgrestSingleResponse, type PostgrestTransformBuilder, type QueryData, type QueryError, type QueryResult, StorageApiError, SupabaseClient, type SupabaseClientOptions, type TracePropagationOptions, createClient };
+//# sourceMappingURL=index.d.cts.map

node_modules/@supabase/supabase-js/dist/index.d.mts

@@ -0,0 +1,776 @@
+import { FunctionInvokeOptions, FunctionRegion, FunctionsClient, FunctionsError, FunctionsFetchError, FunctionsHttpError, FunctionsRelayError } from "@supabase/functions-js";
+import { PostgrestBuilder, PostgrestClient, PostgrestError, PostgrestError as PostgrestError$1, PostgrestFilterBuilder, PostgrestFilterBuilder as PostgrestFilterBuilder$1, PostgrestMaybeSingleResponse, PostgrestQueryBuilder, PostgrestQueryBuilder as PostgrestQueryBuilder$1, PostgrestResponse, PostgrestSingleResponse, PostgrestTransformBuilder } from "@supabase/postgrest-js";
+import { RealtimeChannel, RealtimeChannelOptions, RealtimeClient, RealtimeClientOptions, RealtimeRemoveChannelResponse } from "@supabase/realtime-js";
+import { StorageApiError, StorageClient, StorageClientOptions } from "@supabase/storage-js";
+import { AuthClient, GoTrueClientOptions, Session as AuthSession, User as AuthUser } from "@supabase/auth-js";
+export * from "@supabase/realtime-js";
+export * from "@supabase/auth-js";
+
+//#region src/lib/rest/types/common/common.d.ts
+
+type GenericRelationship = {
+  foreignKeyName: string;
+  columns: string[];
+  isOneToOne?: boolean;
+  referencedRelation: string;
+  referencedColumns: string[];
+};
+type GenericTable = {
+  Row: Record<string, unknown>;
+  Insert: Record<string, unknown>;
+  Update: Record<string, unknown>;
+  Relationships: GenericRelationship[];
+};
+type GenericUpdatableView = {
+  Row: Record<string, unknown>;
+  Insert: Record<string, unknown>;
+  Update: Record<string, unknown>;
+  Relationships: GenericRelationship[];
+};
+type GenericNonUpdatableView = {
+  Row: Record<string, unknown>;
+  Relationships: GenericRelationship[];
+};
+type GenericView = GenericUpdatableView | GenericNonUpdatableView;
+type GenericSetofOption = {
+  isSetofReturn?: boolean | undefined;
+  isOneToOne?: boolean | undefined;
+  isNotNullable?: boolean | undefined;
+  to: string;
+  from: string;
+};
+type GenericFunction = {
+  Args: Record<string, unknown> | never;
+  Returns: unknown;
+  SetofOptions?: GenericSetofOption;
+};
+type GenericSchema = {
+  Tables: Record<string, GenericTable>;
+  Views: Record<string, GenericView>;
+  Functions: Record<string, GenericFunction>;
+};
+//#endregion
+//#region src/lib/types.d.ts
+interface SupabaseAuthClientOptions extends GoTrueClientOptions {}
+type Fetch = typeof fetch;
+/**
+ * Configuration options for trace context propagation.
+ *
+ * Enables distributed tracing across Supabase services using W3C Trace Context
+ * and OpenTelemetry standards. When enabled, the SDK automatically attaches
+ * trace context headers (`traceparent`, `tracestate`, `baggage`) to outgoing
+ * requests to Supabase domains. The resulting `trace_id` appears in API
+ * Gateway and Edge Function logs, so logs forwarded through Log Drains can
+ * be correlated back to the originating client-side span.
+ *
+ * Requires `@opentelemetry/api` to be installed in the consuming application.
+ * If it is not installed, or there is no active context at request time,
+ * propagation silently no-ops.
+ *
+ * @example Enable with defaults
+ * ```ts
+ * const supabase = createClient(url, key, {
+ *   tracePropagation: { enabled: true },
+ * })
+ * ```
+ *
+ * @see https://www.w3.org/TR/trace-context/
+ * @see https://opentelemetry.io/docs/concepts/context-propagation/
+ * @see https://supabase.com/docs/guides/telemetry/client-side-tracing
+ */
+interface TracePropagationOptions {
+  /**
+   * Enable trace propagation. Disabled by default.
+   *
+   * When enabled, automatically detects and propagates active trace context
+   * from the OpenTelemetry API to outgoing Supabase requests. Trace context
+   * is only propagated to Supabase domains (`*.supabase.co`, `*.supabase.in`,
+   * `localhost`) for security — third-party hosts never receive trace headers.
+   *
+   * @default false
+   *
+   * @example
+   * ```ts
+   * const supabase = createClient(url, key, {
+   *   tracePropagation: { enabled: true },
+   * })
+   * ```
+   */
+  enabled?: boolean;
+  /**
+   * Respect upstream sampling decisions.
+   *
+   * When true (the default), trace context is not propagated if the upstream
+   * trace indicates non-sampling (sampled flag = `0` in the `traceparent`
+   * header). This avoids overhead when traces are being recorded but dropped.
+   *
+   * Set to `false` to always propagate, regardless of the sampling decision
+   * — useful when you want every Supabase request tagged with a `trace_id`
+   * for log correlation, even if the trace itself will not be exported.
+   *
+   * @default true
+   *
+   * @example Always propagate, ignore sampling
+   * ```ts
+   * const supabase = createClient(url, key, {
+   *   tracePropagation: { enabled: true, respectSamplingDecision: false },
+   * })
+   * ```
+   */
+  respectSamplingDecision?: boolean;
+}
+type SupabaseClientOptions<SchemaName> = {
+  /**
+   * The Postgres schema which your tables belong to. Must be on the list of exposed schemas in Supabase. Defaults to `public`.
+   */
+  db?: {
+    schema?: SchemaName;
+    /**
+     * Optional timeout in milliseconds for PostgREST requests.
+     * When set, requests will automatically abort after this duration to prevent indefinite hangs.
+     *
+     * @example With timeout
+     * ```ts
+     * const supabase = createClient(url, key, {
+     *   db: { timeout: 30000 } // 30 second timeout
+     * })
+     * ```
+     */
+    timeout?: number;
+    /**
+     * Maximum URL length in characters before warnings/errors are triggered.
+     * Defaults to 8000 characters. Used to provide helpful hints when URLs
+     * exceed server limits.
+     *
+     * @example With custom URL length limit
+     * ```ts
+     * const supabase = createClient(url, key, {
+     *   db: { urlLengthLimit: 10000 } // Custom limit
+     * })
+     * ```
+     */
+    urlLengthLimit?: number;
+  };
+  auth?: {
+    /**
+     * Automatically refreshes the token for logged-in users. Defaults to true.
+     */
+    autoRefreshToken?: boolean;
+    /**
+     * Optional key name used for storing tokens in local storage.
+     */
+    storageKey?: string;
+    /**
+     * Whether to persist a logged-in session to storage. Defaults to true.
+     */
+    persistSession?: boolean;
+    /**
+     * Detect a session from the URL. Used for OAuth login callbacks. Defaults to true.
+     *
+     * Can be set to a function to provide custom logic for determining if a URL contains
+     * a Supabase auth callback. The function receives the current URL and parsed parameters,
+     * and should return true if the URL should be processed as a Supabase auth callback.
+     *
+     * This is useful when your app uses other OAuth providers (e.g., Facebook Login) that
+     * also return access_token in the URL fragment, which would otherwise be incorrectly
+     * intercepted by Supabase Auth.
+     *
+     * @example With custom detection logic
+     * ```ts
+     * detectSessionInUrl: (url, params) => {
+     *   // Ignore Facebook OAuth redirects
+     *   if (url.pathname === '/facebook/redirect') return false
+     *   // Use default detection for other URLs
+     *   return Boolean(params.access_token || params.error_description)
+     * }
+     * ```
+     */
+    detectSessionInUrl?: boolean | ((url: URL, params: {
+      [parameter: string]: string;
+    }) => boolean);
+    /**
+     * A storage provider. Used to store the logged-in session.
+     */
+    storage?: SupabaseAuthClientOptions['storage'];
+    /**
+     * A storage provider to store the user profile separately from the session.
+     * Useful when you need to store the session information in cookies,
+     * without bloating the data with the redundant user object.
+     *
+     * @experimental
+     */
+    userStorage?: SupabaseAuthClientOptions['userStorage'];
+    /**
+     * OAuth flow to use - defaults to implicit flow. PKCE is recommended for mobile and server-side applications.
+     */
+    flowType?: SupabaseAuthClientOptions['flowType'];
+    /**
+     * If debug messages for authentication client are emitted. Can be used to inspect the behavior of the library.
+     */
+    debug?: SupabaseAuthClientOptions['debug'];
+    /**
+     * Provide your own locking mechanism based on the environment. By default
+     * the auth client coordinates refreshes itself and the server resolves
+     * cross-tab races. Passing a custom `lock` opts into a legacy path that
+     * wraps every auth operation in your supplied lock.
+     *
+     * @deprecated Custom locks still work in v2.x for backwards compatibility.
+     * The legacy lock path will be removed in v3 — drop this option from your
+     * `createClient` options before upgrading.
+     */
+    lock?: SupabaseAuthClientOptions['lock'];
+    /**
+     * If there is an error with the query, throwOnError will reject the promise by
+     * throwing the error instead of returning it as part of a successful response.
+     */
+    throwOnError?: SupabaseAuthClientOptions['throwOnError'];
+    /**
+     * Opt-in flags for experimental features. These APIs may change without
+     * notice and are disabled by default.
+     *
+     * @experimental
+     */
+    experimental?: SupabaseAuthClientOptions['experimental'];
+    /**
+     * Maximum time in milliseconds to wait for acquiring the custom lock
+     * supplied via `lock`. Only consulted when a custom `lock` is passed.
+     *
+     * @default 5000
+     *
+     * @deprecated Only used by the legacy lock path. Will be removed in v3
+     * along with the `lock` option.
+     */
+    lockAcquireTimeout?: SupabaseAuthClientOptions['lockAcquireTimeout'];
+    /**
+     * If true, skips automatic initialization in the auth client constructor.
+     * Useful for SSR contexts where initialization timing must be controlled to
+     * prevent race conditions with HTTP response generation.
+     *
+     * @default false
+     */
+    skipAutoInitialize?: SupabaseAuthClientOptions['skipAutoInitialize'];
+  };
+  /**
+   * Options passed to the realtime-js instance
+   */
+  realtime?: RealtimeClientOptions;
+  storage?: StorageClientOptions;
+  global?: {
+    /**
+     * A custom `fetch` implementation.
+     */
+    fetch?: Fetch;
+    /**
+     * Optional headers for initializing the client.
+     */
+    headers?: Record<string, string>;
+  };
+  /**
+   * Optional function for using a third-party authentication system with
+   * Supabase. The function should return an access token or ID token (JWT) by
+   * obtaining it from the third-party auth SDK. Note that this
+   * function may be called concurrently and many times. Use memoization and
+   * locking techniques if this is not supported by the SDKs.
+   *
+   * When set, the `auth` namespace of the Supabase client cannot be used.
+   * Create another client if you wish to use Supabase Auth and third-party
+   * authentications concurrently in the same application.
+   */
+  accessToken?: () => Promise<string | null>;
+  /**
+   * Enable OpenTelemetry / W3C trace context propagation to Supabase services.
+   *
+   * Disabled by default. Pass `true` for the common case (auto-detect an
+   * active OpenTelemetry context and inject `traceparent` / `tracestate` /
+   * `baggage` headers) or an object for fine-grained control.
+   *
+   * Requires `@opentelemetry/api` to be installed in your application; if
+   * not present, the SDK silently no-ops. Trace headers are only attached
+   * to requests targeting Supabase domains, so third-party hosts called
+   * through a custom `fetch` are never tagged.
+   *
+   * The resulting `trace_id` appears in Supabase logs (API Gateway, Edge
+   * Functions), letting you correlate client-side spans with server-side
+   * log entries — including logs forwarded via Log Drains.
+   *
+   * @example Shorthand — opt in with defaults
+   * ```ts
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const supabase = createClient(url, key, { tracePropagation: true })
+   * ```
+   *
+   * @example With an active OpenTelemetry span
+   * ```ts
+   * import { createClient } from '@supabase/supabase-js'
+   * import { trace } from '@opentelemetry/api'
+   *
+   * const supabase = createClient(url, key, { tracePropagation: true })
+   * const tracer = trace.getTracer('my-app')
+   *
+   * await tracer.startActiveSpan('fetch-users', async (span) => {
+   *   // Request carries the active trace context.
+   *   const { data, error } = await supabase.from('users').select('*')
+   *   span.end()
+   * })
+   * ```
+   *
+   * @example Advanced — always propagate, even for non-sampled traces
+   * ```ts
+   * const supabase = createClient(url, key, {
+   *   tracePropagation: { enabled: true, respectSamplingDecision: false },
+   * })
+   * ```
+   *
+   * @see https://supabase.com/docs/guides/telemetry/client-side-tracing
+   * @see https://www.w3.org/TR/trace-context/
+   */
+  tracePropagation?: TracePropagationOptions | boolean;
+};
+/**
+ * Helper types for query results.
+ */
+type QueryResult<T> = T extends PromiseLike<infer U> ? U : never;
+type QueryData<T> = T extends PromiseLike<{
+  data: infer U;
+}> ? Exclude<U, null> : never;
+type QueryError = PostgrestError$1;
+/**
+ * Strips internal Supabase metadata from Database types.
+ * Useful for libraries defining generic constraints on Database types.
+ *
+ * @example Stripping internal Supabase metadata
+ * ```typescript
+ * type CleanDB = DatabaseWithoutInternals<Database>
+ * ```
+ */
+type DatabaseWithoutInternals<DB> = Omit<DB, '__InternalSupabase'>;
+//#endregion
+//#region src/lib/helpers.d.ts
+type ResolvedSupabaseClientOptions<SchemaName> = Omit<Required<SupabaseClientOptions<SchemaName>>, 'tracePropagation'> & {
+  tracePropagation: TracePropagationOptions;
+};
+//#endregion
+//#region src/lib/SupabaseAuthClient.d.ts
+declare class SupabaseAuthClient extends AuthClient {
+  constructor(options: SupabaseAuthClientOptions);
+}
+//#endregion
+//#region src/lib/rest/types/common/rpc.d.ts
+type IsMatchingArgs<FnArgs extends GenericFunction['Args'], PassedArgs extends GenericFunction['Args']> = [FnArgs] extends [Record<PropertyKey, never>] ? PassedArgs extends Record<PropertyKey, never> ? true : false : keyof PassedArgs extends keyof FnArgs ? PassedArgs extends FnArgs ? true : false : false;
+type MatchingFunctionArgs<Fn$1 extends GenericFunction, Args extends GenericFunction['Args']> = Fn$1 extends {
+  Args: infer A extends GenericFunction['Args'];
+} ? IsMatchingArgs<A, Args> extends true ? Fn$1 : never : false;
+type FindMatchingFunctionByArgs<FnUnion, Args extends GenericFunction['Args']> = FnUnion extends infer Fn extends GenericFunction ? MatchingFunctionArgs<Fn, Args> : false;
+type TablesAndViews<Schema extends GenericSchema> = Schema['Tables'] & Exclude<Schema['Views'], ''>;
+type UnionToIntersection<U$1> = (U$1 extends any ? (k: U$1) => void : never) extends ((k: infer I) => void) ? I : never;
+type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends (() => infer R) ? R : never;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type ExactMatch<T, S> = [T] extends [S] ? ([S] extends [T] ? true : false) : false;
+type ExtractExactFunction<Fns, Args> = Fns extends infer F ? F extends GenericFunction ? ExactMatch<F['Args'], Args> extends true ? F : never : never : never;
+type IsNever<T> = [T] extends [never] ? true : false;
+type RpcFunctionNotFound<FnName> = {
+  Row: any;
+  Result: {
+    error: true;
+  } & "Couldn't infer function definition matching provided arguments";
+  RelationName: FnName;
+  Relationships: null;
+};
+type CrossSchemaError<TableRef extends string> = {
+  error: true;
+} & `Function returns SETOF from a different schema ('${TableRef}'). Use .overrideTypes<YourReturnType>() to specify the return type explicitly.`;
+type GetRpcFunctionFilterBuilderByArgs<Schema extends GenericSchema, FnName extends string & keyof Schema['Functions'], Args> = {
+  0: Schema['Functions'][FnName];
+  1: IsAny<Schema> extends true ? any : IsNever<Args> extends true ? IsNever<ExtractExactFunction<Schema['Functions'][FnName], Args>> extends true ? LastOf<Schema['Functions'][FnName]> : ExtractExactFunction<Schema['Functions'][FnName], Args> : Args extends Record<PropertyKey, never> ? LastOf<Schema['Functions'][FnName]> : Args extends GenericFunction['Args'] ? IsNever<LastOf<FindMatchingFunctionByArgs<Schema['Functions'][FnName], Args>>> extends true ? LastOf<Schema['Functions'][FnName]> : LastOf<FindMatchingFunctionByArgs<Schema['Functions'][FnName], Args>> : ExtractExactFunction<Schema['Functions'][FnName], Args> extends GenericFunction ? ExtractExactFunction<Schema['Functions'][FnName], Args> : any;
+}[1] extends infer Fn ? IsAny<Fn> extends true ? {
+  Row: any;
+  Result: any;
+  RelationName: FnName;
+  Relationships: null;
+} : Fn extends GenericFunction ? {
+  Row: Fn['SetofOptions'] extends GenericSetofOption ? Fn['SetofOptions']['to'] extends keyof TablesAndViews<Schema> ? TablesAndViews<Schema>[Fn['SetofOptions']['to']]['Row'] : Fn['Returns'] extends any[] ? Fn['Returns'][number] extends Record<string, unknown> ? Fn['Returns'][number] : CrossSchemaError<Fn['SetofOptions']['to'] & string> : Fn['Returns'] extends Record<string, unknown> ? Fn['Returns'] : CrossSchemaError<Fn['SetofOptions']['to'] & string> : Fn['Returns'] extends any[] ? Fn['Returns'][number] extends Record<string, unknown> ? Fn['Returns'][number] : never : Fn['Returns'] extends Record<string, unknown> ? Fn['Returns'] : never;
+  Result: Fn['SetofOptions'] extends GenericSetofOption ? Fn['SetofOptions']['isSetofReturn'] extends true ? Fn['SetofOptions']['isOneToOne'] extends true ? Fn['Returns'][] : Fn['Returns'] : Fn['Returns'] : Fn['Returns'];
+  RelationName: Fn['SetofOptions'] extends GenericSetofOption ? Fn['SetofOptions']['to'] : FnName;
+  Relationships: Fn['SetofOptions'] extends GenericSetofOption ? Fn['SetofOptions']['to'] extends keyof Schema['Tables'] ? Schema['Tables'][Fn['SetofOptions']['to']]['Relationships'] : Fn['SetofOptions']['to'] extends keyof Schema['Views'] ? Schema['Views'][Fn['SetofOptions']['to']]['Relationships'] : null : null;
+} : Fn extends false ? RpcFunctionNotFound<FnName> : RpcFunctionNotFound<FnName> : RpcFunctionNotFound<FnName>;
+//#endregion
+//#region src/SupabaseClient.d.ts
+/**
+ * Supabase Client.
+ *
+ * An isomorphic Javascript client for interacting with Postgres.
+ */
+declare class SupabaseClient<Database = any, SchemaNameOrClientOptions extends (string & keyof Omit<Database, '__InternalSupabase'>) | {
+  PostgrestVersion: string;
+} = ('public' extends keyof Omit<Database, '__InternalSupabase'> ? 'public' : string & keyof Omit<Database, '__InternalSupabase'>), SchemaName extends string & keyof Omit<Database, '__InternalSupabase'> = (SchemaNameOrClientOptions extends string & keyof Omit<Database, '__InternalSupabase'> ? SchemaNameOrClientOptions : 'public' extends keyof Omit<Database, '__InternalSupabase'> ? 'public' : string & keyof Omit<Omit<Database, '__InternalSupabase'>, '__InternalSupabase'>), Schema extends (Omit<Database, '__InternalSupabase'>[SchemaName] extends GenericSchema ? Omit<Database, '__InternalSupabase'>[SchemaName] : never) = (Omit<Database, '__InternalSupabase'>[SchemaName] extends GenericSchema ? Omit<Database, '__InternalSupabase'>[SchemaName] : never), ClientOptions extends {
+  PostgrestVersion: string;
+} = (SchemaNameOrClientOptions extends string & keyof Omit<Database, '__InternalSupabase'> ? Database extends {
+  __InternalSupabase: {
+    PostgrestVersion: string;
+  };
+} ? Database['__InternalSupabase'] : {
+  PostgrestVersion: '12';
+} : SchemaNameOrClientOptions extends {
+  PostgrestVersion: string;
+} ? SchemaNameOrClientOptions : never)> {
+  protected supabaseUrl: string;
+  protected supabaseKey: string;
+  /**
+   * Supabase Auth allows you to create and manage user sessions for access to data that is secured by access policies.
+   */
+  auth: SupabaseAuthClient;
+  realtime: RealtimeClient;
+  /**
+   * Supabase Storage allows you to manage user-generated content, such as photos or videos.
+   */
+  storage: StorageClient;
+  protected realtimeUrl: URL;
+  protected authUrl: URL;
+  protected storageUrl: URL;
+  protected functionsUrl: URL;
+  protected rest: PostgrestClient<Database, ClientOptions, SchemaName>;
+  protected storageKey: string;
+  protected fetch?: Fetch;
+  protected functionsFetch?: Fetch;
+  protected changedAccessToken?: string;
+  protected accessToken?: () => Promise<string | null>;
+  protected headers: Record<string, string>;
+  protected settings?: ResolvedSupabaseClientOptions<SchemaName>;
+  /**
+   * Create a new client for use in the browser.
+   *
+   * @category Initializing
+   *
+   * @param supabaseUrl The unique Supabase URL which is supplied when you create a new project in your project dashboard.
+   * @param supabaseKey The unique Supabase Key which is supplied when you create a new project in your project dashboard.
+   * @param options Optional configuration for the client:
+   * - `db.schema` — You can switch in between schemas. The schema needs to be on the list of exposed schemas inside Supabase.
+   * - `auth.autoRefreshToken` — Set to `true` if you want to automatically refresh the token before expiring.
+   * - `auth.persistSession` — Set to `true` if you want to automatically save the user session into local storage.
+   * - `auth.detectSessionInUrl` — Set to `true` if you want to automatically detect OAuth grants in the URL and sign in the user.
+   * - `realtime` — Options passed along to the realtime-js constructor.
+   * - `storage` — Options passed along to the storage-js constructor.
+   * - `global.fetch` — A custom fetch implementation.
+   * - `global.headers` — Any additional headers to send with each network request.
+   *
+   * @example Creating a client
+   * ```js
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * // Create a single supabase client for interacting with your database
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key')
+   * ```
+   *
+   * @example With a custom domain
+   * ```js
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * // Use a custom domain as the supabase URL
+   * const supabase = createClient('https://my-custom-domain.com', 'your-publishable-key')
+   * ```
+   *
+   * @example With additional parameters
+   * ```js
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const options = {
+   *   db: {
+   *     schema: 'public',
+   *   },
+   *   auth: {
+   *     autoRefreshToken: true,
+   *     persistSession: true,
+   *     detectSessionInUrl: true
+   *   },
+   *   global: {
+   *     headers: { 'x-my-custom-header': 'my-app-name' },
+   *   },
+   * }
+   * const supabase = createClient("https://xyzcompany.supabase.co", "your-publishable-key", options)
+   * ```
+   *
+   * @exampleDescription With custom schemas
+   * By default the API server points to the `public` schema. You can enable other database schemas within the Dashboard.
+   * Go to [Settings > API > Exposed schemas](/dashboard/project/_/settings/api) and add the schema which you want to expose to the API.
+   *
+   * Note: each client connection can only access a single schema, so the code above can access the `other_schema` schema but cannot access the `public` schema.
+   *
+   * @example With custom schemas
+   * ```js
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key', {
+   *   // Provide a custom schema. Defaults to "public".
+   *   db: { schema: 'other_schema' }
+   * })
+   * ```
+   *
+   * @exampleDescription Custom fetch implementation
+   * `supabase-js` uses the runtime's global `fetch` to make HTTP requests,
+   * but an alternative `fetch` implementation can be provided as an option.
+   * This is useful in environments where the global `fetch` is unavailable or where you want to customize request behavior.
+   *
+   * @example Custom fetch implementation
+   * ```js
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key', {
+   *   global: { fetch: fetch.bind(globalThis) }
+   * })
+   * ```
+   *
+   * @exampleDescription React Native options with AsyncStorage
+   * For React Native we recommend using `AsyncStorage` as the storage implementation for Supabase Auth.
+   *
+   * @example React Native options with AsyncStorage
+   * ```js
+   * import 'react-native-url-polyfill/auto'
+   * import { createClient } from '@supabase/supabase-js'
+   * import AsyncStorage from "@react-native-async-storage/async-storage";
+   *
+   * const supabase = createClient("https://xyzcompany.supabase.co", "your-publishable-key", {
+   *   auth: {
+   *     storage: AsyncStorage,
+   *     autoRefreshToken: true,
+   *     persistSession: true,
+   *     detectSessionInUrl: false,
+   *   },
+   * });
+   * ```
+   *
+   * @exampleDescription React Native options with Expo SecureStore
+   * If you wish to encrypt the user's session information, you can use `aes-js` and store the encryption key in Expo SecureStore.
+   * The `aes-js` library, a reputable JavaScript-only implementation of the AES encryption algorithm in CTR mode.
+   * A new 256-bit encryption key is generated using the `react-native-get-random-values` library.
+   * This key is stored inside Expo's SecureStore, while the value is encrypted and placed inside AsyncStorage.
+   *
+   * Please make sure that:
+   * - You keep the `expo-secure-store`, `aes-js` and `react-native-get-random-values` libraries up-to-date.
+   * - Choose the correct [`SecureStoreOptions`](https://docs.expo.dev/versions/latest/sdk/securestore/#securestoreoptions) for your app's needs.
+   *   E.g. [`SecureStore.WHEN_UNLOCKED`](https://docs.expo.dev/versions/latest/sdk/securestore/#securestorewhen_unlocked) regulates when the data can be accessed.
+   * - Carefully consider optimizations or other modifications to the above example, as those can lead to introducing subtle security vulnerabilities.
+   *
+   * @example React Native options with Expo SecureStore
+   * ```ts
+   * import 'react-native-url-polyfill/auto'
+   * import { createClient } from '@supabase/supabase-js'
+   * import AsyncStorage from '@react-native-async-storage/async-storage';
+   * import * as SecureStore from 'expo-secure-store';
+   * import * as aesjs from 'aes-js';
+   * import 'react-native-get-random-values';
+   *
+   * // As Expo's SecureStore does not support values larger than 2048
+   * // bytes, an AES-256 key is generated and stored in SecureStore, while
+   * // it is used to encrypt/decrypt values stored in AsyncStorage.
+   * class LargeSecureStore {
+   *   private async _encrypt(key: string, value: string) {
+   *     const encryptionKey = crypto.getRandomValues(new Uint8Array(256 / 8));
+   *
+   *     const cipher = new aesjs.ModeOfOperation.ctr(encryptionKey, new aesjs.Counter(1));
+   *     const encryptedBytes = cipher.encrypt(aesjs.utils.utf8.toBytes(value));
+   *
+   *     await SecureStore.setItemAsync(key, aesjs.utils.hex.fromBytes(encryptionKey));
+   *
+   *     return aesjs.utils.hex.fromBytes(encryptedBytes);
+   *   }
+   *
+   *   private async _decrypt(key: string, value: string) {
+   *     const encryptionKeyHex = await SecureStore.getItemAsync(key);
+   *     if (!encryptionKeyHex) {
+   *       return encryptionKeyHex;
+   *     }
+   *
+   *     const cipher = new aesjs.ModeOfOperation.ctr(aesjs.utils.hex.toBytes(encryptionKeyHex), new aesjs.Counter(1));
+   *     const decryptedBytes = cipher.decrypt(aesjs.utils.hex.toBytes(value));
+   *
+   *     return aesjs.utils.utf8.fromBytes(decryptedBytes);
+   *   }
+   *
+   *   async getItem(key: string) {
+   *     const encrypted = await AsyncStorage.getItem(key);
+   *     if (!encrypted) { return encrypted; }
+   *
+   *     return await this._decrypt(key, encrypted);
+   *   }
+   *
+   *   async removeItem(key: string) {
+   *     await AsyncStorage.removeItem(key);
+   *     await SecureStore.deleteItemAsync(key);
+   *   }
+   *
+   *   async setItem(key: string, value: string) {
+   *     const encrypted = await this._encrypt(key, value);
+   *
+   *     await AsyncStorage.setItem(key, encrypted);
+   *   }
+   * }
+   *
+   * const supabase = createClient("https://xyzcompany.supabase.co", "your-publishable-key", {
+   *   auth: {
+   *     storage: new LargeSecureStore(),
+   *     autoRefreshToken: true,
+   *     persistSession: true,
+   *     detectSessionInUrl: false,
+   *   },
+   * });
+   * ```
+   *
+   * @example With a database query
+   * ```ts
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key')
+   *
+   * const { data } = await supabase.from('profiles').select('*')
+   * ```
+   *
+   * @exampleDescription With OpenTelemetry tracing
+   * Opt in to W3C trace context propagation so the `trace_id` from your
+   * client-side spans is attached to Supabase requests and appears in API
+   * Gateway and Edge Function logs. Requires `@opentelemetry/api` to be
+   * installed in your application. See [Tracing with the JS SDK](https://supabase.com/docs/guides/telemetry/client-side-tracing).
+   *
+   * @example With OpenTelemetry tracing
+   * ```ts
+   * import { createClient } from '@supabase/supabase-js'
+   * import { trace } from '@opentelemetry/api'
+   *
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key', {
+   *   tracePropagation: true,
+   * })
+   *
+   * const tracer = trace.getTracer('my-app')
+   *
+   * await tracer.startActiveSpan('fetch-users', async (span) => {
+   *   // Outgoing request carries the active trace context.
+   *   const { data, error } = await supabase.from('users').select('*')
+   *   span.end()
+   * })
+   * ```
+   */
+  constructor(supabaseUrl: string, supabaseKey: string, options?: SupabaseClientOptions<SchemaName>);
+  /**
+   * Supabase Functions allows you to deploy and invoke edge functions.
+   */
+  get functions(): FunctionsClient;
+  from<TableName extends string & keyof Schema['Tables'], Table extends Schema['Tables'][TableName]>(relation: TableName): PostgrestQueryBuilder$1<ClientOptions, Schema, Table, TableName>;
+  from<ViewName extends string & keyof Schema['Views'], View extends Schema['Views'][ViewName]>(relation: ViewName): PostgrestQueryBuilder$1<ClientOptions, Schema, View, ViewName>;
+  /**
+   * Select a schema to query or perform an function (rpc) call.
+   *
+   * The schema needs to be on the list of exposed schemas inside Supabase.
+   *
+   * @param schema - The schema to query
+   */
+  schema<DynamicSchema extends string & keyof Omit<Database, '__InternalSupabase'>>(schema: DynamicSchema): PostgrestClient<Database, ClientOptions, DynamicSchema, Database[DynamicSchema] extends GenericSchema ? Database[DynamicSchema] : any>;
+  /**
+   * Perform a function call.
+   *
+   * @param fn - The function name to call
+   * @param args - The arguments to pass to the function call
+   * @param options - Named parameters
+   * @param options.head - When set to `true`, `data` will not be returned.
+   * Useful if you only need the count.
+   * @param options.get - When set to `true`, the function will be called with
+   * read-only access mode.
+   * @param options.count - Count algorithm to use to count rows returned by the
+   * function. Only applicable for [set-returning
+   * functions](https://www.postgresql.org/docs/current/functions-srf.html).
+   *
+   * `"exact"`: Exact but slow count algorithm. Performs a `COUNT(*)` under the
+   * hood.
+   *
+   * `"planned"`: Approximated but fast count algorithm. Uses the Postgres
+   * statistics under the hood.
+   *
+   * `"estimated"`: Uses exact count for low numbers and planned count for high
+   * numbers.
+   */
+  rpc<FnName extends string & keyof Schema['Functions'], Args extends Schema['Functions'][FnName]['Args'] = never, FilterBuilder extends GetRpcFunctionFilterBuilderByArgs<Schema, FnName, Args> = GetRpcFunctionFilterBuilderByArgs<Schema, FnName, Args>>(fn: FnName, args?: Args, options?: {
+    head?: boolean;
+    get?: boolean;
+    count?: 'exact' | 'planned' | 'estimated';
+  }): PostgrestFilterBuilder$1<ClientOptions, Schema, FilterBuilder['Row'], FilterBuilder['Result'], FilterBuilder['RelationName'], FilterBuilder['Relationships'], 'RPC'>;
+  /**
+   * Creates a Realtime channel with Broadcast, Presence, and Postgres Changes.
+   *
+   * @param {string} name - The name of the Realtime channel.
+   * @param {Object} opts - The options to pass to the Realtime channel.
+   *
+   * @category Realtime
+   */
+  channel(name: string, opts?: RealtimeChannelOptions): RealtimeChannel;
+  /**
+   * Returns all Realtime channels.
+   *
+   * @category Realtime
+   *
+   * @example Get all channels
+   * ```js
+   * const channels = supabase.getChannels()
+   * ```
+   */
+  getChannels(): RealtimeChannel[];
+  /**
+   * Unsubscribes and removes Realtime channel from Realtime client.
+   *
+   * @param {RealtimeChannel} channel - The name of the Realtime channel.
+   *
+   *
+   * @category Realtime
+   *
+   * @remarks
+   * - Removing a channel is a great way to maintain the performance of your project's Realtime service as well as your database if you're listening to Postgres changes. Supabase will automatically handle cleanup 30 seconds after a client is disconnected, but unused channels may cause degradation as more clients are simultaneously subscribed.
+   *
+   * @example Removes a channel
+   * ```js
+   * supabase.removeChannel(myChannel)
+   * ```
+   */
+  removeChannel(channel: RealtimeChannel): Promise<RealtimeRemoveChannelResponse>;
+  /**
+   * Unsubscribes and removes all Realtime channels from Realtime client.
+   *
+   * @category Realtime
+   *
+   * @remarks
+   * - Removing channels is a great way to maintain the performance of your project's Realtime service as well as your database if you're listening to Postgres changes. Supabase will automatically handle cleanup 30 seconds after a client is disconnected, but unused channels may cause degradation as more clients are simultaneously subscribed.
+   *
+   * @example Remove all channels
+   * ```js
+   * supabase.removeAllChannels()
+   * ```
+   */
+  removeAllChannels(): Promise<RealtimeRemoveChannelResponse[]>;
+  /**
+   * The raw session token — the custom `accessToken` result or the signed-in user's JWT —
+   * or `null` when there is no session. Unlike {@link _getAccessToken} it does not fall back
+   * to `supabaseKey`, so callers can distinguish "no session" from "has session".
+   */
+  private _getSessionToken;
+  private _getAccessToken;
+  private _initSupabaseAuthClient;
+  private _initRealtimeClient;
+  private _listenForAuthEvents;
+  private _handleTokenChanged;
+}
+//#endregion
+//#region src/index.d.ts
+/**
+ * Creates a new Supabase Client.
+ *
+ * @example Creating a Supabase client
+ * ```ts
+ * import { createClient } from '@supabase/supabase-js'
+ *
+ * const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key')
+ * const { data, error } = await supabase.from('profiles').select('*')
+ * ```
+ */
+declare const createClient: <Database = any, SchemaNameOrClientOptions extends (string & keyof Omit<Database, "__InternalSupabase">) | {
+  PostgrestVersion: string;
+} = ("public" extends keyof Omit<Database, "__InternalSupabase"> ? "public" : string & keyof Omit<Database, "__InternalSupabase">), SchemaName extends string & keyof Omit<Database, "__InternalSupabase"> = (SchemaNameOrClientOptions extends string & keyof Omit<Database, "__InternalSupabase"> ? SchemaNameOrClientOptions : "public" extends keyof Omit<Database, "__InternalSupabase"> ? "public" : string & keyof Omit<Omit<Database, "__InternalSupabase">, "__InternalSupabase">)>(supabaseUrl: string, supabaseKey: string, options?: SupabaseClientOptions<SchemaName>) => SupabaseClient<Database, SchemaNameOrClientOptions, SchemaName>;
+//#endregion
+export { type AuthSession, type AuthUser, type DatabaseWithoutInternals, type FunctionInvokeOptions, FunctionRegion, FunctionsError, FunctionsFetchError, FunctionsHttpError, FunctionsRelayError, type PostgrestBuilder, PostgrestError, type PostgrestFilterBuilder, type PostgrestMaybeSingleResponse, type PostgrestQueryBuilder, type PostgrestResponse, type PostgrestSingleResponse, type PostgrestTransformBuilder, type QueryData, type QueryError, type QueryResult, StorageApiError, SupabaseClient, type SupabaseClientOptions, type TracePropagationOptions, createClient };
+//# sourceMappingURL=index.d.mts.map

node_modules/@supabase/supabase-js/dist/index.mjs

@@ -0,0 +1,927 @@
+import { FunctionRegion, FunctionsClient, FunctionsError, FunctionsFetchError, FunctionsHttpError, FunctionsRelayError } from "@supabase/functions-js";
+import { PostgrestClient, PostgrestError } from "@supabase/postgrest-js";
+import { RealtimeClient } from "@supabase/realtime-js";
+import { StorageApiError, StorageClient } from "@supabase/storage-js";
+import { AuthClient } from "@supabase/auth-js";
+
+export * from "@supabase/realtime-js"
+
+export * from "@supabase/auth-js"
+
+//#region src/lib/version.ts
+const version = "2.110.8";
+
+//#endregion
+//#region src/lib/constants.ts
+let JS_ENV = "";
+let JS_RUNTIME_VERSION;
+if (typeof Deno !== "undefined") {
+	var _Deno$version;
+	JS_ENV = "deno";
+	JS_RUNTIME_VERSION = (_Deno$version = Deno.version) === null || _Deno$version === void 0 ? void 0 : _Deno$version.deno;
+} else if (typeof document !== "undefined") JS_ENV = "web";
+else if (typeof navigator !== "undefined" && navigator.product === "ReactNative") JS_ENV = "react-native";
+else {
+	var _process$version;
+	JS_ENV = "node";
+	const _process = globalThis["process"];
+	JS_RUNTIME_VERSION = _process === null || _process === void 0 || (_process$version = _process["version"]) === null || _process$version === void 0 ? void 0 : _process$version.replace(/^v/, "");
+}
+const _runtimeMeta = [`runtime=${JS_ENV}`];
+if (JS_RUNTIME_VERSION) _runtimeMeta.push(`runtime-version=${JS_RUNTIME_VERSION}`);
+const DEFAULT_HEADERS = { "X-Client-Info": `supabase-js/${version}; ${_runtimeMeta.join("; ")}` };
+const DEFAULT_GLOBAL_OPTIONS = { headers: DEFAULT_HEADERS };
+const DEFAULT_DB_OPTIONS = { schema: "public" };
+const DEFAULT_AUTH_OPTIONS = {
+	autoRefreshToken: true,
+	persistSession: true,
+	detectSessionInUrl: true,
+	flowType: "implicit"
+};
+const DEFAULT_REALTIME_OPTIONS = {};
+const DEFAULT_TRACE_PROPAGATION_OPTIONS = {
+	enabled: false,
+	respectSamplingDecision: true
+};
+
+//#endregion
+//#region ../../../node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
+function __awaiter(thisArg, _arguments, P, generator) {
+	function adopt(value) {
+		return value instanceof P ? value : new P(function(resolve) {
+			resolve(value);
+		});
+	}
+	return new (P || (P = Promise))(function(resolve, reject) {
+		function fulfilled(value) {
+			try {
+				step(generator.next(value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function rejected(value) {
+			try {
+				step(generator["throw"](value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function step(result) {
+			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+		}
+		step((generator = generator.apply(thisArg, _arguments || [])).next());
+	});
+}
+
+//#endregion
+//#region ../../shared/tracing/dist/module/extract.js
+let otelModulePromise = null;
+const OTEL_PKG = "@opentelemetry/api";
+function loadOtel() {
+	if (otelModulePromise === null) otelModulePromise = import(/* webpackIgnore: true */ /* turbopackIgnore: true */ /* @vite-ignore */ OTEL_PKG).catch(() => null);
+	return otelModulePromise;
+}
+/**
+* Extract trace context from the OpenTelemetry API.
+*
+* Returns null if `@opentelemetry/api` is not installed or there is no active
+* trace context. The dynamic import is cached after the first call.
+*
+* @returns Trace context with traceparent, tracestate, and baggage headers, or null if unavailable
+*/
+function extractTraceContext() {
+	return __awaiter(this, void 0, void 0, function* () {
+		try {
+			const otel = yield loadOtel();
+			if (!otel || !otel.propagation || !otel.context) return null;
+			const carrier = {};
+			otel.propagation.inject(otel.context.active(), carrier);
+			const traceparent = carrier["traceparent"];
+			if (!traceparent) return null;
+			return {
+				traceparent,
+				tracestate: carrier["tracestate"],
+				baggage: carrier["baggage"]
+			};
+		} catch (_a) {
+			return null;
+		}
+	});
+}
+
+//#endregion
+//#region ../../shared/tracing/dist/module/parse.js
+/**
+* Parse W3C traceparent header according to the specification.
+*
+* The traceparent header format is: version-traceid-parentid-traceflags
+* - version: 2 hex digits (currently always "00")
+* - traceid: 32 hex digits (128-bit trace identifier)
+* - parentid: 16 hex digits (64-bit span/parent identifier)
+* - traceflags: 2 hex digits (8-bit flags, bit 0 is sampled flag)
+*
+* @param traceparent - The traceparent header value
+* @returns Parsed traceparent object, or null if invalid format
+*
+* @see https://www.w3.org/TR/trace-context/#traceparent-header
+*
+* @example
+* ```typescript
+* const parsed = parseTraceParent('00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01')
+*
+* console.log(parsed)
+* // {
+* //   version: '00',
+* //   traceId: '0af7651916cd43dd8448eb211c80319c',
+* //   parentId: 'b7ad6b7169203331',
+* //   traceFlags: '01',
+* //   isSampled: true
+* // }
+* ```
+*/
+function parseTraceParent(traceparent) {
+	if (!traceparent || typeof traceparent !== "string") return null;
+	const parts = traceparent.split("-");
+	if (parts.length !== 4) return null;
+	const [version$1, traceId, parentId, traceFlags] = parts;
+	if (version$1.length !== 2 || traceId.length !== 32 || parentId.length !== 16 || traceFlags.length !== 2) return null;
+	const hexRegex = /^[0-9a-f]+$/i;
+	if (!hexRegex.test(version$1) || !hexRegex.test(traceId) || !hexRegex.test(parentId) || !hexRegex.test(traceFlags)) return null;
+	if (traceId === "00000000000000000000000000000000" || parentId === "0000000000000000") return null;
+	return {
+		version: version$1,
+		traceId,
+		parentId,
+		traceFlags,
+		isSampled: (parseInt(traceFlags, 16) & 1) === 1
+	};
+}
+
+//#endregion
+//#region ../../shared/tracing/dist/module/validate.js
+/**
+* Check if trace context should be propagated to the target URL.
+*
+* This function checks if the target URL matches any of the configured
+* propagation targets. Targets can be:
+* - String: Exact hostname match or wildcard domain (*.example.com)
+* - RegExp: Pattern matching hostname
+* - Function: Custom logic to determine if URL should receive trace context
+*
+* @param targetUrl - The URL to check
+* @param targets - Array of propagation targets
+* @returns True if trace context should be propagated, false otherwise
+*
+* @example
+* ```typescript
+* const targets = [
+*   'myproject.supabase.co',           // Exact match
+*   '*.supabase.co',                   // Wildcard domain
+*   /.*\.supabase\.co$/,               // Regex pattern
+*   (url) => url.hostname === 'localhost' // Custom function
+* ]
+*
+* shouldPropagateToTarget('https://myproject.supabase.co/rest/v1/table', targets)
+* // true
+*
+* shouldPropagateToTarget('https://evil.com/api', targets)
+* // false
+* ```
+*/
+function shouldPropagateToTarget(targetUrl, targets) {
+	if (!targetUrl || !targets || targets.length === 0) return false;
+	let url;
+	if (targetUrl instanceof URL) url = targetUrl;
+	else try {
+		url = new URL(targetUrl);
+	} catch (error) {
+		return false;
+	}
+	for (const target of targets) try {
+		if (typeof target === "string") {
+			if (matchStringTarget(url.hostname, target)) return true;
+		} else if (target instanceof RegExp) {
+			if (target.test(url.hostname)) return true;
+		} else if (typeof target === "function") {
+			if (target(url)) return true;
+		}
+	} catch (error) {
+		continue;
+	}
+	return false;
+}
+/**
+* Match hostname against string target (exact match or wildcard)
+*
+* @param hostname - The hostname to check
+* @param target - The target pattern (exact or wildcard)
+* @returns True if hostname matches target
+*/
+function matchStringTarget(hostname, target) {
+	if (target === hostname) return true;
+	if (target.startsWith("*.")) {
+		const domain = target.slice(2);
+		if (hostname.endsWith(domain)) {
+			if (hostname === domain || hostname.endsWith("." + domain)) return true;
+		}
+	}
+	return false;
+}
+
+//#endregion
+//#region ../../shared/tracing/dist/module/defaults.js
+/**
+* Generate default propagation targets based on the Supabase project URL.
+*
+* By default, trace context is only propagated to Supabase domains for
+* security. This prevents leaking trace context to potentially malicious
+* third-party services.
+*
+* Wildcard strings (e.g. `*.supabase.co`) are matched with linear string
+* operations rather than regex, avoiding ReDoS risk.
+*
+* @param supabaseUrl - The Supabase project URL
+* @returns Array of default propagation targets
+*/
+function getDefaultPropagationTargets(supabaseUrl) {
+	const targets = [];
+	try {
+		const url = new URL(supabaseUrl);
+		targets.push(url.hostname);
+	} catch (error) {}
+	targets.push("*.supabase.co", "*.supabase.in");
+	targets.push("localhost", "127.0.0.1", "[::1]");
+	return targets;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.103.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.103.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.103.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.103.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.103.0/helpers/objectSpread2.js
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter(function(r$1) {
+			return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+		})), t.push.apply(t, o);
+	}
+	return t;
+}
+function _objectSpread2(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t), !0).forEach(function(r$1) {
+			_defineProperty(e, r$1, t[r$1]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+			Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+		});
+	}
+	return e;
+}
+
+//#endregion
+//#region src/lib/fetch.ts
+const resolveFetch = (customFetch) => {
+	if (customFetch) return (...args) => customFetch(...args);
+	return (...args) => fetch(...args);
+};
+const resolveHeadersConstructor = () => {
+	return Headers;
+};
+/**
+* New-format Supabase API keys (`sb_publishable_…` / `sb_secret_…`) are not JWTs and
+* must never be sent as a Bearer token — they belong only in the `apikey` header.
+* All other keys (legacy JWT keys, `sb_temp_…` temporary keys, unrecognized `sb_`
+* subtypes) keep the Bearer fallback.
+*/
+const isNewApiKey = (key) => key.startsWith("sb_publishable_") || key.startsWith("sb_secret_");
+const TEMP_KEY_PREFIX = "sb_temp_";
+const warnedKeySubtypes = /* @__PURE__ */ new Set();
+/**
+* Warn (once per subtype) when an `sb_` key isn't a subtype this SDK version recognizes.
+* Never throws — the server, not the SDK, decides key validity. The key value is never
+* included in the message.
+*/
+const checkApiKeyFormat = (key) => {
+	var _key$match$, _key$match;
+	if (!key.startsWith("sb_") || isNewApiKey(key) || key.startsWith(TEMP_KEY_PREFIX)) return;
+	const subtype = (_key$match$ = (_key$match = key.match(/^sb_[a-zA-Z0-9]+_/)) === null || _key$match === void 0 ? void 0 : _key$match[0]) !== null && _key$match$ !== void 0 ? _key$match$ : "unknown";
+	if (warnedKeySubtypes.has(subtype)) return;
+	warnedKeySubtypes.add(subtype);
+	console.warn("@supabase/supabase-js: Unrecognized Supabase API key format. The client will proceed and send this key as-is; if you see authentication errors you may need to upgrade @supabase/supabase-js to a version that recognizes this key type.");
+};
+const fetchWithAuth = (supabaseKey, supabaseUrl, getAccessToken, customFetch, tracePropagationOptions, options) => {
+	const fetch$1 = resolveFetch(customFetch);
+	const HeadersConstructor = resolveHeadersConstructor();
+	const traceEnabled = (tracePropagationOptions === null || tracePropagationOptions === void 0 ? void 0 : tracePropagationOptions.enabled) === true;
+	const respectSampling = (tracePropagationOptions === null || tracePropagationOptions === void 0 ? void 0 : tracePropagationOptions.respectSamplingDecision) !== false;
+	const traceTargets = traceEnabled ? getDefaultPropagationTargets(supabaseUrl) : null;
+	const allowKeyAsBearer = !((options === null || options === void 0 ? void 0 : options.omitApiKeyAsBearer) && isNewApiKey(supabaseKey));
+	return async (input, init) => {
+		const realToken = await getAccessToken();
+		let headers = new HeadersConstructor(init === null || init === void 0 ? void 0 : init.headers);
+		if (!headers.has("apikey")) headers.set("apikey", supabaseKey);
+		if (!headers.has("Authorization")) {
+			const bearer = realToken !== null && realToken !== void 0 ? realToken : allowKeyAsBearer ? supabaseKey : null;
+			if (bearer) headers.set("Authorization", `Bearer ${bearer}`);
+		}
+		if (traceTargets) {
+			const traceHeaders = await getTraceHeaders(input, traceTargets, respectSampling);
+			if (traceHeaders) {
+				if (traceHeaders.traceparent && !headers.has("traceparent")) headers.set("traceparent", traceHeaders.traceparent);
+				if (traceHeaders.tracestate && !headers.has("tracestate")) headers.set("tracestate", traceHeaders.tracestate);
+				if (traceHeaders.baggage && !headers.has("baggage")) headers.set("baggage", traceHeaders.baggage);
+			}
+		}
+		return fetch$1(input, _objectSpread2(_objectSpread2({}, init), {}, { headers }));
+	};
+};
+async function getTraceHeaders(input, targets, respectSampling) {
+	if (!shouldPropagateToTarget(typeof input === "string" ? input : input instanceof URL ? input : input.url, targets)) return null;
+	const traceContext = await extractTraceContext();
+	if (!traceContext || !traceContext.traceparent) return null;
+	if (respectSampling) {
+		const parsed = parseTraceParent(traceContext.traceparent);
+		if (parsed && !parsed.isSampled) return null;
+	}
+	return traceContext;
+}
+
+//#endregion
+//#region src/lib/helpers.ts
+function normalizeTracePropagation(value) {
+	return typeof value === "boolean" ? { enabled: value } : value;
+}
+function ensureTrailingSlash(url) {
+	return url.endsWith("/") ? url : url + "/";
+}
+function applySettingDefaults(options, defaults) {
+	var _DEFAULT_GLOBAL_OPTIO, _globalOptions$header, _ref, _tracePropagationOpti, _ref2, _tracePropagationOpti2;
+	const { db: dbOptions, auth: authOptions, realtime: realtimeOptions, global: globalOptions } = options;
+	const { db: DEFAULT_DB_OPTIONS$1, auth: DEFAULT_AUTH_OPTIONS$1, realtime: DEFAULT_REALTIME_OPTIONS$1, global: DEFAULT_GLOBAL_OPTIONS$1 } = defaults;
+	const tracePropagationOptions = normalizeTracePropagation(options.tracePropagation);
+	const DEFAULT_TRACE_PROPAGATION_OPTIONS$1 = normalizeTracePropagation(defaults.tracePropagation);
+	const result = {
+		db: _objectSpread2(_objectSpread2({}, DEFAULT_DB_OPTIONS$1), dbOptions),
+		auth: _objectSpread2(_objectSpread2({}, DEFAULT_AUTH_OPTIONS$1), authOptions),
+		realtime: _objectSpread2(_objectSpread2({}, DEFAULT_REALTIME_OPTIONS$1), realtimeOptions),
+		storage: {},
+		global: _objectSpread2(_objectSpread2(_objectSpread2({}, DEFAULT_GLOBAL_OPTIONS$1), globalOptions), {}, { headers: _objectSpread2(_objectSpread2({}, (_DEFAULT_GLOBAL_OPTIO = DEFAULT_GLOBAL_OPTIONS$1 === null || DEFAULT_GLOBAL_OPTIONS$1 === void 0 ? void 0 : DEFAULT_GLOBAL_OPTIONS$1.headers) !== null && _DEFAULT_GLOBAL_OPTIO !== void 0 ? _DEFAULT_GLOBAL_OPTIO : {}), (_globalOptions$header = globalOptions === null || globalOptions === void 0 ? void 0 : globalOptions.headers) !== null && _globalOptions$header !== void 0 ? _globalOptions$header : {}) }),
+		tracePropagation: {
+			enabled: (_ref = (_tracePropagationOpti = tracePropagationOptions === null || tracePropagationOptions === void 0 ? void 0 : tracePropagationOptions.enabled) !== null && _tracePropagationOpti !== void 0 ? _tracePropagationOpti : DEFAULT_TRACE_PROPAGATION_OPTIONS$1 === null || DEFAULT_TRACE_PROPAGATION_OPTIONS$1 === void 0 ? void 0 : DEFAULT_TRACE_PROPAGATION_OPTIONS$1.enabled) !== null && _ref !== void 0 ? _ref : false,
+			respectSamplingDecision: (_ref2 = (_tracePropagationOpti2 = tracePropagationOptions === null || tracePropagationOptions === void 0 ? void 0 : tracePropagationOptions.respectSamplingDecision) !== null && _tracePropagationOpti2 !== void 0 ? _tracePropagationOpti2 : DEFAULT_TRACE_PROPAGATION_OPTIONS$1 === null || DEFAULT_TRACE_PROPAGATION_OPTIONS$1 === void 0 ? void 0 : DEFAULT_TRACE_PROPAGATION_OPTIONS$1.respectSamplingDecision) !== null && _ref2 !== void 0 ? _ref2 : true
+		},
+		accessToken: async () => ""
+	};
+	if (options.accessToken) result.accessToken = options.accessToken;
+	else delete result.accessToken;
+	return result;
+}
+/**
+* Validates a Supabase client URL
+*
+* @param {string} supabaseUrl - The Supabase client URL string.
+* @returns {URL} - The validated base URL.
+* @throws {Error}
+*/
+function validateSupabaseUrl(supabaseUrl) {
+	const trimmedUrl = supabaseUrl === null || supabaseUrl === void 0 ? void 0 : supabaseUrl.trim();
+	if (!trimmedUrl) throw new Error("supabaseUrl is required.");
+	if (!trimmedUrl.match(/^https?:\/\//i)) throw new Error("Invalid supabaseUrl: Must be a valid HTTP or HTTPS URL.");
+	try {
+		return new URL(ensureTrailingSlash(trimmedUrl));
+	} catch (_unused) {
+		throw Error("Invalid supabaseUrl: Provided URL is malformed.");
+	}
+}
+
+//#endregion
+//#region src/lib/SupabaseAuthClient.ts
+var SupabaseAuthClient = class extends AuthClient {
+	constructor(options) {
+		super(options);
+	}
+};
+
+//#endregion
+//#region src/SupabaseClient.ts
+/**
+* Supabase Client.
+*
+* An isomorphic Javascript client for interacting with Postgres.
+*/
+var SupabaseClient = class {
+	/**
+	* Create a new client for use in the browser.
+	*
+	* @category Initializing
+	*
+	* @param supabaseUrl The unique Supabase URL which is supplied when you create a new project in your project dashboard.
+	* @param supabaseKey The unique Supabase Key which is supplied when you create a new project in your project dashboard.
+	* @param options Optional configuration for the client:
+	* - `db.schema` — You can switch in between schemas. The schema needs to be on the list of exposed schemas inside Supabase.
+	* - `auth.autoRefreshToken` — Set to `true` if you want to automatically refresh the token before expiring.
+	* - `auth.persistSession` — Set to `true` if you want to automatically save the user session into local storage.
+	* - `auth.detectSessionInUrl` — Set to `true` if you want to automatically detect OAuth grants in the URL and sign in the user.
+	* - `realtime` — Options passed along to the realtime-js constructor.
+	* - `storage` — Options passed along to the storage-js constructor.
+	* - `global.fetch` — A custom fetch implementation.
+	* - `global.headers` — Any additional headers to send with each network request.
+	*
+	* @example Creating a client
+	* ```js
+	* import { createClient } from '@supabase/supabase-js'
+	*
+	* // Create a single supabase client for interacting with your database
+	* const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key')
+	* ```
+	*
+	* @example With a custom domain
+	* ```js
+	* import { createClient } from '@supabase/supabase-js'
+	*
+	* // Use a custom domain as the supabase URL
+	* const supabase = createClient('https://my-custom-domain.com', 'your-publishable-key')
+	* ```
+	*
+	* @example With additional parameters
+	* ```js
+	* import { createClient } from '@supabase/supabase-js'
+	*
+	* const options = {
+	*   db: {
+	*     schema: 'public',
+	*   },
+	*   auth: {
+	*     autoRefreshToken: true,
+	*     persistSession: true,
+	*     detectSessionInUrl: true
+	*   },
+	*   global: {
+	*     headers: { 'x-my-custom-header': 'my-app-name' },
+	*   },
+	* }
+	* const supabase = createClient("https://xyzcompany.supabase.co", "your-publishable-key", options)
+	* ```
+	*
+	* @exampleDescription With custom schemas
+	* By default the API server points to the `public` schema. You can enable other database schemas within the Dashboard.
+	* Go to [Settings > API > Exposed schemas](/dashboard/project/_/settings/api) and add the schema which you want to expose to the API.
+	*
+	* Note: each client connection can only access a single schema, so the code above can access the `other_schema` schema but cannot access the `public` schema.
+	*
+	* @example With custom schemas
+	* ```js
+	* import { createClient } from '@supabase/supabase-js'
+	*
+	* const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key', {
+	*   // Provide a custom schema. Defaults to "public".
+	*   db: { schema: 'other_schema' }
+	* })
+	* ```
+	*
+	* @exampleDescription Custom fetch implementation
+	* `supabase-js` uses the runtime's global `fetch` to make HTTP requests,
+	* but an alternative `fetch` implementation can be provided as an option.
+	* This is useful in environments where the global `fetch` is unavailable or where you want to customize request behavior.
+	*
+	* @example Custom fetch implementation
+	* ```js
+	* import { createClient } from '@supabase/supabase-js'
+	*
+	* const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key', {
+	*   global: { fetch: fetch.bind(globalThis) }
+	* })
+	* ```
+	*
+	* @exampleDescription React Native options with AsyncStorage
+	* For React Native we recommend using `AsyncStorage` as the storage implementation for Supabase Auth.
+	*
+	* @example React Native options with AsyncStorage
+	* ```js
+	* import 'react-native-url-polyfill/auto'
+	* import { createClient } from '@supabase/supabase-js'
+	* import AsyncStorage from "@react-native-async-storage/async-storage";
+	*
+	* const supabase = createClient("https://xyzcompany.supabase.co", "your-publishable-key", {
+	*   auth: {
+	*     storage: AsyncStorage,
+	*     autoRefreshToken: true,
+	*     persistSession: true,
+	*     detectSessionInUrl: false,
+	*   },
+	* });
+	* ```
+	*
+	* @exampleDescription React Native options with Expo SecureStore
+	* If you wish to encrypt the user's session information, you can use `aes-js` and store the encryption key in Expo SecureStore.
+	* The `aes-js` library, a reputable JavaScript-only implementation of the AES encryption algorithm in CTR mode.
+	* A new 256-bit encryption key is generated using the `react-native-get-random-values` library.
+	* This key is stored inside Expo's SecureStore, while the value is encrypted and placed inside AsyncStorage.
+	*
+	* Please make sure that:
+	* - You keep the `expo-secure-store`, `aes-js` and `react-native-get-random-values` libraries up-to-date.
+	* - Choose the correct [`SecureStoreOptions`](https://docs.expo.dev/versions/latest/sdk/securestore/#securestoreoptions) for your app's needs.
+	*   E.g. [`SecureStore.WHEN_UNLOCKED`](https://docs.expo.dev/versions/latest/sdk/securestore/#securestorewhen_unlocked) regulates when the data can be accessed.
+	* - Carefully consider optimizations or other modifications to the above example, as those can lead to introducing subtle security vulnerabilities.
+	*
+	* @example React Native options with Expo SecureStore
+	* ```ts
+	* import 'react-native-url-polyfill/auto'
+	* import { createClient } from '@supabase/supabase-js'
+	* import AsyncStorage from '@react-native-async-storage/async-storage';
+	* import * as SecureStore from 'expo-secure-store';
+	* import * as aesjs from 'aes-js';
+	* import 'react-native-get-random-values';
+	*
+	* // As Expo's SecureStore does not support values larger than 2048
+	* // bytes, an AES-256 key is generated and stored in SecureStore, while
+	* // it is used to encrypt/decrypt values stored in AsyncStorage.
+	* class LargeSecureStore {
+	*   private async _encrypt(key: string, value: string) {
+	*     const encryptionKey = crypto.getRandomValues(new Uint8Array(256 / 8));
+	*
+	*     const cipher = new aesjs.ModeOfOperation.ctr(encryptionKey, new aesjs.Counter(1));
+	*     const encryptedBytes = cipher.encrypt(aesjs.utils.utf8.toBytes(value));
+	*
+	*     await SecureStore.setItemAsync(key, aesjs.utils.hex.fromBytes(encryptionKey));
+	*
+	*     return aesjs.utils.hex.fromBytes(encryptedBytes);
+	*   }
+	*
+	*   private async _decrypt(key: string, value: string) {
+	*     const encryptionKeyHex = await SecureStore.getItemAsync(key);
+	*     if (!encryptionKeyHex) {
+	*       return encryptionKeyHex;
+	*     }
+	*
+	*     const cipher = new aesjs.ModeOfOperation.ctr(aesjs.utils.hex.toBytes(encryptionKeyHex), new aesjs.Counter(1));
+	*     const decryptedBytes = cipher.decrypt(aesjs.utils.hex.toBytes(value));
+	*
+	*     return aesjs.utils.utf8.fromBytes(decryptedBytes);
+	*   }
+	*
+	*   async getItem(key: string) {
+	*     const encrypted = await AsyncStorage.getItem(key);
+	*     if (!encrypted) { return encrypted; }
+	*
+	*     return await this._decrypt(key, encrypted);
+	*   }
+	*
+	*   async removeItem(key: string) {
+	*     await AsyncStorage.removeItem(key);
+	*     await SecureStore.deleteItemAsync(key);
+	*   }
+	*
+	*   async setItem(key: string, value: string) {
+	*     const encrypted = await this._encrypt(key, value);
+	*
+	*     await AsyncStorage.setItem(key, encrypted);
+	*   }
+	* }
+	*
+	* const supabase = createClient("https://xyzcompany.supabase.co", "your-publishable-key", {
+	*   auth: {
+	*     storage: new LargeSecureStore(),
+	*     autoRefreshToken: true,
+	*     persistSession: true,
+	*     detectSessionInUrl: false,
+	*   },
+	* });
+	* ```
+	*
+	* @example With a database query
+	* ```ts
+	* import { createClient } from '@supabase/supabase-js'
+	*
+	* const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key')
+	*
+	* const { data } = await supabase.from('profiles').select('*')
+	* ```
+	*
+	* @exampleDescription With OpenTelemetry tracing
+	* Opt in to W3C trace context propagation so the `trace_id` from your
+	* client-side spans is attached to Supabase requests and appears in API
+	* Gateway and Edge Function logs. Requires `@opentelemetry/api` to be
+	* installed in your application. See [Tracing with the JS SDK](https://supabase.com/docs/guides/telemetry/client-side-tracing).
+	*
+	* @example With OpenTelemetry tracing
+	* ```ts
+	* import { createClient } from '@supabase/supabase-js'
+	* import { trace } from '@opentelemetry/api'
+	*
+	* const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key', {
+	*   tracePropagation: true,
+	* })
+	*
+	* const tracer = trace.getTracer('my-app')
+	*
+	* await tracer.startActiveSpan('fetch-users', async (span) => {
+	*   // Outgoing request carries the active trace context.
+	*   const { data, error } = await supabase.from('users').select('*')
+	*   span.end()
+	* })
+	* ```
+	*/
+	constructor(supabaseUrl, supabaseKey, options) {
+		var _settings$auth$storag, _settings$global$head;
+		this.supabaseUrl = supabaseUrl;
+		this.supabaseKey = supabaseKey;
+		const baseUrl = validateSupabaseUrl(supabaseUrl);
+		if (!supabaseKey) throw new Error("supabaseKey is required.");
+		checkApiKeyFormat(supabaseKey);
+		this.realtimeUrl = new URL("realtime/v1", baseUrl);
+		this.realtimeUrl.protocol = this.realtimeUrl.protocol.replace("http", "ws");
+		this.authUrl = new URL("auth/v1", baseUrl);
+		this.storageUrl = new URL("storage/v1", baseUrl);
+		this.functionsUrl = new URL("functions/v1", baseUrl);
+		const defaultStorageKey = `sb-${baseUrl.hostname.split(".")[0]}-auth-token`;
+		const DEFAULTS = {
+			db: DEFAULT_DB_OPTIONS,
+			realtime: DEFAULT_REALTIME_OPTIONS,
+			auth: _objectSpread2(_objectSpread2({}, DEFAULT_AUTH_OPTIONS), {}, { storageKey: defaultStorageKey }),
+			global: DEFAULT_GLOBAL_OPTIONS,
+			tracePropagation: DEFAULT_TRACE_PROPAGATION_OPTIONS
+		};
+		const settings = applySettingDefaults(options !== null && options !== void 0 ? options : {}, DEFAULTS);
+		this.settings = settings;
+		this.storageKey = (_settings$auth$storag = settings.auth.storageKey) !== null && _settings$auth$storag !== void 0 ? _settings$auth$storag : "";
+		this.headers = (_settings$global$head = settings.global.headers) !== null && _settings$global$head !== void 0 ? _settings$global$head : {};
+		if (!settings.accessToken) {
+			var _settings$auth;
+			this.auth = this._initSupabaseAuthClient((_settings$auth = settings.auth) !== null && _settings$auth !== void 0 ? _settings$auth : {}, this.headers, settings.global.fetch);
+		} else {
+			this.accessToken = settings.accessToken;
+			this.auth = new Proxy({}, { get: (_, prop) => {
+				throw new Error(`@supabase/supabase-js: Supabase Client is configured with the accessToken option, accessing supabase.auth.${String(prop)} is not possible`);
+			} });
+		}
+		this.fetch = fetchWithAuth(supabaseKey, supabaseUrl, this._getSessionToken.bind(this), settings.global.fetch, settings.tracePropagation);
+		this.functionsFetch = fetchWithAuth(supabaseKey, supabaseUrl, this._getSessionToken.bind(this), settings.global.fetch, settings.tracePropagation, { omitApiKeyAsBearer: true });
+		this.realtime = this._initRealtimeClient(_objectSpread2({
+			headers: this.headers,
+			accessToken: this._getAccessToken.bind(this),
+			fetch: this.fetch
+		}, settings.realtime));
+		if (this.accessToken) Promise.resolve(this.accessToken()).then((token) => this.realtime.setAuth(token)).catch((e) => console.warn("Failed to set initial Realtime auth token:", e));
+		this.rest = new PostgrestClient(new URL("rest/v1", baseUrl).href, {
+			headers: this.headers,
+			schema: settings.db.schema,
+			fetch: this.fetch,
+			timeout: settings.db.timeout,
+			urlLengthLimit: settings.db.urlLengthLimit
+		});
+		this.storage = new StorageClient(this.storageUrl.href, this.headers, this.fetch, options === null || options === void 0 ? void 0 : options.storage);
+		if (!settings.accessToken) this._listenForAuthEvents();
+	}
+	/**
+	* Supabase Functions allows you to deploy and invoke edge functions.
+	*/
+	get functions() {
+		return new FunctionsClient(this.functionsUrl.href, {
+			headers: this.headers,
+			customFetch: this.functionsFetch
+		});
+	}
+	/**
+	* Perform a query on a table or a view.
+	*
+	* @param relation - The table or view name to query
+	*/
+	from(relation) {
+		return this.rest.from(relation);
+	}
+	/**
+	* Select a schema to query or perform an function (rpc) call.
+	*
+	* The schema needs to be on the list of exposed schemas inside Supabase.
+	*
+	* @param schema - The schema to query
+	*/
+	schema(schema) {
+		return this.rest.schema(schema);
+	}
+	/**
+	* Perform a function call.
+	*
+	* @param fn - The function name to call
+	* @param args - The arguments to pass to the function call
+	* @param options - Named parameters
+	* @param options.head - When set to `true`, `data` will not be returned.
+	* Useful if you only need the count.
+	* @param options.get - When set to `true`, the function will be called with
+	* read-only access mode.
+	* @param options.count - Count algorithm to use to count rows returned by the
+	* function. Only applicable for [set-returning
+	* functions](https://www.postgresql.org/docs/current/functions-srf.html).
+	*
+	* `"exact"`: Exact but slow count algorithm. Performs a `COUNT(*)` under the
+	* hood.
+	*
+	* `"planned"`: Approximated but fast count algorithm. Uses the Postgres
+	* statistics under the hood.
+	*
+	* `"estimated"`: Uses exact count for low numbers and planned count for high
+	* numbers.
+	*/
+	rpc(fn, args = {}, options = {
+		head: false,
+		get: false,
+		count: void 0
+	}) {
+		return this.rest.rpc(fn, args, options);
+	}
+	/**
+	* Creates a Realtime channel with Broadcast, Presence, and Postgres Changes.
+	*
+	* @param {string} name - The name of the Realtime channel.
+	* @param {Object} opts - The options to pass to the Realtime channel.
+	*
+	* @category Realtime
+	*/
+	channel(name, opts = { config: {} }) {
+		return this.realtime.channel(name, opts);
+	}
+	/**
+	* Returns all Realtime channels.
+	*
+	* @category Realtime
+	*
+	* @example Get all channels
+	* ```js
+	* const channels = supabase.getChannels()
+	* ```
+	*/
+	getChannels() {
+		return this.realtime.getChannels();
+	}
+	/**
+	* Unsubscribes and removes Realtime channel from Realtime client.
+	*
+	* @param {RealtimeChannel} channel - The name of the Realtime channel.
+	*
+	*
+	* @category Realtime
+	*
+	* @remarks
+	* - Removing a channel is a great way to maintain the performance of your project's Realtime service as well as your database if you're listening to Postgres changes. Supabase will automatically handle cleanup 30 seconds after a client is disconnected, but unused channels may cause degradation as more clients are simultaneously subscribed.
+	*
+	* @example Removes a channel
+	* ```js
+	* supabase.removeChannel(myChannel)
+	* ```
+	*/
+	removeChannel(channel) {
+		return this.realtime.removeChannel(channel);
+	}
+	/**
+	* Unsubscribes and removes all Realtime channels from Realtime client.
+	*
+	* @category Realtime
+	*
+	* @remarks
+	* - Removing channels is a great way to maintain the performance of your project's Realtime service as well as your database if you're listening to Postgres changes. Supabase will automatically handle cleanup 30 seconds after a client is disconnected, but unused channels may cause degradation as more clients are simultaneously subscribed.
+	*
+	* @example Remove all channels
+	* ```js
+	* supabase.removeAllChannels()
+	* ```
+	*/
+	removeAllChannels() {
+		return this.realtime.removeAllChannels();
+	}
+	/**
+	* The raw session token — the custom `accessToken` result or the signed-in user's JWT —
+	* or `null` when there is no session. Unlike {@link _getAccessToken} it does not fall back
+	* to `supabaseKey`, so callers can distinguish "no session" from "has session".
+	*/
+	async _getSessionToken() {
+		var _this = this;
+		var _data$session$access_, _data$session;
+		if (_this.accessToken) return await _this.accessToken();
+		const { data } = await _this.auth.getSession();
+		return (_data$session$access_ = (_data$session = data.session) === null || _data$session === void 0 ? void 0 : _data$session.access_token) !== null && _data$session$access_ !== void 0 ? _data$session$access_ : null;
+	}
+	async _getAccessToken() {
+		var _this2 = this;
+		var _await$this$_getSessi;
+		return (_await$this$_getSessi = await _this2._getSessionToken()) !== null && _await$this$_getSessi !== void 0 ? _await$this$_getSessi : _this2.supabaseKey;
+	}
+	_initSupabaseAuthClient({ autoRefreshToken, persistSession, detectSessionInUrl, storage, userStorage, storageKey, flowType, lock, debug, throwOnError, experimental, lockAcquireTimeout, skipAutoInitialize }, headers, fetch$1) {
+		const authHeaders = {
+			Authorization: `Bearer ${this.supabaseKey}`,
+			apikey: `${this.supabaseKey}`
+		};
+		return new SupabaseAuthClient({
+			url: this.authUrl.href,
+			headers: _objectSpread2(_objectSpread2({}, authHeaders), headers),
+			storageKey,
+			autoRefreshToken,
+			persistSession,
+			detectSessionInUrl,
+			storage,
+			userStorage,
+			flowType,
+			lock,
+			debug,
+			throwOnError,
+			experimental,
+			fetch: fetch$1,
+			lockAcquireTimeout,
+			skipAutoInitialize,
+			hasCustomAuthorizationHeader: Object.keys(this.headers).some((key) => key.toLowerCase() === "authorization")
+		});
+	}
+	_initRealtimeClient(options) {
+		return new RealtimeClient(this.realtimeUrl.href, _objectSpread2(_objectSpread2({}, options), {}, { params: _objectSpread2(_objectSpread2({}, { apikey: this.supabaseKey }), options === null || options === void 0 ? void 0 : options.params) }));
+	}
+	_listenForAuthEvents() {
+		return this.auth.onAuthStateChange((event, session) => {
+			this._handleTokenChanged(event, "CLIENT", session === null || session === void 0 ? void 0 : session.access_token);
+		});
+	}
+	_handleTokenChanged(event, source, token) {
+		if ((event === "TOKEN_REFRESHED" || event === "SIGNED_IN" || event === "INITIAL_SESSION") && this.changedAccessToken !== token) {
+			this.changedAccessToken = token;
+			this.realtime.setAuth(token);
+		} else if (event === "SIGNED_OUT") {
+			this.realtime.setAuth();
+			if (source == "STORAGE") this.auth.signOut();
+			this.changedAccessToken = void 0;
+		}
+	}
+};
+
+//#endregion
+//#region src/index.ts
+/**
+* Creates a new Supabase Client.
+*
+* @example Creating a Supabase client
+* ```ts
+* import { createClient } from '@supabase/supabase-js'
+*
+* const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key')
+* const { data, error } = await supabase.from('profiles').select('*')
+* ```
+*/
+const createClient = (supabaseUrl, supabaseKey, options) => {
+	return new SupabaseClient(supabaseUrl, supabaseKey, options);
+};
+function shouldShowDeprecationWarning() {
+	if (typeof window !== "undefined" || globalThis["Deno"] !== void 0) return false;
+	const _process = globalThis["process"];
+	if (!_process) return false;
+	const processVersion = _process["version"];
+	if (processVersion === void 0 || processVersion === null) return false;
+	const versionMatch = processVersion.match(/^v(\d+)\./);
+	if (!versionMatch) return false;
+	return parseInt(versionMatch[1], 10) <= 20;
+}
+if (shouldShowDeprecationWarning()) console.warn("⚠️  Node.js 20 and below are deprecated and will no longer be supported in future versions of @supabase/supabase-js. Please upgrade to Node.js 22 or later. For more information, visit: https://github.com/orgs/supabase/discussions/45715");
+
+//#endregion
+export { FunctionRegion, FunctionsError, FunctionsFetchError, FunctionsHttpError, FunctionsRelayError, PostgrestError, StorageApiError, SupabaseClient, createClient };
+//# sourceMappingURL=index.mjs.map