MarcWieland
1575 lines
58 KiB
JavaScript
1575 lines
58 KiB
JavaScript
//#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");
|
|
let _supabase_storage_js = require("@supabase/storage-js");
|
|
let _supabase_auth_js = require("@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
|
|
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) {
|
|
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());
|
|
});
|
|
}
|
|
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
|
|
};
|
|
}
|
|
}
|
|
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 {
|
|
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);
|
|
});
|
|
};
|
|
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/main/types.js
|
|
var require_types = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
}));
|
|
|
|
//#endregion
|
|
//#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;
|
|
}
|
|
});
|
|
}
|
|
}));
|
|
|
|
//#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;
|
|
}
|
|
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/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) {
|
|
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 ? (0, import_main.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 (!(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 = (0, import_main.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 _supabase_auth_js.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 _supabase_postgrest_js.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 _supabase_storage_js.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 _supabase_functions_js.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 _supabase_realtime_js.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
|
|
Object.defineProperty(exports, 'FunctionRegion', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return _supabase_functions_js.FunctionRegion;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'FunctionsError', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return _supabase_functions_js.FunctionsError;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'FunctionsFetchError', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return _supabase_functions_js.FunctionsFetchError;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'FunctionsHttpError', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return _supabase_functions_js.FunctionsHttpError;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'FunctionsRelayError', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return _supabase_functions_js.FunctionsRelayError;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'PostgrestError', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return _supabase_postgrest_js.PostgrestError;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'StorageApiError', {
|
|
enumerable: true,
|
|
get: function () {
|
|
return _supabase_storage_js.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, {
|
|
enumerable: true,
|
|
get: function () { return _supabase_auth_js[k]; }
|
|
});
|
|
});
|
|
|
|
Object.keys(_supabase_realtime_js).forEach(function (k) {
|
|
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
|
|
enumerable: true,
|
|
get: function () { return _supabase_realtime_js[k]; }
|
|
});
|
|
});
|
|
|
|
//# sourceMappingURL=index.cjs.map
|