@supabase/supabase-js 2.106.1-beta.0 → 2.106.1-beta.1

package/dist/index.cjs

@@ -1,3 +1,40 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+//#endregion
 let _supabase_functions_js = require("@supabase/functions-js");
 let _supabase_postgrest_js = require("@supabase/postgrest-js");
 let _supabase_realtime_js = require("@supabase/realtime-js");
@@ -5,7 +42,7 @@ let _supabase_storage_js = require("@supabase/storage-js");
 let _supabase_auth_js = require("@supabase/auth-js");
 
 //#region src/lib/version.ts
-const version = "2.106.1-beta.0";
+const version = "2.106.1-beta.1";
 
 //#endregion
 //#region src/lib/constants.ts
@@ -31,6 +68,119 @@ const DEFAULT_TRACE_PROPAGATION_OPTIONS = {
 
 //#endregion
 //#region ../../../node_modules/tslib/tslib.es6.mjs
+var tslib_es6_exports = /* @__PURE__ */ __exportAll({
+	__addDisposableResource: () => __addDisposableResource,
+	__assign: () => __assign,
+	__asyncDelegator: () => __asyncDelegator,
+	__asyncGenerator: () => __asyncGenerator,
+	__asyncValues: () => __asyncValues,
+	__await: () => __await,
+	__awaiter: () => __awaiter,
+	__classPrivateFieldGet: () => __classPrivateFieldGet,
+	__classPrivateFieldIn: () => __classPrivateFieldIn,
+	__classPrivateFieldSet: () => __classPrivateFieldSet,
+	__createBinding: () => __createBinding,
+	__decorate: () => __decorate,
+	__disposeResources: () => __disposeResources,
+	__esDecorate: () => __esDecorate,
+	__exportStar: () => __exportStar,
+	__extends: () => __extends,
+	__generator: () => __generator,
+	__importDefault: () => __importDefault,
+	__importStar: () => __importStar,
+	__makeTemplateObject: () => __makeTemplateObject,
+	__metadata: () => __metadata,
+	__param: () => __param,
+	__propKey: () => __propKey,
+	__read: () => __read,
+	__rest: () => __rest,
+	__rewriteRelativeImportExtension: () => __rewriteRelativeImportExtension,
+	__runInitializers: () => __runInitializers,
+	__setFunctionName: () => __setFunctionName,
+	__spread: () => __spread,
+	__spreadArray: () => __spreadArray,
+	__spreadArrays: () => __spreadArrays,
+	__values: () => __values,
+	default: () => tslib_es6_default
+});
+function __extends(d, b) {
+	if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+	extendStatics(d, b);
+	function __() {
+		this.constructor = d;
+	}
+	d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+function __rest(s, e) {
+	var t = {};
+	for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+	if (s != null && typeof Object.getOwnPropertySymbols === "function") {
+		for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+	}
+	return t;
+}
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+	function accept(f) {
+		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+		return f;
+	}
+	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+	var _, done = false;
+	for (var i = decorators.length - 1; i >= 0; i--) {
+		var context = {};
+		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+		context.addInitializer = function(f) {
+			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+			extraInitializers.push(accept(f || null));
+		};
+		var result = (0, decorators[i])(kind === "accessor" ? {
+			get: descriptor.get,
+			set: descriptor.set
+		} : descriptor[key], context);
+		if (kind === "accessor") {
+			if (result === void 0) continue;
+			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+			if (_ = accept(result.get)) descriptor.get = _;
+			if (_ = accept(result.set)) descriptor.set = _;
+			if (_ = accept(result.init)) initializers.unshift(_);
+		} else if (_ = accept(result)) if (kind === "field") initializers.unshift(_);
+		else descriptor[key] = _;
+	}
+	if (target) Object.defineProperty(target, contextIn.name, descriptor);
+	done = true;
+}
+function __runInitializers(thisArg, initializers, value) {
+	var useValue = arguments.length > 2;
+	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+	return useValue ? value : void 0;
+}
+function __propKey(x) {
+	return typeof x === "symbol" ? x : "".concat(x);
+}
+function __setFunctionName(f, name, prefix) {
+	if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+	return Object.defineProperty(f, "name", {
+		configurable: true,
+		value: prefix ? "".concat(prefix, " ", name) : name
+	});
+}
+function __metadata(metadataKey, metadataValue) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
 function __awaiter(thisArg, _arguments, P, generator) {
 	function adopt(value) {
 		return value instanceof P ? value : new P(function(resolve) {
@@ -58,191 +208,634 @@ function __awaiter(thisArg, _arguments, P, generator) {
 		step((generator = generator.apply(thisArg, _arguments || [])).next());
 	});
 }
-
-//#endregion
-//#region ../../shared/tracing/dist/module/extract.js
-let otelModulePromise = null;
-const OTEL_PKG = "@opentelemetry/api";
-const _dynamicImport = new Function("p", "return import(p)");
-function loadOtel() {
-	if (otelModulePromise === null) otelModulePromise = _dynamicImport(OTEL_PKG).catch(() => null);
-	return otelModulePromise;
+function __generator(thisArg, body) {
+	var _ = {
+		label: 0,
+		sent: function() {
+			if (t[0] & 1) throw t[1];
+			return t[1];
+		},
+		trys: [],
+		ops: []
+	}, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+	return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+		return this;
+	}), g;
+	function verb(n) {
+		return function(v) {
+			return step([n, v]);
+		};
+	}
+	function step(op) {
+		if (f) throw new TypeError("Generator is already executing.");
+		while (g && (g = 0, op[0] && (_ = 0)), _) try {
+			if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+			if (y = 0, t) op = [op[0] & 2, t.value];
+			switch (op[0]) {
+				case 0:
+				case 1:
+					t = op;
+					break;
+				case 4:
+					_.label++;
+					return {
+						value: op[1],
+						done: false
+					};
+				case 5:
+					_.label++;
+					y = op[1];
+					op = [0];
+					continue;
+				case 7:
+					op = _.ops.pop();
+					_.trys.pop();
+					continue;
+				default:
+					if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+						_ = 0;
+						continue;
+					}
+					if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+						_.label = op[1];
+						break;
+					}
+					if (op[0] === 6 && _.label < t[1]) {
+						_.label = t[1];
+						t = op;
+						break;
+					}
+					if (t && _.label < t[2]) {
+						_.label = t[2];
+						_.ops.push(op);
+						break;
+					}
+					if (t[2]) _.ops.pop();
+					_.trys.pop();
+					continue;
+			}
+			op = body.call(thisArg, _);
+		} catch (e) {
+			op = [6, e];
+			y = 0;
+		} finally {
+			f = t = 0;
+		}
+		if (op[0] & 5) throw op[1];
+		return {
+			value: op[0] ? op[1] : void 0,
+			done: true
+		};
+	}
 }
