better-supabase 0.14.0 → 0.15.0

package/dist/stats-qCEV5M3B.js

@@ -1,1147 +0,0 @@
-import { c as mapDbError, d as withMaxAffected, n as dbError } from "./errors-03ysrOt4.js";
-import { n as invalidRequest } from "./build-g9wTbQdp.js";
-import { t as lookupOf } from "./lookup-BaP5bI27.js";
-import { d as temporalText } from "./temporal-DLZlWbOi.js";
-import { t as dateText } from "./wire-Bizdxvp-.js";
-import { a as ok, r as err, s as toDbError } from "./result-B3m7xtRY.js";
-import { n as simplifyOrFalse } from "./simplify-DDO0j0LI.js";
-//#region src/compile/postgrest.ts
-/** `false` only for a version string whose major is known to be below 13. */
-function supportsMaxAffected(version) {
-	if (version === void 0) return true;
-	const major = /^v?(\d+)/i.exec(version)?.[1];
-	return major === void 0 || Number(major) >= 13;
-}
-function scalar(value) {
-	if (typeof value === "string") return value;
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	const temporalValue = temporalText(value);
-	if (temporalValue !== void 0) return temporalValue;
-	if (value instanceof Date) return dateText(value);
-	if (typeof value === "bigint") return String(value);
-	if (value === null) return "null";
-	return JSON.stringify(value);
-}
-/** Double-quotes a value for PostgREST lists and logic trees. */
-function quote(value) {
-	return `"${scalar(value).replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
-}
-/**
-* Values PostgREST reads the same with or without quotes in an `in` list:
-* uuids, numbers, ISO dates and times, enum values, slugs and emails. `null`
-* stays quoted, so it keeps meaning the string.
-*/
-const BARE = /^[\w.:+@-]+$/;
-/** An `in` list element; quoted only when it needs to be, as supabase-js does. */
-function listItem(value) {
-	const text = scalar(value);
-	return BARE.test(text) && text.toLowerCase() !== "null" ? text : quote(text);
-}
-const BRACES = /[{}]/;
-function list(values, open, close) {
-	return `${open}${values.map(quote).join(",")}${close}`;
-}
-/** The filter target: the column, or `column->a->>b` for a json path. */
-function target(condition) {
-	const { column, path } = condition;
-	if (!path || path.length === 0) return column;
-	const last = path.length - 1;
-	return `${column}${path.map((key, index) => `${index === last ? "->>" : "->"}${key}`).join("")}`;
-}
-const REGEX_SPECIAL = /[\\^$.|?*+()[\]{}]/;
-/**
-* A LIKE pattern as an anchored POSIX regex. PostgREST reads every `*` in a
-* like value as `%`, so a pattern with a literal `*` goes as `match`.
-*/
-function likeToRegex(pattern) {
-	let regex = "^";
-	for (let index = 0; index < pattern.length; index += 1) {
-		const char = pattern.charAt(index);
-		if (char === "\\" && index + 1 < pattern.length) {
-			index += 1;
-			const next = pattern.charAt(index);
-			regex += REGEX_SPECIAL.test(next) ? `\\${next}` : next;
-		} else if (char === "%") regex += ".*";
-		else if (char === "_") regex += ".";
-		else regex += REGEX_SPECIAL.test(char) ? `\\${char}` : char;
-	}
-	return `${regex}$`;
-}
-function isBoolLike(value) {
-	return value === null || typeof value === "boolean";
-}
-function operatorAndValue(condition, inLogic) {
-	const { op, value } = condition;
-	const plain = (text) => inLogic ? quote(text) : scalar(text);
-	switch (op) {
-		case "eq":
-		case "neq":
-		case "gt":
-		case "gte":
-		case "lt":
-		case "lte":
-		case "match":
-		case "imatch": return {
-			operator: op,
-			value: plain(value)
-		};
-		case "like":
-		case "ilike": {
-			const text = scalar(value);
-			if (!text.includes("*")) return {
-				operator: op,
-				value: plain(text)
-			};
-			return {
-				operator: op === "like" ? "match" : "imatch",
-				value: plain(likeToRegex(text))
-			};
-		}
-		case "in":
-			if (!Array.isArray(value)) invalidRequest("\"in\" needs an array");
-			return {
-				operator: "in",
-				value: `(${value.map(listItem).join(",")})`
-			};
-		case "is":
-			if (!isBoolLike(value)) invalidRequest("\"is\" needs null, true or false");
-			return {
-				operator: "is",
-				value: String(value)
-			};
-		case "contains":
-		case "containedBy":
-		case "overlaps": {
-			const operator = op === "contains" ? "cs" : op === "containedBy" ? "cd" : "ov";
-			if (Array.isArray(value) && !condition.json) {
-				const literal = list(value, "{", "}");
-				return {
-					operator,
-					value: inLogic && BRACES.test(literal.slice(1, -1)) ? quote(literal) : literal
-				};
-			}
-			const json = JSON.stringify(value);
-			return {
-				operator,
-				value: inLogic ? quote(json) : json
-			};
-		}
-		case "fts": return {
-			operator: condition.config ? `wfts(${condition.config})` : "wfts",
-			value: plain(value)
-		};
-		default: return op;
-	}
-}
-var PostgrestCompiler = class {
-	filters = [];
-	orders = [];
-	limits = [];
-	#counter = 0;
-	nextAlias() {
-		this.#counter += 1;
-		return `_bs${this.#counter}`;
-	}
-	/** Compiles a condition at `path` where top-level items are ANDed. */
-	andContext(condition, path, embeds) {
-		switch (condition.kind) {
-			case "and":
-				for (const item of condition.items) this.andContext(item, path, embeds);
-				return;
-			case "column": {
-				const { operator, value } = operatorAndValue(condition, false);
-				this.filters.push({
-					kind: "filter",
-					path: path ? `${path}.${target(condition)}` : target(condition),
-					operator,
-					value
-				});
-				return;
-			}
-			case "not": {
-				const inner = condition.item;
-				if (inner.kind === "column") {
-					const { operator, value } = operatorAndValue(inner, false);
-					this.filters.push({
-						kind: "filter",
-						path: path ? `${path}.${target(inner)}` : target(inner),
-						operator: `not.${operator}`,
-						value
-					});
-					return;
-				}
-				if (inner.kind === "relation") {
-					this.relationAnd(negateRelation(inner), path, embeds);
-					return;
-				}
-				if (inner.kind === "not") {
-					this.andContext(inner.item, path, embeds);
-					return;
-				}
-				this.filters.push({
-					kind: "or",
-					expression: this.logic(condition, embeds),
-					referencedTable: path
-				});
-				return;
-			}
-			case "or":
-				this.filters.push({
-					kind: "or",
-					expression: this.logic(condition, embeds).replace(/^or\(/, "").replace(/\)$/, ""),
-					referencedTable: path
-				});
-				return;
-			case "relation":
-				this.relationAnd(condition, path, embeds);
-				return;
-			default: return condition;
-		}
-	}
-	relationAnd(condition, path, embeds) {
-		if (condition.quantifier === "every" && !condition.where) return;
-		const alias = this.nextAlias();
-		const aliasPath = path ? `${path}.${alias}` : alias;
-		const node = filterEmbed(alias, condition, condition.quantifier === "some");
-		this.withPath(node.children, aliasPath);
-		embeds.push(node);
-		const where = condition.quantifier === "every" && condition.where ? {
-			kind: "not",
-			item: condition.where
-		} : condition.where;
-		if (where) this.andContext(where, aliasPath, node.children);
-		if (condition.quantifier !== "some") this.filters.push({
-			kind: "filter",
-			path: aliasPath,
-			operator: "is",
-			value: "null"
-		});
-	}
-	/** Compiles a condition into a PostgREST logic-tree term. */
-	logic(condition, embeds) {
-		switch (condition.kind) {
-			case "and":
-			case "or": return `${condition.kind}(${condition.items.map((item) => this.logic(item, embeds)).join(",")})`;
-			case "not": {
-				const inner = condition.item;
-				if (inner.kind === "column") {
-					const { operator, value } = operatorAndValue(inner, true);
-					return `${target(inner)}.not.${operator}.${value}`;
-				}
-				if (inner.kind === "relation") return this.logic(negateRelation(inner), embeds);
-				if (inner.kind === "not") return this.logic(inner.item, embeds);
-				return `not.${this.logic(inner, embeds)}`;
-			}
-			case "column": {
-				const { operator, value } = operatorAndValue(condition, true);
-				return `${target(condition)}.${operator}.${value}`;
-			}
-			case "relation": {
-				if (condition.quantifier === "every" && !condition.where) invalidRequest("every({}) must be simplified before compiling");
-				const alias = this.nextAlias();
-				const node = filterEmbed(alias, condition, false);
-				const nodePath = this.pathOf(alias, embeds);
-				this.withPath(node.children, nodePath);
-				embeds.push(node);
-				const where = condition.quantifier === "every" && condition.where ? {
-					kind: "not",
-					item: condition.where
-				} : condition.where;
-				if (where) this.andContext(where, nodePath, node.children);
-				return condition.quantifier === "some" ? `${alias}.not.is.null` : `${alias}.is.null`;
-			}
-			default: return condition;
-		}
-	}
-	#paths;
-	withPath(embeds, path) {
-		(this.#paths ??= /* @__PURE__ */ new WeakMap()).set(embeds, path);
-		return embeds;
-	}
-	pathOf(alias, embeds) {
-		const parent = this.#paths?.get(embeds);
-		return parent ? `${parent}.${alias}` : alias;
-	}
-	include(include, path, embeds) {
-		const aliasPath = path ? `${path}.${include.alias}` : include.alias;
-		const node = {
-			alias: include.alias,
-			target: include.target,
-			relation: include.relation,
-			inner: include.required,
-			columns: include.selection.columns,
-			children: this.withPath([], aliasPath),
-			...include.count === void 0 ? {} : { count: true },
-			...include.selection.aggregate ? { measures: include.selection.aggregate.measures } : {}
-		};
-		embeds.push(node);
-		for (const child of include.selection.includes) this.include(child, aliasPath, node.children);
-		const where = simplifyOrFalse(include.where);
-		if (where.never) {
-			const [first] = include.target.primaryKey;
-			const column = first ? include.target.columns[first]?.db : void 0;
-			if (!column) invalidRequest(`Cannot filter "${include.alias}" to nothing`);
-			this.filters.push({
-				kind: "filter",
-				path: `${aliasPath}.${column}`,
-				operator: "is",
-				value: "null"
-			}, {
-				kind: "filter",
-				path: `${aliasPath}.${column}`,
-				operator: "not.is",
-				value: "null"
-			});
-		} else if (where.condition) this.andContext(where.condition, aliasPath, node.children);
-		for (const term of include.orderBy) this.order(term, aliasPath);
-		if (include.limit !== void 0) this.limits.push({
-			count: include.limit,
-			referencedTable: aliasPath
-		});
-	}
-	/**
-	* Sorts the root rows by a column of a to-one embed, `order=alias(column)`.
-	* Reuses the include of that relation, or adds an empty embed for it.
-	*/
-	relationOrder(term, embeds) {
-		const { relation } = term;
-		if (!relation) return;
-		let alias = embeds.find((node) => node.relation.foreignKey === relation.relation.foreignKey && node.target === relation.target && node.count === void 0 && node.measures === void 0 && node.alias === relation.name)?.alias;
-		if (alias === void 0) {
-			alias = this.nextAlias();
-			embeds.push({
-				alias,
-				target: relation.target,
-				relation: relation.relation,
-				inner: false,
-				columns: [],
-				children: []
-			});
-		}
-		this.order({
-			...term,
-			column: `${alias}(${term.column})`
-		}, void 0);
-	}
-	order(term, referencedTable) {
-		this.orders.push({
-			column: term.column,
-			ascending: term.direction === "asc",
-			nullsFirst: term.nulls === void 0 ? void 0 : term.nulls === "first",
-			referencedTable
-		});
-	}
-};
-function negateRelation(condition) {
-	switch (condition.quantifier) {
-		case "some": return {
-			...condition,
-			quantifier: "none"
-		};
-		case "none": return {
-			...condition,
-			quantifier: "some"
-		};
-		case "every": return {
-			...condition,
-			quantifier: "some",
-			where: condition.where ? {
-				kind: "not",
-				item: condition.where
-			} : void 0
-		};
-		default: return condition.quantifier;
-	}
-}
-function filterEmbed(alias, condition, inner) {
-	return {
-		alias,
-		target: condition.target,
-		relation: condition.relation,
-		inner,
-		columns: [],
-		children: []
-	};
-}
-const columnTexts = /* @__PURE__ */ new WeakMap();
-/** The rendered column list, cached per (shared, immutable) column array. */
-function columnText(columns) {
-	let text = columnTexts.get(columns);
-	if (text === void 0) {
-		text = columns.map(({ alias, column, cast }) => {
-			const source = cast ? `${column}::${cast}` : column;
-			return alias === column ? source : `${alias}:${source}`;
-		}).join(",");
-		columnTexts.set(columns, text);
-	}
-	return text;
-}
-function columnList(columns) {
-	return columns.length > 0 ? [columnText(columns)] : [];
-}
-/** `key:column.sum()::text`, PostgREST's aggregate syntax (PostgREST 12+). */
-function measureList(measures) {
-	return measures.map(({ key, column, fn, cast }) => `${key}:${column}.${fn}()${cast ? `::${cast}` : ""}`);
-}
-function aggregateList(aggregate) {
-	return [...aggregate.count ? ["_count:count()"] : [], ...measureList(aggregate.measures)];
-}
-function renderEmbeds(embeds) {
-	return embeds.map((node) => {
-		const hint = `${node.target.name}!${node.relation.foreignKey}${node.inner ? "!inner" : ""}`;
-		if (node.count) return `${node.alias}:${hint}(count)`;
-		if (node.measures) return `${node.alias}:${hint}(${measureList(node.measures).join(",")})`;
-		const inside = [...columnList(node.columns), ...renderEmbeds(node.children)];
-		return `${node.alias}:${hint}(${inside.join(",")})`;
-	});
-}
-function renderSelect(selection, embeds) {
-	if (!selection.aggregate && embeds.length === 0) return selection.columns.length > 0 ? columnText(selection.columns) : "*";
-	const parts = [
-		...columnList(selection.columns),
-		...selection.aggregate ? aggregateList(selection.aggregate) : [],
-		...renderEmbeds(embeds)
-	];
-	return parts.length > 0 ? parts.join(",") : "*";
-}
-/**
-* PostgREST orders by columns only. `order=count` still sorts groups by their
-* row count: Postgres reads `customers.count` as `count(customers)` when the
-* table has no `count` column. Measures have no such spelling.
-*/
-function aggregateOrder(compiler, term, table) {
-	if (term.aggregate !== "count") invalidRequest(`PostgREST can't sort "${table.key}" by _${term.aggregate}; sort by _count or a groupBy column, or use the postgres adapter`, table.key);
-	if (Object.values(table.columns).some((column) => column.db === "count")) invalidRequest(`PostgREST can't sort "${table.key}" by _count because the table has a column named "count"; sort by a groupBy column or use the postgres adapter`, table.key);
-	compiler.order({
-		...term,
-		column: "count"
-	}, void 0);
-}
-function applyWhere(compiler, condition, embeds) {
-	const where = simplifyOrFalse(condition);
-	if (where.never) return false;
-	if (where.condition) compiler.andContext(where.condition, void 0, embeds);
-	return true;
-}
-/** Compiles an operation into a PostgREST plan. */
-function compilePostgrest(op, options = {}) {
-	const maxAffected = op.kind === "update" || op.kind === "delete" ? op.maxAffected : void 0;
-	if (maxAffected !== void 0) {
-		if (!Number.isInteger(maxAffected) || maxAffected < 0) invalidRequest(`"maxAffected" must be a non-negative integer, got ${maxAffected}`, op.table.key);
-		if (!supportsMaxAffected(options.postgrestVersion)) invalidRequest(`"maxAffected" needs PostgREST 13 or later; postgrestVersion is "${options.postgrestVersion}"`, op.table.key);
-	}
-	const compiler = new PostgrestCompiler();
-	const embeds = compiler.withPath([], void 0);
-	const selection = op.kind === "select" ? op.selection : op.kind === "insert" ? op.returning : op.returning;
-	if (selection) for (const include of selection.includes) compiler.include(include, void 0, embeds);
-	let matches = true;
-	if (op.kind === "select" || op.kind === "update" || op.kind === "delete") {
-		const before = embeds.length;
-		matches = applyWhere(compiler, op.where, embeds);
-		if (op.kind !== "select" && embeds.length > before) invalidRequest(`Relation filters are not supported in ${op.kind} on PostgREST; filter by key instead`, op.table.key);
-	}
-	let range;
-	if (op.kind === "select") {
-		for (const term of op.orderBy) if (term.relation) compiler.relationOrder(term, embeds);
-		else if (term.aggregate) aggregateOrder(compiler, term, op.table);
-		else compiler.order(term, void 0);
-		if (op.offset !== void 0) {
-			const from = op.offset;
-			range = {
-				from,
-				to: op.limit === void 0 ? Number.MAX_SAFE_INTEGER : from + op.limit - 1
-			};
-		} else if (op.limit !== void 0) compiler.limits.push({
-			count: op.limit,
-			referencedTable: void 0
-		});
-	}
-	return {
-		select: selection ? renderSelect(selection, embeds) : void 0,
-		filters: compiler.filters,
-		orders: compiler.orders,
-		limits: compiler.limits,
-		range,
-		never: !matches,
-		...maxAffected === void 0 ? {} : { maxAffected }
-	};
-}
-//#endregion
-//#region src/core/in-chunks.ts
-/** The length of the query string supabase-js sends for `plan`. */
-function queryLength(plan) {
-	let length = plan.select === void 0 ? 0 : 8 + encoded(plan.select);
-	for (const filter of plan.filters) length += filter.kind === "filter" ? encoded(filter.path) + 2 + encoded(`${filter.operator}.${filter.value}`) : 4 + encoded(`(${filter.expression})`) + (filter.referencedTable ? encoded(filter.referencedTable) + 1 : 0);
-	for (const order of plan.orders) length += 24 + encoded(order.column);
-	return length;
-}
-function encoded(text) {
-	return encodeURIComponent(text).length;
-}
-function topLevel(where) {
-	if (!where) return [];
-	return where.kind === "and" ? where.items : [where];
-}
-function isInList(condition) {
-	return condition.kind === "column" && condition.op === "in" && condition.path === void 0 && Array.isArray(condition.value);
-}
-/**
-* Column types whose order JavaScript reproduces without the database's
-* collation.
-*/
-const SORTABLE = /* @__PURE__ */ new Set([
-	"int2",
-	"int4",
-	"int8",
-	"float4",
-	"float8",
-	"numeric",
-	"uuid",
-	"date",
-	"timestamp",
-	"timestamptz",
-	"bool"
-]);
-const TIME = /* @__PURE__ */ new Set([
-	"date",
-	"timestamp",
-	"timestamptz"
-]);
-const NUMERIC = /* @__PURE__ */ new Set([
-	"int2",
-	"int4",
-	"float4",
-	"float8",
-	"numeric"
-]);
-const INTEGER = /^-?\d+$/;
-function sortKind(type) {
-	if (type === "int8") return "bigint";
-	if (NUMERIC.has(type)) return "number";
-	return TIME.has(type) ? "time" : "text";
-}
-/** The `invalid_request` for a request whose URL is over the limit. */
-function tooLong(op, length, max, why) {
-	return dbError("invalid_request", `The request for "${op.table.key}" is ${length} characters, over the ${max} the URL takes, and ${why}`, {
-		table: op.table.key,
-		hint: "Split the in list or paginate, pass a shorter list to a search function, or raise `urlLengthLimit` when every proxy in front of PostgREST accepts longer URLs."
-	});
-}
-/**
-* Splits a read whose query string is over `max` into reads that each fit,
-* along its longest top-level `in` list. Only reads without a limit, offset,
-* count or single row qualify, since chunks can't share those; their rows are
-* disjoint, and an order is re-applied in memory on columns that sort the same
-* in JavaScript.
-*/
-function chunkRead(op, plan, max) {
-	const length = queryLength(plan);
-	if (op.limit !== void 0 || op.offset !== void 0 || op.count !== void 0 || op.head || op.single !== void 0 || op.source !== void 0) return tooLong(op, length, max, "a read with a limit, offset, count or single row can't be split");
-	const items = topLevel(op.where);
-	let longest;
-	for (const condition of items) {
-		if (!isInList(condition)) continue;
-		const seen = /* @__PURE__ */ new Set();
-		const values = [];
-		const texts = [];
-		const sizes = [];
-		let total = 0;
-		let largest = 0;
-		for (const value of condition.value) {
-			const text = listItem(value);
-			if (seen.has(text)) continue;
-			seen.add(text);
-			const size = encoded(text) + 3;
-			values.push(value);
-			texts.push(text);
-			sizes.push(size);
-			total += size;
-			if (size > largest) largest = size;
-		}
-		if (!longest || total > longest.total) longest = {
-			condition,
-			values,
-			texts,
-			sizes,
-			total,
-			largest
-		};
-	}
-	if (!longest) return tooLong(op, length, max, "it has no top-level in list to split");
-	const listLength = encoded(`(${longest.condition.value.map(listItem).join(",")})`);
-	const { byDb } = lookupOf(op.table);
-	const hidden = [];
-	const aliases = new Map(op.selection.columns.map((c) => [c.column, c.alias]));
-	for (const term of op.orderBy) {
-		if (term.relation || aliases.has(term.column)) continue;
-		const alias = `_bs_order${hidden.length}`;
-		const exact = byDb.get(term.column)?.[1].type === "int8";
-		hidden.push({
-			alias,
-			column: term.column,
-			...exact ? { cast: "text" } : {}
-		});
-		aliases.set(term.column, alias);
-	}
-	const hiddenText = (column) => `${column.alias}:${column.column}${column.cast ? `::${column.cast}` : ""}`;
-	const extra = hidden.reduce((sum, column) => sum + encoded(`,${hiddenText(column)}`), 0);
-	const budget = max - (length - listLength) - extra - encoded("()");
-	if (budget < longest.largest) return tooLong(op, length, max, "the rest of the request leaves no room for its in list");
-	let sort;
-	if (op.orderBy.length > 0) {
-		const keys = [];
-		for (const term of op.orderBy) {
-			const type = byDb.get(term.column)?.[1].type ?? "";
-			const alias = aliases.get(term.column);
-			if (term.relation || alias === void 0 || !SORTABLE.has(type) && !term.implicit) return tooLong(op, length, max, `its order on "${term.column}" can't be re-applied after splitting it; order by number, uuid, date or time columns`);
-			const desc = term.direction === "desc";
-			keys.push({
-				alias,
-				desc,
-				nullsFirst: (term.nulls ?? (desc ? "first" : "last")) === "first",
-				kind: sortKind(type)
-			});
-		}
-		sort = (rows) => {
-			const decorated = rows.map((row) => ({
-				row,
-				values: keys.map((key) => sortValue(row[key.alias], key.kind))
-			}));
-			decorated.sort((left, right) => {
-				for (const [index, key] of keys.entries()) {
-					const a = left.values[index];
-					const b = right.values[index];
-					if (a === b) continue;
-					if (a === void 0) return key.nullsFirst ? -1 : 1;
-					if (b === void 0) return key.nullsFirst ? 1 : -1;
-					const order = a < b ? -1 : a > b ? 1 : 0;
-					if (order !== 0) return key.desc ? -order : order;
-				}
-				return 0;
-			});
-			return decorated.map(({ row }) => {
-				for (const column of hidden) delete row[column.alias];
-				return row;
-			});
-		};
-	}
-	const chunks = [];
-	let current = {
-		values: [],
-		texts: []
-	};
-	let used = 0;
-	const list = longest;
-	for (const [index, value] of list.values.entries()) {
-		const size = list.sizes[index] ?? 0;
-		if (current.values.length > 0 && used + size > budget) {
-			chunks.push(current);
-			current = {
-				values: [],
-				texts: []
-			};
-			used = 0;
-		}
-		current.values.push(value);
-		current.texts.push(list.texts[index] ?? "");
-		used += size;
-	}
-	if (current.values.length > 0) chunks.push(current);
-	const full = `(${list.condition.value.map(listItem).join(",")})`;
-	const at = plan.filters.findIndex((filter) => filter.kind === "filter" && filter.operator === "in" && filter.path === list.condition.column && filter.value === full);
-	const select = plan.select === void 0 || hidden.length === 0 ? plan.select : `${plan.select},${hidden.map(hiddenText).join(",")}`;
-	const plans = at === -1 ? void 0 : chunks.map((chunk) => ({
-		...plan,
-		select,
-		filters: plan.filters.map((filter, index) => index === at && filter.kind === "filter" ? {
-			...filter,
-			value: `(${chunk.texts.join(",")})`
-		} : filter)
-	}));
-	return {
-		ops: chunks.map(({ values }) => {
-			const where = items.map((item) => item === list.condition ? {
-				...list.condition,
-				value: values
-			} : item);
-			return {
-				...op,
-				...hidden.length > 0 && { selection: {
-					...op.selection,
-					columns: [...op.selection.columns, ...hidden]
-				} },
-				where: where.length === 1 ? where[0] : {
-					kind: "and",
-					items: where
-				}
-			};
-		}),
-		plans,
-		sort
-	};
-}
-/**
-* A comparable value, or `undefined` for SQL null. Times compare by instant,
-* which text can't do across offsets, with the microseconds `Date.parse` drops
-* appended.
-*/
-function sortValue(value, kind) {
-	if (value === null || value === void 0) return;
-	if (kind === "number") return Number(value);
-	if (kind === "bigint") {
-		if (typeof value === "bigint") return value;
-		if (typeof value === "number" && Number.isInteger(value)) return BigInt(value);
-		if (typeof value === "string" && INTEGER.test(value)) return BigInt(value);
-		return Number(value);
-	}
-	const text = String(value);
-	if (kind === "text") return text;
-	const instant = Date.parse(text);
-	if (Number.isNaN(instant)) return text;
-	const micros = (/\.(\d+)/.exec(text)?.[1] ?? "").slice(3, 6).padEnd(3, "0");
-	return `${String(instant + 864e13).padStart(17, "0")}${micros}`;
-}
-//#endregion
-//#region src/core/timeout.ts
-const NO_DEADLINE = (signal) => ({
-	signal,
-	timedOut: () => false,
-	clear: () => {}
-});
-/**
-* Either signal aborting aborts the result. Uses `AbortSignal.any` where the
-* runtime has it; Hermes and older runtimes get the same behaviour by hand.
-*/
-function anySignal(signals) {
-	if (typeof AbortSignal.any === "function") return {
-		signal: AbortSignal.any([...signals]),
-		detach: () => {}
-	};
-	const controller = new AbortController();
-	const abort = () => {
-		controller.abort();
-	};
-	for (const signal of signals) if (signal.aborted) {
-		abort();
-		return {
-			signal: controller.signal,
-			detach: () => {}
-		};
-	}
-	for (const signal of signals) signal.addEventListener("abort", abort);
-	return {
-		signal: controller.signal,
-		detach: () => {
-			for (const signal of signals) signal.removeEventListener("abort", abort);
-		}
-	};
-}
-/** `true` for a timeout the executors and the repository accept. */
-function isTimeout(value) {
-	return typeof value === "number" && Number.isFinite(value) && value > 0;
-}
-/**
-* `signal` combined with a `timeoutMs` timer. Without a timeout it returns the
-* signal unchanged, so calls without one allocate nothing.
-*/
-function deadline(signal, timeoutMs) {
-	if (timeoutMs === void 0) return NO_DEADLINE(signal);
-	const timer = new AbortController();
-	const handle = setTimeout(() => {
-		timer.abort();
-	}, timeoutMs);
-	const combined = signal ? anySignal([signal, timer.signal]) : {
-		signal: timer.signal,
-		detach: () => {}
-	};
-	return {
-		signal: combined.signal,
-		timedOut: () => timer.signal.aborted && !(signal?.aborted ?? false),
-		clear: () => {
-			clearTimeout(handle);
-			combined.detach();
-		}
-	};
-}
-const NO_TUNING = Object.freeze({});
-/** `invalid_request` text for a bad `timeout` or `retry`, else `undefined`. */
-function invalidTuning(tuning) {
-	if (tuning.timeout !== void 0 && !isTimeout(tuning.timeout)) return `"timeout" must be a positive number of milliseconds, got ${String(tuning.timeout)}`;
-	if (tuning.retry !== void 0 && typeof tuning.retry !== "boolean") return `"retry" must be a boolean, got ${String(tuning.retry)}`;
-}
-/** `timeout` and `retry` from a call's arguments, or why they are invalid. */
-function tuningOf(args) {
-	const timeout = args?.["timeout"];
-	const retry = args?.["retry"];
-	if (timeout === void 0 && retry === void 0) return NO_TUNING;
-	const invalid = invalidTuning({
-		timeout,
-		retry
-	});
-	if (invalid) return { invalid };
-	return {
-		...isTimeout(timeout) ? { timeout } : {},
-		...typeof retry === "boolean" ? { retry } : {}
-	};
-}
-//#endregion
-//#region src/core/postgrest-executor.ts
-function scope(client, schema) {
-	const loose = client;
-	if (schema === "public" || !loose.schema) return loose;
-	let schemas = scopedClients.get(client);
-	if (!schemas) {
-		schemas = /* @__PURE__ */ new Map();
-		scopedClients.set(client, schemas);
-	}
-	let scoped = schemas.get(schema);
-	if (!scoped) {
-		scoped = loose.schema(schema);
-		schemas.set(schema, scoped);
-	}
-	return scoped;
-}
-/**
-* `schema()` builds a new client on every call; one per client and schema is
-* enough.
-*/
-const scopedClients = /* @__PURE__ */ new WeakMap();
-function fromTable(client, schema, table) {
-	return scope(client, schema).from(table);
-}
-/**
-* A POST to the function: arguments such as query vectors are too long for a
-* URL.
-*/
-function fromFunction(client, source, options) {
-	const scoped = scope(client, source.schema);
-	if (!scoped.rpc) throw new TypeError(`better-supabase: the client has no rpc(), needed to read from ${source.name}`);
-	return scoped.rpc(source.name, source.args, options);
-}
-function applyFilters(builder, plan) {
-	let query = builder;
-	for (const filter of plan.filters) query = filter.kind === "filter" ? query.filter(filter.path, filter.operator, filter.value) : query.or(filter.expression, filter.referencedTable ? { referencedTable: filter.referencedTable } : {});
-	return query;
-}
-function applyOrderAndLimits(builder, plan) {
-	let query = builder;
-	for (const order of plan.orders) {
-		const options = { ascending: order.ascending };
-		if (order.nullsFirst !== void 0) options.nullsFirst = order.nullsFirst;
-		if (order.referencedTable) options.referencedTable = order.referencedTable;
-		query = query.order(order.column, options);
-	}
-	for (const limit of plan.limits) query = query.limit(limit.count, limit.referencedTable ? { referencedTable: limit.referencedTable } : {});
-	if (plan.range) query = query.range(plan.range.from, plan.range.to);
-	return query;
-}
-/**
-* A mutation without `returning` reports its row count, `exact` unless the op
-* says otherwise.
-*/
-function countOf(op, plan) {
-	return plan.select === void 0 ? { count: op.count ?? "exact" } : {};
-}
-function bounded(query, op, plan) {
-	if (plan.maxAffected === void 0) return query;
-	if (!query.maxAffected) invalidRequest("\"maxAffected\" needs @supabase/postgrest-js 2 or later", op.table.key);
-	return query.maxAffected(plan.maxAffected);
-}
-function build(client, op, plan) {
-	const base = fromTable(client, op.table.schema, op.table.name);
-	switch (op.kind) {
-		case "select": {
-			const options = {};
-			if (op.count) options.count = op.count;
-			if (op.head) options.head = true;
-			let query = applyOrderAndLimits(applyFilters(op.source ? fromFunction(client, op.source, options).select(plan.select) : base.select(plan.select, options), plan), plan);
-			if (op.single === "one") query = query.single();
-			if (op.single === "maybe") query = query.maybeSingle();
-			return query;
-		}
-		case "insert": {
-			const rows = op.rows.length === 1 ? op.rows[0] : op.rows;
-			const count = countOf(op, plan);
-			let query = op.onConflict ? base.upsert(rows, {
-				onConflict: op.onConflict.columns.join(","),
-				ignoreDuplicates: op.onConflict.action === "ignore",
-				defaultToNull: op.defaultToNull,
-				...count
-			}) : base.insert(rows, {
-				defaultToNull: op.defaultToNull,
-				...count
-			});
-			if (plan.select !== void 0) query = query.select(plan.select);
-			return query;
-		}
-		case "update": {
-			let query = applyFilters(base.update(op.set, countOf(op, plan)), plan);
-			if (plan.select !== void 0) query = query.select(plan.select);
-			return bounded(query, op, plan);
-		}
-		case "delete": {
-			let query = applyFilters(base.delete(countOf(op, plan)), plan);
-			if (plan.select !== void 0) query = query.select(plan.select);
-			return bounded(query, op, plan);
-		}
-		default: return op;
-	}
-}
-function rowsOf(data) {
-	if (data === null || data === void 0) return [];
-	if (Array.isArray(data)) return data;
-	return [data];
-}
-const ONLY_ROWS = /there are only (\d+) rows/;
-/**
-* PostgREST answers a counted read whose offset is past the last row with 416
-* (`PGRST103`); the SQL executor returns no rows and the total.
-*/
-function pastLastRow(op, error) {
-	if (op.kind !== "select" || !op.count || error.code !== "PGRST103") return;
-	const match = ONLY_ROWS.exec(error.details ?? "");
-	return match ? Number(match[1]) : void 0;
-}
-const aborted = () => dbError("aborted", "The request was aborted");
-function tune(builder, signal, retry) {
-	let query = builder;
-	if (signal) query = query.abortSignal(signal);
-	if (retry !== void 0 && query.retry) query = query.retry(retry);
-	return query;
-}
-const timedOut = (ms) => dbError("timeout", `The request timed out after ${ms} ms`);
-const DEFAULT_URL_LENGTH_LIMIT = 6e3;
-/**
-* `urlLengthLimit` on a bare `PostgrestClient`, or on supabase-js's `rest`
-* client.
-*/
-function clientUrlLengthLimit(client) {
-	const loose = client;
-	const limit = loose.urlLengthLimit ?? loose.rest?.urlLengthLimit;
-	return typeof limit === "number" && limit > 0 ? limit : void 0;
-}
-/**
-* The query-string budget for one read: the option, else the lower of 6000 and
-* the client's limit.
-*/
-function resolveUrlLengthLimit(client, options) {
-	const explicit = options.urlLengthLimit;
-	if (explicit !== void 0) return explicit;
-	const fromClient = clientUrlLengthLimit(client);
-	return fromClient === void 0 ? DEFAULT_URL_LENGTH_LIMIT : Math.min(fromClient, DEFAULT_URL_LENGTH_LIMIT);
-}
-/** Chunks of a split read in flight at once. */
-const CHUNK_CONCURRENCY = 4;
-/** Executes IR operations through a supabase-js client. */
-function postgrestExecutor(client, options = {}) {
-	const urlLengthLimit = resolveUrlLengthLimit(client, options);
-	const compileOptions = options.postgrestVersion === void 0 ? {} : { postgrestVersion: options.postgrestVersion };
-	const timeout = isTimeout(options.timeout) ? options.timeout : void 0;
-	const execute = async (op, context) => {
-		let plan;
-		try {
-			plan = compilePostgrest(op, compileOptions);
-		} catch (cause) {
-			return err(toDbError(cause));
-		}
-		if (plan.never) return ok({
-			rows: [],
-			count: 0
-		});
-		if (context.signal?.aborted) return err(aborted());
-		const length = queryLength(plan);
-		if (op.kind !== "select" && length > urlLengthLimit) return err(tooLong(op, length, urlLengthLimit, "a write can't be split into several requests"));
-		if (op.kind === "select" && length > urlLengthLimit) {
-			const chunked = chunkRead(op, plan, urlLengthLimit);
-			if (!("ops" in chunked)) return err(chunked);
-			const results = [];
-			let next = 0;
-			const lane = async () => {
-				while (next < chunked.ops.length) {
-					const index = next;
-					next += 1;
-					const chunk = chunked.ops[index];
-					const chunkPlan = chunked.plans?.[index];
-					const result = await (chunkPlan ? run(chunk, chunkPlan, context) : send(chunk, context));
-					results[index] = result;
-					if (!result.ok) next = chunked.ops.length;
-				}
-			};
-			await Promise.all(Array.from({ length: Math.min(CHUNK_CONCURRENCY, chunked.ops.length) }, lane));
-			const rows = [];
-			for (const result of results) {
-				if (!result.ok) return result;
-				for (const row of result.data.rows) rows.push(row);
-			}
-			return ok({
-				rows: chunked.sort ? chunked.sort(rows) : rows,
-				count: null
-			});
-		}
-		return run(op, plan, context);
-	};
-	const send = (op, context) => {
-		let plan;
-		try {
-			plan = compilePostgrest(op, compileOptions);
-		} catch (cause) {
-			return Promise.resolve(err(toDbError(cause)));
-		}
-		return plan.never ? Promise.resolve(ok({
-			rows: [],
-			count: 0
-		})) : run(op, plan, context);
-	};
-	const run = async (op, plan, context) => {
-		let query;
-		try {
-			query = build(client, op, plan);
-		} catch (cause) {
-			return err(toDbError(cause));
-		}
-		const limit = deadline(context.signal, timeout);
-		try {
-			query = tune(query, limit.signal, context.retry ?? options.retry);
-			const response = await query;
-			if (response.error) {
-				if (limit.timedOut() && timeout !== void 0) return err(timedOut(timeout));
-				if (limit.signal?.aborted) return err(aborted());
-				const total = pastLastRow(op, response.error);
-				if (total !== void 0) return ok({
-					rows: [],
-					count: total
-				});
-				return err(withMaxAffected(mapDbError(response.error, context.errorMappers), plan.maxAffected));
-			}
-			return ok({
-				rows: rowsOf(response.data),
-				count: response.count ?? null
-			});
-		} finally {
-			limit.clear();
-		}
-	};
-	return {
-		name: "postgrest",
-		functionSources: true,
-		execute,
-		async rpc(name, args, context) {
-			if (options.rpcUnavailable !== void 0) return err(dbError("unsupported", options.rpcUnavailable, {
-				code: "RPC_UNAVAILABLE",
-				details: `rpc("${name}")`
-			}));
-			const scoped = scope(client, context.schema);
-			if (!scoped.rpc) return err(toDbError(/* @__PURE__ */ new Error("The client does not support rpc()")));
-			if (context.signal?.aborted) return err(aborted());
-			const called = context.get ? scoped.rpc(name, queryArgs(args), { get: true }) : scoped.rpc(name, args);
-			const built = context.select ? called.select(context.select.map(({ column, cast }) => cast ? `${column}::${cast}` : column).join(",")) : called;
-			const limit = deadline(context.signal, timeout);
-			try {
-				const response = await tune(built, limit.signal, context.retry ?? options.retry);
-				if (response.error) {
-					if (limit.timedOut() && timeout !== void 0) return err(timedOut(timeout));
-					if (limit.signal?.aborted) return err(aborted());
-					return err(mapDbError(response.error, context.errorMappers));
-				}
-				return ok(response.data);
-			} finally {
-				limit.clear();
-			}
-		}
-	};
-}
-/**
-* GET arguments travel in the query string, where supabase-js would print an
-* object as `[object Object]`; json and jsonb parameters take it as JSON.
-*/
-function queryArgs(args) {
-	return Object.fromEntries(Object.entries(args).map(([key, value]) => [key, typeof value === "object" && value !== null && !Array.isArray(value) ? JSON.stringify(value) : value]));
-}
-/** The compiled plan for an operation; useful for debugging and tests. */
-function explainPostgrest(op, options) {
-	return compilePostgrest(op, options);
-}
-//#endregion
-//#region src/core/stats.ts
-const EMPTY_STATS = {
-	calls: 0,
-	waves: 0,
-	tables: [],
-	ms: 0
-};
-/**
-* Counts calls and waves. A recorder with a `parent` also reports to it, so a
-* request-wide recorder sees every scope's calls.
-*/
-var StatsRecorder = class {
-	#parent;
-	#now;
-	#tables = /* @__PURE__ */ new Set();
-	#calls = 0;
-	#waves = 0;
-	#inFlight = 0;
-	#first;
-	#last;
-	constructor(parent, now = () => performance.now()) {
-		this.#parent = parent;
-		this.#now = now;
-	}
-	/** Records a call to `table`; the returned function ends it. */
-	begin(table) {
-		const end = this.#parent?.begin(table);
-		const started = this.#now();
-		if (this.#inFlight === 0) this.#waves += 1;
-		this.#inFlight += 1;
-		this.#calls += 1;
-		this.#tables.add(table);
-		this.#first ??= started;
-		let ended = false;
-		return () => {
-			if (ended) return;
-			ended = true;
-			this.#inFlight -= 1;
-			this.#last = Math.max(this.#last ?? 0, this.#now());
-			end?.();
-		};
-	}
-	/** The totals so far. */
-	snapshot() {
-		return {
-			calls: this.#calls,
-			waves: this.#waves,
-			tables: [...this.#tables],
-			ms: this.#first === void 0 || this.#last === void 0 ? 0 : Math.round((this.#last - this.#first) * 100) / 100
-		};
-	}
-};
-/** Wraps an executor so every call is recorded. */
-function recordStats(executor, recorder) {
-	const wrapped = {
-		name: executor.name,
-		async execute(op, context) {
-			const end = recorder.begin(op.table.key);
-			try {
-				return await executor.execute(op, context);
-			} finally {
-				end();
-			}
-		}
-	};
-	if (executor.rpc) {
-		const rpc = executor.rpc.bind(executor);
-		return {
-			...wrapped,
-			async rpc(name, args, context) {
-				const end = recorder.begin(`${name}()`);
-				try {
-					return await rpc(name, args, context);
-				} finally {
-					end();
-				}
-			}
-		};
-	}
-	return wrapped;
-}
-//#endregion
-export { postgrestExecutor as a, invalidTuning as c, explainPostgrest as i, tuningOf as l, StatsRecorder as n, NO_TUNING as o, recordStats as r, deadline as s, EMPTY_STATS as t, compilePostgrest as u };