-/**
-* 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* () {
+function __exportStar(m, o) {
+	for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
+}
+function __values(o) {
+	var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+	if (m) return m.call(o);
+	if (o && typeof o.length === "number") return { next: function() {
+		if (o && i >= o.length) o = void 0;
+		return {
+			value: o && o[i++],
+			done: !o
+		};
+	} };
+	throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o, n) {
+	var m = typeof Symbol === "function" && o[Symbol.iterator];
+	if (!m) return o;
+	var i = m.call(o), r, ar = [], e;
+	try {
+		while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+	} catch (error) {
+		e = { error };
+	} finally {
 		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"]
+			if (r && !r.done && (m = i["return"])) m.call(i);
+		} finally {
+			if (e) throw e.error;
+		}
+	}
+	return ar;
+}
+/** @deprecated */
+function __spread() {
+	for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+	return ar;
+}
+/** @deprecated */
+function __spreadArrays() {
+	for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+	for (var r = Array(s), k = 0, i = 0; i < il; i++) for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) r[k] = a[j];
+	return r;
+}
+function __spreadArray(to, from, pack) {
+	if (pack || arguments.length === 2) {
+		for (var i = 0, l = from.length, ar; i < l; i++) if (ar || !(i in from)) {
+			if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+			ar[i] = from[i];
+		}
+	}
+	return to.concat(ar || Array.prototype.slice.call(from));
+}
+function __await(v) {
+	return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+	if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+	var g = generator.apply(thisArg, _arguments || []), i, q = [];
+	return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+		return this;
+	}, i;
+	function awaitReturn(f) {
+		return function(v) {
+			return Promise.resolve(v).then(f, reject);
+		};
+	}
+	function verb(n, f) {
+		if (g[n]) {
+			i[n] = function(v) {
+				return new Promise(function(a, b) {
+					q.push([
+						n,
+						v,
+						a,
+						b
+					]) > 1 || resume(n, v);
+				});
 			};
-		} catch (_a) {
-			return null;
+			if (f) i[n] = f(i[n]);
+		}
+	}
+	function resume(n, v) {
+		try {
+			step(g[n](v));
+		} catch (e) {
+			settle(q[0][3], e);
 		}
+	}
+	function step(r) {
+		r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+	}
+	function fulfill(value) {
+		resume("next", value);
+	}
+	function reject(value) {
+		resume("throw", value);
+	}
+	function settle(f, v) {
+		if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+	}
+}
+function __asyncDelegator(o) {
+	var i, p;
+	return i = {}, verb("next"), verb("throw", function(e) {
+		throw e;
+	}), verb("return"), i[Symbol.iterator] = function() {
+		return this;
+	}, i;
+	function verb(n, f) {
+		i[n] = o[n] ? function(v) {
+			return (p = !p) ? {
+				value: __await(o[n](v)),
+				done: false
+			} : f ? f(v) : v;
+		} : f;
+	}
+}
+function __asyncValues(o) {
+	if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+	var m = o[Symbol.asyncIterator], i;
+	return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+		return this;
+	}, i);
+	function verb(n) {
+		i[n] = o[n] && function(v) {
+			return new Promise(function(resolve, reject) {
+				v = o[n](v), settle(resolve, reject, v.done, v.value);
+			});
+		};
+	}
+	function settle(resolve, reject, d, v) {
+		Promise.resolve(v).then(function(v$1) {
+			resolve({
+				value: v$1,
+				done: d
+			});
+		}, reject);
+	}
+}
+function __makeTemplateObject(cooked, raw) {
+	if (Object.defineProperty) Object.defineProperty(cooked, "raw", { value: raw });
+	else cooked.raw = raw;
+	return cooked;
+}
+function __importStar(mod) {
+	if (mod && mod.__esModule) return mod;
+	var result = {};
+	if (mod != null) {
+		for (var k = ownKeys$1(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+	}
+	__setModuleDefault(result, mod);
+	return result;
+}
+function __importDefault(mod) {
+	return mod && mod.__esModule ? mod : { default: mod };
+}
+function __classPrivateFieldGet(receiver, state, kind, f) {
+	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+	return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+	if (kind === "m") throw new TypeError("Private method is not writable");
+	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+	return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+}
+function __classPrivateFieldIn(state, receiver) {
+	if (receiver === null || typeof receiver !== "object" && typeof receiver !== "function") throw new TypeError("Cannot use 'in' operator on non-object");
+	return typeof state === "function" ? receiver === state : state.has(receiver);
+}
+function __addDisposableResource(env, value, async) {
+	if (value !== null && value !== void 0) {
+		if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+		var dispose, inner;
+		if (async) {
+			if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+			dispose = value[Symbol.asyncDispose];
+		}
+		if (dispose === void 0) {
+			if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+			dispose = value[Symbol.dispose];
+			if (async) inner = dispose;
+		}
+		if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+		if (inner) dispose = function() {
+			try {
+				inner.call(this);
+			} catch (e) {
+				return Promise.reject(e);
+			}
+		};
+		env.stack.push({
+			value,
+			dispose,
+			async
+		});
+	} else if (async) env.stack.push({ async: true });
+	return value;
+}
+function __disposeResources(env) {
+	function fail(e) {
+		env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+		env.hasError = true;
+	}
+	var r, s = 0;
+	function next() {
+		while (r = env.stack.pop()) try {
+			if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+			if (r.dispose) {
+				var result = r.dispose.call(r.value);
+				if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+					fail(e);
+					return next();
+				});
+			} else s |= 1;
+		} catch (e) {
+			fail(e);
+		}
+		if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+		if (env.hasError) throw env.error;
+	}
+	return next();
+}
+function __rewriteRelativeImportExtension(path, preserveJsx) {
+	if (typeof path === "string" && /^\.\.?\//.test(path)) return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+		return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
 	});
+	return path;
 }
+var extendStatics, __assign, __createBinding, __setModuleDefault, ownKeys$1, _SuppressedError, tslib_es6_default;
+var init_tslib_es6 = __esmMin((() => {
+	extendStatics = function(d, b) {
+		extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d$1, b$1) {
+			d$1.__proto__ = b$1;
+		} || function(d$1, b$1) {
+			for (var p in b$1) if (Object.prototype.hasOwnProperty.call(b$1, p)) d$1[p] = b$1[p];
+		};
+		return extendStatics(d, b);
+	};
+	__assign = function() {
+		__assign = Object.assign || function __assign$1(t) {
+			for (var s, i = 1, n = arguments.length; i < n; i++) {
+				s = arguments[i];
+				for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+			}
+			return t;
+		};
+		return __assign.apply(this, arguments);
+	};
+	__createBinding = Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	});
+	__setModuleDefault = Object.create ? (function(o, v) {
+		Object.defineProperty(o, "default", {
+			enumerable: true,
+			value: v
+		});
+	}) : function(o, v) {
+		o["default"] = v;
+	};
+	ownKeys$1 = function(o) {
+		ownKeys$1 = Object.getOwnPropertyNames || function(o$1) {
+			var ar = [];
+			for (var k in o$1) if (Object.prototype.hasOwnProperty.call(o$1, k)) ar[ar.length] = k;
+			return ar;
+		};
+		return ownKeys$1(o);
+	};
+	_SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+		var e = new Error(message);
+		return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+	};
+	tslib_es6_default = {
+		__extends,
+		__assign,
+		__rest,
+		__decorate,
+		__param,
+		__esDecorate,
+		__runInitializers,
+		__propKey,
+		__setFunctionName,
+		__metadata,
+		__awaiter,
+		__generator,
+		__createBinding,
+		__exportStar,
+		__values,
+		__read,
+		__spread,
+		__spreadArrays,
+		__spreadArray,
+		__await,
+		__asyncGenerator,
+		__asyncDelegator,
+		__asyncValues,
+		__makeTemplateObject,
+		__importStar,
+		__importDefault,
+		__classPrivateFieldGet,
+		__classPrivateFieldSet,
+		__classPrivateFieldIn,
+		__addDisposableResource,
+		__disposeResources,
+		__rewriteRelativeImportExtension
+	};
+}));
 
 //#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
-	};
-}
+//#region ../../shared/tracing/dist/main/types.js
+var require_types = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+}));
 
 //#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;
+//#region ../../shared/tracing/dist/main/extract.js
+var require_extract = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports._resetOtelCache = _resetOtelCache;
+	exports.extractTraceContext = extractTraceContext;
+	const tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
+	let otelModulePromise = null;
+	const OTEL_PKG = "@opentelemetry/api";
+	function loadOtel() {
+		if (otelModulePromise === null) otelModulePromise = Promise.resolve(`${OTEL_PKG}`).then((s) => tslib_1.__importStar(require(s))).catch(() => null);
+		return otelModulePromise;
+	}
+	/**
+	* For tests only. Resets the cached OpenTelemetry import.
+	*
+	* @internal
+	*/
+	function _resetOtelCache() {
+		otelModulePromise = null;
+	}
+	/**
+	* 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 tslib_1.__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;
+			}
+		});
 	}
-	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;
+}));
+
+//#endregion
+//#region ../../shared/tracing/dist/main/parse.js
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.parseTraceParent = parseTraceParent;
+	/**
+	* 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/main/validate.js
+var require_validate = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.shouldPropagateToTarget = shouldPropagateToTarget;
+	/**
+	* 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;
 		}
-	} catch (error) {
-		continue;
+		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;
 	}
-	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;
+	/**
+	* 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;
 	}
-	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;
-}
+//#region ../../shared/tracing/dist/main/defaults.js
+var require_defaults = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.getDefaultPropagationTargets = getDefaultPropagationTargets;
+	/**
+	* 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 ../../shared/tracing/dist/main/index.js
+var require_main = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
+	tslib_1.__exportStar(require_types(), exports);
+	tslib_1.__exportStar(require_extract(), exports);
+	tslib_1.__exportStar(require_parse(), exports);
+	tslib_1.__exportStar(require_validate(), exports);
+	tslib_1.__exportStar(require_defaults(), exports);
+}));
 
 //#endregion
 //#region \0@oxc-project+runtime@0.103.0/helpers/typeof.js
+var import_main = require_main();
 function _typeof(o) {
 	"@babel/helpers - typeof";
 	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
@@ -321,7 +914,7 @@ const fetchWithAuth = (supabaseKey, supabaseUrl, getAccessToken, customFetch, tr
 	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 traceTargets = traceEnabled ? (0, import_main.getDefaultPropagationTargets)(supabaseUrl) : null;
 	return async (input, init) => {
 		var _await$getAccessToken;
 		const accessToken = (_await$getAccessToken = await getAccessToken()) !== null && _await$getAccessToken !== void 0 ? _await$getAccessToken : supabaseKey;
@@ -340,11 +933,11 @@ const fetchWithAuth = (supabaseKey, supabaseUrl, getAccessToken, customFetch, tr
 	};
 };
 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 (!(0, import_main.shouldPropagateToTarget)(typeof input === "string" ? input : input instanceof URL ? input : input.url, targets)) return null;
+	const traceContext = await (0, import_main.extractTraceContext)();
 	if (!traceContext || !traceContext.traceparent) return null;
 	if (respectSampling) {
-		const parsed = parseTraceParent(traceContext.traceparent);
+		const parsed = (0, import_main.parseTraceParent)(traceContext.traceparent);
 		if (parsed && !parsed.isSampled) return null;
 	}
 	return traceContext;
@@ -890,6 +1483,7 @@ Object.defineProperty(exports, 'StorageApiError', {
   }
 });
 exports.SupabaseClient = SupabaseClient;
+exports.__toCommonJS = __toCommonJS;
 exports.createClient = createClient;
 Object.keys(_supabase_auth_js).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {