@coffre/db 0.14.5 → 0.15.0

package/dist/postgres-BI3xTnyw.js

@@ -0,0 +1,1718 @@
+import { readFileSync } from "node:fs";
+import { isIP } from "node:net";
+import { checkServerIdentity } from "node:tls";
+import { Buffer as Buffer$1 } from "node:buffer";
+import * as platform from "#postgres/platform";
+//#region src/postgres-js/bytes.ts
+const SIZE = 256;
+/**
+* The message being written: started with its type (`b.typed('Q')`), or
+* none (`b.untyped()`, for the startup's and the SSLRequest's), then its
+* fields, then `end()`, which writes its length and hands it over. One at a
+* time, each written whole before the next starts.
+*/
+var Writer = class {
+	#buffer = Buffer$1.allocUnsafe(SIZE);
+	/** Where the next field goes. */
+	i = 0;
+	/** A message of `type`, a letter: its length, written by `end()`, follows it. */
+	typed(type) {
+		this.#buffer[0] = type.charCodeAt(0);
+		this.i = 5;
+		return this;
+	}
+	untyped() {
+		this.i = 0;
+		return this;
+	}
+	/** Skip `n` bytes, to be written later (`i32(x, at)`). */
+	inc(n) {
+		this.i += n;
+		return this;
+	}
+	str(x) {
+		const length = Buffer$1.byteLength(x);
+		this.#fit(length);
+		this.i += this.#buffer.write(x, this.i, length, "utf8");
+		return this;
+	}
+	i16(x) {
+		this.#fit(2);
+		this.#buffer.writeUInt16BE(x, this.i);
+		this.i += 2;
+		return this;
+	}
+	/** `x` next, or at `at`, a place skipped before. */
+	i32(x, at) {
+		if (at !== void 0) {
+			this.#buffer.writeUInt32BE(x, at);
+			return this;
+		}
+		this.#fit(4);
+		this.#buffer.writeUInt32BE(x, this.i);
+		this.i += 4;
+		return this;
+	}
+	/** `n` zero bytes. */
+	z(n) {
+		this.#fit(n);
+		this.#buffer.fill(0, this.i, this.i + n);
+		this.i += n;
+		return this;
+	}
+	/** The message, its length written at `at`: 1 after a type, 0 for an untyped one. */
+	end(at = 1) {
+		this.#buffer.writeUInt32BE(this.i - at, at);
+		const out = this.#buffer.subarray(0, this.i);
+		this.i = 0;
+		this.#buffer = Buffer$1.allocUnsafe(SIZE);
+		return out;
+	}
+	#fit(n) {
+		if (this.#buffer.length - this.i < n) {
+			const prev = this.#buffer;
+			this.#buffer = Buffer$1.allocUnsafe(prev.length + (prev.length >> 1) + n);
+			prev.copy(this.#buffer);
+		}
+	}
+};
+const b = new Writer();
+//#endregion
+//#region src/postgres-js/errors.ts
+/** An ErrorResponse's fields, by their code. `data type_name` is upstream's spelling, kept. */
+const FIELDS = {
+	83: "severity_local",
+	86: "severity",
+	67: "code",
+	77: "message",
+	68: "detail",
+	72: "hint",
+	80: "position",
+	112: "internal_position",
+	113: "internal_query",
+	87: "where",
+	115: "schema_name",
+	116: "table_name",
+	99: "column_name",
+	100: "data type_name",
+	110: "constraint_name",
+	70: "file",
+	76: "line",
+	82: "routine"
+};
+/** An error Postgres answered, with its fields: `code` (the SQLSTATE), `detail`, `constraint_name`… */
+var PostgresError = class extends Error {
+	constructor(fields) {
+		super(fields.message);
+		this.name = this.constructor.name;
+		Object.assign(this, fields);
+	}
+};
+/** The connection lost, never made or ended (`CONNECTION_CLOSED`, `CONNECT_TIMEOUT`…), naming where it was to. */
+function connection(code, options) {
+	const where = options.path ?? options.host + ":" + options.port;
+	const error = Object.assign(/* @__PURE__ */ new Error("write " + code + " " + where), {
+		code,
+		errno: code,
+		address: options.path ?? options.host,
+		...options.path ? {} : { port: options.port }
+	});
+	Error.captureStackTrace(error, connection);
+	return error;
+}
+function postgres$1(fields) {
+	const error = new PostgresError(fields);
+	Error.captureStackTrace(error, postgres$1);
+	return error;
+}
+function generic(code, message) {
+	const error = Object.assign(/* @__PURE__ */ new Error(code + ": " + message), { code });
+	Error.captureStackTrace(error, generic);
+	return error;
+}
+function notSupported(name) {
+	const error = Object.assign(/* @__PURE__ */ new Error(name + " (B) is not supported"), {
+		code: "MESSAGE_NOT_SUPPORTED",
+		name
+	});
+	Error.captureStackTrace(error, notSupported);
+	return error;
+}
+//#endregion
+//#region src/postgres-js/queue.ts
+/** A queue that takes from either end, and lets go of what it took. */
+var Queue = class {
+	#xs = [];
+	#index = 0;
+	get length() {
+		return this.#xs.length - this.#index;
+	}
+	push(x) {
+		this.#xs.push(x);
+		return x;
+	}
+	remove(x) {
+		const index = this.#xs.indexOf(x);
+		if (index === -1) return null;
+		this.#xs.splice(index, 1);
+		return x;
+	}
+	pop() {
+		if (this.#xs.length === this.#index) return void 0;
+		const out = this.#xs.pop();
+		if (this.#index === this.#xs.length) this.#clear();
+		return out;
+	}
+	shift() {
+		const out = this.#xs[this.#index++];
+		if (this.#index === this.#xs.length) this.#clear();
+		else this.#xs[this.#index - 1] = void 0;
+		return out;
+	}
+	#clear() {
+		this.#index = 0;
+		this.#xs = [];
+	}
+};
+//#endregion
+//#region src/postgres-js/result.ts
+/**
+* A statement's rows, with what its CommandComplete said beside them: `count`
+* (rows inserted, updated, deleted or returned), `command`, and `state`, the
+* backend that ran it. Not enumerable, so that a result spreads as its rows.
+*/
+var Result = class extends Array {
+	constructor() {
+		super();
+		Object.defineProperties(this, {
+			count: {
+				value: null,
+				writable: true
+			},
+			state: {
+				value: null,
+				writable: true
+			},
+			command: {
+				value: null,
+				writable: true
+			},
+			columns: {
+				value: null,
+				writable: true
+			},
+			statement: {
+				value: null,
+				writable: true
+			}
+		});
+	}
+	/** What `map`, `filter` and the like make: a plain array. */
+	static get [Symbol.species]() {
+		return Array;
+	}
+};
+//#endregion
+//#region src/postgres-js/types.ts
+/**
+* The types read and written by default, as upstream's `types.js`: each one's
+* oid when sent (`to`), the oids read as it (`from`), and how.
+*/
+const TYPES = [
+	{
+		to: 25,
+		from: [],
+		serialize: (x) => String(x)
+	},
+	{
+		to: 0,
+		from: [
+			21,
+			23,
+			26,
+			700,
+			701
+		],
+		serialize: (x) => String(x),
+		parse: (x) => +x
+	},
+	{
+		to: 114,
+		from: [114, 3802],
+		serialize: (x) => JSON.stringify(x),
+		parse: (x) => JSON.parse(x)
+	},
+	{
+		to: 16,
+		from: [16],
+		serialize: (x) => x === true ? "t" : "f",
+		parse: (x) => x === "t"
+	},
+	{
+		to: 1184,
+		from: [
+			1082,
+			1114,
+			1184
+		],
+		serialize: (x) => (x instanceof Date ? x : new Date(x)).toISOString(),
+		parse: (x) => new Date(x)
+	},
+	{
+		to: 17,
+		from: [17],
+		serialize: (x) => "\\x" + Buffer$1.from(x).toString("hex"),
+		parse: (x) => Buffer$1.from(x.slice(2), "hex")
+	}
+];
+/** A client's own parsers and serializers, made from the defaults: it may change them (`options.parsers[oid] = …`). */
+function defaultTypes() {
+	const parsers = {};
+	const serializers = {};
+	for (const type of TYPES) {
+		for (const oid of type.from) parsers[oid] = type.parse;
+		serializers[type.to] = type.serialize;
+		for (const oid of type.from) serializers[oid] = type.serialize;
+	}
+	return {
+		parsers,
+		serializers
+	};
+}
+/**
+* The type a value is sent as, which a parameter's serializer goes by: 0,
+* none, for the server to type its text, but for a date, bytes, a boolean or
+* a bigint. An array goes by its first element (porsager/postgres#1225; coffre
+* sends arrays as their text, `asPgSends` in postgres.ts).
+*/
+function inferType(x) {
+	return x instanceof Date ? 1184 : x instanceof Uint8Array ? 17 : x === true || x === false ? 16 : typeof x === "bigint" ? 20 : Array.isArray(x) ? inferType(x[0]) : 0;
+}
+//#endregion
+//#region src/postgres-js/connection.ts
+const isReservation = (waiting) => "reserve" in waiting;
+let uid = 1;
+const Sync = b.typed("S").end();
+const Flush = b.typed("H").end();
+const SSLRequest = b.untyped().inc(4).i32(80877103).end(0);
+const ExecuteOnly = b.typed("E").str("\0").i32(0).end();
+const ExecuteUnnamed = Buffer$1.concat([ExecuteOnly, Sync]);
+const BindNothing = b.typed("B").str("\0").str("\0").i16(0).i16(0).i16(0).end();
+const DescribeUnnamed = b.typed("D").str("S").str("\0").end();
+const noop = () => {};
+/** A connection, closed, in `queue`, the pool's queue of closed ones. */
+function createConnection(options, queue, { onopen, onend, onclose }) {
+	const { sslnegotiation, ssl, max, user, database, parsers, serializers, onnotice, max_pipeline, keep_alive, backoff } = options;
+	const sent = new Queue();
+	const id = uid++;
+	const backend = {
+		pid: null,
+		secret: null
+	};
+	const idleTimer = timer(end, options.idle_timeout);
+	const lifeTimer = timer(end, options.max_lifetime);
+	const connectTimer = timer(connectTimedOut, options.connect_timeout);
+	let socket = null;
+	let errorResponse = null;
+	let result = new Result();
+	let results = null;
+	let incoming = Buffer$1.alloc(0);
+	let incomings = null;
+	let closedTime = 0;
+	let remaining = 0;
+	let length = 0;
+	let delay = 0;
+	let rows = 0;
+	let serverSignature = null;
+	let nextWriteTimer = null;
+	let terminated = false;
+	/** A dial asked for after a close (`reconnect`), not made yet: a forced terminate takes it back. */
+	let redial = null;
+	let initial = null;
+	let ending = null;
+	let chunk = null;
+	let ended = null;
+	let nonce = null;
+	/** The statement answering now; those sent after it, pipelined, wait in `sent`. */
+	let query = null;
+	const connection$1 = {
+		queue,
+		idleTimer,
+		reserved: null,
+		onclose: null,
+		connect(first) {
+			initial = first;
+			reconnect();
+		},
+		terminate,
+		execute,
+		end,
+		release,
+		id
+	};
+	queue.push(connection$1);
+	return connection$1;
+	async function createSocket() {
+		let x;
+		try {
+			x = options.socket ? await options.socket() : platform.tcp(options.path ? { path: options.path } : {
+				host: options.host,
+				port: options.port,
+				tls: ssl !== false
+			}, ssl ? () => void secure().catch(openingFailed) : connected);
+		} catch (e) {
+			error(e);
+			closed(true);
+			return null;
+		}
+		x.on("error", error);
+		x.on("close", closed);
+		x.on("drain", drain);
+		return x;
+	}
+	function execute(q) {
+		if (terminated) {
+			queryError(q, connection("CONNECTION_DESTROYED", options));
+			return false;
+		}
+		let message;
+		try {
+			build(q);
+			message = toBuffer(q);
+			if (typeof options.debug === "function") {
+				if (q.begin !== null) options.debug(id, q.begin, [], []);
+				for (const member of q.group ?? [q]) options.debug(id, member.text, member.args, member.statement.types);
+			}
+		} catch (e) {
+			queryError(q, e);
+			if (query === null) {
+				query = q;
+				write(Sync);
+			}
+			return true;
+		}
+		if (query) sent.push(q);
+		else query = q;
+		return write(message) && !q.describeFirst && q.begin === null && sent.length < max_pipeline;
+	}
+	function toBuffer(q) {
+		if (q.parameters.length >= 65534) throw generic("MAX_PARAMETERS_EXCEEDED", "Max number of parameters (65534) exceeded");
+		if (q.options.simple) return b.typed("Q").str((q.begin === null ? "" : q.begin + ";\n") + q.statement.string + "\0").end();
+		if (q.group !== null) return Buffer$1.concat([...q.group.flatMap((member) => [
+			Parse(member),
+			DescribeUnnamed,
+			Bind(member.parameters, member.statement.types),
+			ExecuteOnly
+		]), Sync]);
+		const statement = q.describeFirst ? [
+			Parse(q),
+			DescribeUnnamed,
+			Flush
+		] : [
+			Parse(q),
+			DescribeUnnamed,
+			bound(q)
+		];
+		return Buffer$1.concat(q.begin === null ? statement : [
+			b.typed("P").str("\0").str(q.begin + "\0").i16(0).end(),
+			BindNothing,
+			ExecuteOnly,
+			...statement
+		]);
+	}
+	/** The statement's values, bound, and its execution: what follows its Parse once the values can be written. */
+	function bound(q) {
+		return Buffer$1.concat([Bind(q.parameters, q.statement.types), ExecuteUnnamed]);
+	}
+	function build(q) {
+		if (q.group !== null) {
+			for (const [index, member] of q.group.entries()) {
+				q.member = index;
+				built(member);
+				q.parameters = member.parameters;
+				if (member.parameters.length >= 65534) throw generic("MAX_PARAMETERS_EXCEEDED", "Max number of parameters (65534) exceeded");
+				if (typedByServer(member.parameters, member.statement.types)) throw generic("GROUP_UNTYPED", "A statement of a group has a value whose type only the server can say");
+			}
+			return startMember(q, 0);
+		}
+		built(q);
+		q.describeFirst = q.parameters.length > 0 && typedByServer(q.parameters, q.statement.types);
+	}
+	/** A statement's values as sent, and their types as the client knows them (0 for the server to say). */
+	function built(statement) {
+		const parameters = [];
+		const types = [];
+		for (const x of statement.args) {
+			if (x === void 0) throw generic("UNDEFINED_VALUE", "Undefined values are not allowed");
+			parameters.push(x);
+			types.push(inferType(x));
+		}
+		statement.parameters = parameters;
+		statement.statement = {
+			string: statement.text,
+			types,
+			columns: null
+		};
+	}
+	/** A group's statement `index`, the one answering from now: its rows are read as it describes them. */
+	function startMember(q, index) {
+		const member = q.group[index];
+		q.member = index;
+		q.statement = member.statement;
+		q.arrays = member.arrays;
+		q.parameters = member.parameters;
+	}
+	function write(x) {
+		chunk = chunk ? Buffer$1.concat([chunk, x]) : Buffer$1.from(x);
+		if (chunk.length >= 1024) return nextWrite();
+		if (nextWriteTimer === null) nextWriteTimer = platform.setImmediate(nextWrite);
+		return true;
+	}
+	function nextWrite() {
+		const x = socket.write(chunk);
+		if (nextWriteTimer !== null) platform.clearImmediate(nextWriteTimer);
+		chunk = nextWriteTimer = null;
+		return x;
+	}
+	function connectTimedOut() {
+		errored(connection("CONNECT_TIMEOUT", options));
+		socket.destroy();
+	}
+	async function secure() {
+		if (sslnegotiation !== "direct") {
+			const at = socket;
+			write(SSLRequest);
+			await new Promise((resolve) => at.once("data", () => resolve()));
+			if (socket !== at) return;
+		}
+		const tls = { servername: options.socket || options.path || platform.isIP(options.host) ? void 0 : options.host };
+		if (sslnegotiation === "direct") tls.ALPNProtocols = ["postgresql"];
+		if (ssl) Object.assign(tls, ssl);
+		const plain = socket;
+		plain.removeAllListeners();
+		try {
+			socket = platform.startTls(plain, tls);
+		} catch (e) {
+			plain.on("close", closed);
+			throw e;
+		}
+		socket.on("secureConnect", connected);
+		socket.on("error", error);
+		socket.on("close", closed);
+		socket.on("drain", drain);
+	}
+	function drain() {
+		if (!query && !connection$1.reserved) onopen(connection$1);
+	}
+	function data(x) {
+		if (incomings) {
+			incomings.push(x);
+			remaining -= x.length;
+			if (remaining > 0) return;
+		}
+		incoming = incomings ? Buffer$1.concat(incomings, length - remaining) : incoming.length === 0 ? x : Buffer$1.concat([incoming, x], incoming.length + x.length);
+		while (incoming.length > 4) {
+			length = incoming.readUInt32BE(1);
+			if (length >= incoming.length) {
+				remaining = length - incoming.length;
+				incomings = [incoming];
+				break;
+			}
+			try {
+				handle(incoming.subarray(0, length + 1));
+			} catch (e) {
+				if (query?.describeFirst) write(Sync);
+				errored(e);
+			}
+			incoming = incoming.subarray(length + 1);
+			remaining = 0;
+			incomings = null;
+		}
+	}
+	async function connect() {
+		terminated = false;
+		socket ??= await createSocket();
+		if (!socket) return;
+		connectTimer.start();
+		if (options.socket) return ssl ? secure().catch(openingFailed) : connected();
+	}
+	function reconnect() {
+		redial = setTimeout(() => {
+			redial = null;
+			connect();
+		}, closedTime ? Math.max(0, closedTime + delay - platform.now()) : 0);
+	}
+	function connected() {
+		try {
+			lifeTimer.start();
+			socket.on("data", data);
+			if (keep_alive) socket.setKeepAlive?.(true, 1e3 * keep_alive);
+			write(StartupMessage());
+		} catch (err) {
+			openingFailed(err);
+		}
+	}
+	function error(err) {
+		errored(err);
+		while (sent.length) queryError(sent.shift(), err);
+	}
+	function errored(err) {
+		if (query) queryError(query, err);
+		if (initial) {
+			queryError(initial, err);
+			initial = null;
+		}
+	}
+	function queryError(q, err) {
+		if (isReservation(q)) return q.reject(err);
+		const e = err && typeof err === "object" ? err : new Error(String(err));
+		let begin = false;
+		if (q.begin !== null && e instanceof PostgresError) {
+			const prefix = q.begin.length + 2;
+			const inStatement = q.options.simple && e.position !== void 0 && Number(e.position) > prefix;
+			if (inStatement) Object.defineProperty(e, "position", {
+				value: String(Number(e.position) - prefix),
+				enumerable: true
+			});
+			begin = !q.began && !inStatement;
+		}
+		if (!("query" in e) && !("parameters" in e)) {
+			const debug = Boolean(options.debug);
+			Object.defineProperties(e, {
+				stack: {
+					value: ("stack" in e ? String(e.stack) : "") + q.origin.replace(/.*\n/, "\n"),
+					enumerable: debug
+				},
+				query: {
+					value: begin ? q.begin : q.group === null ? q.text : q.group[q.member].text,
+					enumerable: debug
+				},
+				parameters: {
+					value: begin ? [] : q.parameters,
+					enumerable: debug
+				},
+				args: {
+					value: q.group === null ? q.args : q.group[q.member].args,
+					enumerable: debug
+				},
+				types: {
+					value: q.statement?.types,
+					enumerable: debug
+				}
+			});
+		}
+		q.reject(e);
+	}
+	function end() {
+		if (ending) return ending;
+		if (!connection$1.reserved) onend(connection$1);
+		if (!connection$1.reserved && !initial && !query && sent.length === 0) {
+			terminate();
+			return new Promise((resolve) => socket && socket.readyState !== "closed" ? socket.once("close", () => resolve()) : resolve());
+		}
+		return ending = new Promise((resolve) => ended = resolve);
+	}
+	function release() {
+		connection$1.reserved = null;
+		if (ending) terminate();
+		else onopen(connection$1);
+	}
+	function terminate(force = false) {
+		terminated = true;
+		if (query || initial || sent.length) error(connection("CONNECTION_DESTROYED", options));
+		platform.clearImmediate(nextWriteTimer);
+		if (socket) {
+			socket.removeListener("data", data);
+			socket.removeListener("connect", connected);
+			if (socket.readyState === "open" && !force) socket.end(b.typed("X").end());
+			else socket.destroy();
+		}
+		if (force && redial !== null) {
+			clearTimeout(redial);
+			redial = null;
+		}
+		if (ended) {
+			ended();
+			ending = ended = null;
+		}
+	}
+	async function closed(hadError) {
+		incoming = Buffer$1.alloc(0);
+		remaining = 0;
+		incomings = null;
+		platform.clearImmediate(nextWriteTimer);
+		idleTimer.cancel();
+		lifeTimer.cancel();
+		connectTimer.cancel();
+		socket?.removeAllListeners();
+		socket = null;
+		if (initial) errored(connection("CONNECTION_CLOSED", options));
+		if (!hadError && (query || sent.length)) error(connection("CONNECTION_CLOSED", options));
+		query = null;
+		errorResponse = null;
+		rows = 0;
+		result = new Result();
+		results = null;
+		chunk = null;
+		nextWriteTimer = null;
+		if (ended) {
+			ended();
+			ending = ended = null;
+		}
+		closedTime = platform.now();
+		if (hadError) options.shared.retries++;
+		delay = (typeof backoff === "function" ? backoff(options.shared.retries) : backoff) * 1e3;
+		onclose(connection$1, connection("CONNECTION_CLOSED", options));
+	}
+	function handle(x) {
+		switch (x[0]) {
+			case 68: return DataRow(x);
+			case 83: return ParameterStatus(x);
+			case 90: return ReadyForQuery(x);
+			case 67: return CommandComplete(x);
+			case 50: return BindComplete();
+			case 49: return;
+			case 116: return ParameterDescription(x);
+			case 84: return RowDescription(x);
+			case 82: return authenticate(x);
+			case 110: return NoData();
+			case 75: return BackendKeyData(x);
+			case 69: return ErrorResponse(x);
+			case 78: return NoticeResponse(x);
+			case 73: return;
+			case 65: return;
+			case 71: return CopyInResponse();
+			case 72:
+			case 87: return CopyOutResponse();
+			case 100: return;
+			case 99: return;
+			case 86: return errored(notSupported("FunctionCallResponse"));
+			case 118: return errored(notSupported("NegotiateProtocolVersion"));
+			default: console.error("Postgres.js : Unknown Message:", x[0]);
+		}
+	}
+	function DataRow(x) {
+		const q = query;
+		const columns = q.statement.columns;
+		let index = 7;
+		const row = q.arrays ? new Array(columns.length) : {};
+		for (let i = 0; i < columns.length; i++) {
+			const column = columns[i];
+			const length = x.readInt32BE(index);
+			index += 4;
+			const value = length === -1 ? null : column.parser === void 0 ? x.toString("utf8", index, index += length) : column.parser(x.toString("utf8", index, index += length));
+			if (Array.isArray(row)) row[i] = value;
+			else row[column.name] = value;
+		}
+		result[rows++] = row;
+	}
+	function ParameterStatus(x) {
+		const [k, v] = x.toString("utf8", 5, x.length - 1).split("\0");
+		options.parameters[k] = v;
+	}
+	function ReadyForQuery(x) {
+		if (query) {
+			if (errorResponse) errored(errorResponse);
+			else query.resolve(results || result);
+		} else if (errorResponse) errored(errorResponse);
+		query = results = errorResponse = null;
+		result = new Result();
+		connectTimer.cancel();
+		if (initial) {
+			if (!isReservation(initial)) execute(initial);
+			options.shared.retries = 0;
+			const opened = initial;
+			initial = null;
+			if (opened !== null && isReservation(opened)) opened.reserve(connection$1);
+			return;
+		}
+		if (sent.length) query = sent.shift();
+		if (query) return;
+		if (connection$1.reserved) connection$1.reserved.next();
+		else if (ending) terminate();
+		else onopen(connection$1);
+	}
+	function CommandComplete(x) {
+		if (query.begin !== null && !query.began) {
+			query.began = true;
+			return;
+		}
+		rows = 0;
+		for (let i = x.length - 1; i > 0; i--) {
+			if (x[i] === 32 && (x[i + 1] ?? 58) < 58 && result.count === null) result.count = +x.toString("utf8", i + 1, x.length - 1);
+			if (x[i - 1] >= 65) {
+				result.command = x.toString("utf8", 5, i);
+				result.state = backend;
+				break;
+			}
+		}
+		if (result.command === "BEGIN" && max !== 1 && !connection$1.reserved) return errored(generic("UNSAFE_TRANSACTION", "Only use sql.begin, sql.reserved or max: 1"));
+		const q = query;
+		if (q.group !== null) {
+			results ??= [result];
+			if (q.member + 1 < q.group.length) {
+				results.push(result = new Result());
+				startMember(q, q.member + 1);
+			}
+			return;
+		}
+		if (query.options.simple) return BindComplete();
+	}
+	function BindComplete() {
+		if (!result.statement) result.statement = query.statement;
+		result.columns = query.statement.columns;
+	}
+	function ParameterDescription(x) {
+		const q = query;
+		const types = q.statement.types;
+		const length = x.readUInt16BE(5);
+		for (let i = 0; i < length; ++i) if (!types[i]) types[i] = x.readUInt32BE(7 + i * 4);
+		if (q.describeFirst) {
+			write(bound(q));
+			q.describeFirst = false;
+		}
+	}
+	function RowDescription(x) {
+		const statement = query.statement;
+		if (result.command) {
+			results = results || [result];
+			results.push(result = new Result());
+			result.count = null;
+			statement.columns = null;
+		}
+		const length = x.readUInt16BE(5);
+		let index = 7;
+		let start;
+		const columns = statement.columns = Array(length);
+		for (let i = 0; i < length; ++i) {
+			start = index;
+			while (x[index++] !== 0);
+			columns[i] = {
+				name: x.toString("utf8", start, index - 1),
+				parser: parsers[x.readUInt32BE(index + 6)],
+				table: x.readUInt32BE(index),
+				number: x.readUInt16BE(index + 4),
+				type: x.readUInt32BE(index + 6)
+			};
+			index += 18;
+		}
+		result.statement = statement;
+	}
+	function authenticate(x) {
+		const at = socket;
+		Authentication(x, at).catch((err) => {
+			if (socket === at) openingFailed(err);
+		});
+	}
+	async function Authentication(x, at) {
+		const type = x.readUInt32BE(5);
+		switch (type) {
+			case 0: return;
+			case 3: return AuthenticationCleartextPassword();
+			case 5: return AuthenticationMD5Password(x, at);
+			case 10: return SASL();
+			case 11: return SASLContinue(x, at);
+			case 12: return SASLFinal(x);
+			default: throw generic("AUTH_TYPE_NOT_SUPPORTED", `Postgres asked for an authentication the client has not: type ${type}`);
+		}
+	}
+	function openingFailed(err) {
+		errored(err);
+		socket?.destroy();
+	}
+	function AuthenticationCleartextPassword() {
+		write(b.typed("p").str(options.pass).z(1).end());
+	}
+	async function AuthenticationMD5Password(x, at) {
+		const payload = "md5" + await platform.md5(Buffer$1.concat([Buffer$1.from(await platform.md5(options.pass + user)), x.subarray(9)]));
+		if (socket !== at) return;
+		write(b.typed("p").str(payload).z(1).end());
+	}
+	function SASL() {
+		nonce = platform.randomBytes(18).toString("base64");
+		b.typed("p").str("SCRAM-SHA-256\0");
+		const i = b.i;
+		write(b.inc(4).str("n,,n=*,r=" + nonce).i32(b.i - i - 4, i).end());
+	}
+	async function SASLContinue(x, at) {
+		const res = {};
+		for (const part of x.toString("utf8", 9).split(",")) res[part[0]] = part.slice(2);
+		const saltedPassword = await platform.pbkdf2(options.pass, Buffer$1.from(res.s, "base64"), parseInt(res.i), 32);
+		const clientKey = await platform.hmac(saltedPassword, "Client Key");
+		const auth = "n=*,r=" + nonce + ",r=" + res.r + ",s=" + res.s + ",i=" + res.i + ",c=biws,r=" + res.r;
+		const signature = (await platform.hmac(await platform.hmac(saltedPassword, "Server Key"), auth)).toString("base64");
+		const payload = "c=biws,r=" + res.r + ",p=" + xor(clientKey, await platform.hmac(await platform.sha256(clientKey), auth)).toString("base64");
+		if (socket !== at) return;
+		serverSignature = signature;
+		write(b.typed("p").str(payload).end());
+	}
+	function SASLFinal(x) {
+		if (x.toString("utf8", 9).split("\0", 1)[0].slice(2) === serverSignature) return;
+		errored(generic("SASL_SIGNATURE_MISMATCH", "The server did not return the correct signature"));
+		socket.destroy();
+	}
+	function NoData() {
+		result.statement = query.statement;
+		result.statement.columns = [];
+	}
+	function BackendKeyData(x) {
+		backend.pid = x.readUInt32BE(5);
+		backend.secret = x.readUInt32BE(9);
+	}
+	function ErrorResponse(x) {
+		if (query) {
+			if (query.describeFirst) write(Sync);
+			errorResponse = postgres$1(parseError(x));
+		} else errored(postgres$1(parseError(x)));
+	}
+	function CopyInResponse() {
+		write(b.typed("f").str("COPY is not supported by this client\0").end());
+		if (!query?.options.simple) write(Sync);
+	}
+	function CopyOutResponse() {
+		errorResponse ??= generic("COPY_NOT_SUPPORTED", "COPY is not supported by this client");
+	}
+	function NoticeResponse(x) {
+		if (onnotice) onnotice(parseError(x));
+		else console.log(parseError(x));
+	}
+	function Bind(parameters, types) {
+		let prev;
+		b.typed("B").str("\0").str("\0").i16(0).i16(parameters.length);
+		parameters.forEach((x, i) => {
+			if (x === null) return void b.i32(4294967295);
+			const type = types[i];
+			const serialize = serializers[type];
+			parameters[i] = x = serialize ? serialize(x) : String(x);
+			prev = b.i;
+			b.inc(4).str(x).i32(b.i - prev - 4, prev);
+		});
+		b.i16(0);
+		return b.end();
+	}
+	function Parse(q) {
+		const { string, types } = q.statement;
+		b.typed("P").str("\0").str(string + "\0").i16(q.parameters.length);
+		q.parameters.forEach((_, i) => b.i32(types[i] || 0));
+		return b.end();
+	}
+	function StartupMessage() {
+		return b.untyped().inc(4).i16(3).z(2).str(Object.entries({
+			user,
+			database,
+			client_encoding: "UTF8",
+			...options.connection
+		}).filter(([, v]) => v).map(([k, v]) => k + "\0" + String(v)).join("\0")).z(2).end(0);
+	}
+}
+function parseError(x) {
+	const error = {};
+	let start = 5;
+	for (let i = 5; i < x.length - 1; i++) if (x[i] === 0) {
+		error[FIELDS[x[start]]] = x.toString("utf8", start + 1, i);
+		start = i + 1;
+	}
+	return error;
+}
+function xor(a, b) {
+	const length = Math.max(a.length, b.length);
+	const buffer = Buffer$1.allocUnsafe(length);
+	for (let i = 0; i < length; i++) buffer[i] = a[i] ^ b[i];
+	return buffer;
+}
+/** `fn`, `seconds` after each `start` unless cancelled; nothing at all for no seconds. */
+function timer(fn, seconds) {
+	const s = typeof seconds === "function" ? seconds() : seconds;
+	if (!s) return {
+		cancel: noop,
+		start: noop
+	};
+	let handle = null;
+	return {
+		cancel() {
+			if (handle) {
+				clearTimeout(handle);
+				handle = null;
+			}
+		},
+		start() {
+			if (handle) clearTimeout(handle);
+			handle = setTimeout(() => {
+				fn();
+				handle = null;
+			}, s * 1e3);
+		}
+	};
+}
+/**
+* Whether an unnamed statement must learn its parameters' types before it
+* can send them. Strings, numbers and nulls go as text, typed by the server,
+* in the same flush as the statement, as libpq and node-postgres send them;
+* only an array or an object whose type is not known yet has a text that
+* depends on the type. porsager/postgres#1225
+*/
+function typedByServer(parameters, types) {
+	return parameters.some((x, i) => !types[i] && x !== null && typeof x === "object");
+}
+//#endregion
+//#region src/postgres-js/query.ts
+/**
+* A statement, sent once awaited (`then`, `catch`, `finally`) or `execute`d,
+* a task later, through the pool or the transaction that made it: its
+* `handler`. A promise of its result, its rows as objects or, after
+* `values()`, as arrays.
+*/
+var Query = class extends Promise {
+	text;
+	args;
+	options;
+	#handler;
+	/** Where it was made, when the client debugs. */
+	#origin;
+	/** Its rows as arrays of values rather than objects. */
+	arrays = false;
+	executed = false;
+	parameters = [];
+	statement = null;
+	/** Whether its parameters' types are asked of the server before its values go (`typedByServer`, connection.ts). */
+	describeFirst = false;
+	/** A transaction's first statement: its BEGIN, sent ahead of it under its Sync (`begin`, index.ts); and whether it took. */
+	begin = null;
+	began = false;
+	/**
+	* Coffre: a group's statements, sent under one Sync and answered together, each its own result (`group`, index.ts),
+	* and the one answering now. Null for a statement of its own.
+	*/
+	group = null;
+	member = 0;
+	resolve;
+	reject;
+	constructor(text, args, handler, options, debug) {
+		let resolve;
+		let reject;
+		super((a, b) => {
+			resolve = a;
+			reject = b;
+		});
+		this.text = text;
+		this.args = args;
+		this.options = options;
+		this.#handler = handler;
+		this.#origin = debug ? /* @__PURE__ */ new Error() : null;
+		this.resolve = resolve;
+		this.reject = reject;
+	}
+	/** Where it was made, for its error's stack: nothing unless the client debugs. */
+	get origin() {
+		return this.#origin?.stack ?? "";
+	}
+	/** What `then` and the like make: a plain promise, not another statement. */
+	static get [Symbol.species]() {
+		return Promise;
+	}
+	values() {
+		this.arrays = true;
+		return this;
+	}
+	execute() {
+		this.#handle();
+		return this;
+	}
+	then(onfulfilled, onrejected) {
+		this.#handle();
+		return super.then(onfulfilled, onrejected);
+	}
+	catch(onrejected) {
+		this.#handle();
+		return super.catch(onrejected);
+	}
+	finally(onfinally) {
+		this.#handle();
+		return super.finally(onfinally);
+	}
+	/** Sent once, a task after it is first asked for. */
+	async #handle() {
+		if (this.executed) return;
+		this.executed = true;
+		await null;
+		this.#handler(this);
+	}
+};
+//#endregion
+//#region src/postgres-js/index.ts
+/**
+* Coffre: whether a statement is a plain read, what a group may hold (`group`): one that starts `select`. A `select`
+* that writes through a function says so first, in a comment, which this does not take (`pruneSpentTokens` in
+* @coffre/server). The extended protocol takes one statement a message, so none rides behind it.
+*/
+function plainRead(text) {
+	return /^\s*select\b/i.test(text);
+}
+/** A pool of connections, opened as statements ask for them. */
+function postgres(given) {
+	const options = settle(given);
+	let ending = null;
+	const queries = new Queue();
+	const connecting = new Queue();
+	const reserved = new Queue();
+	const closed = new Queue();
+	const ended = new Queue();
+	const open = new Queue();
+	const busy = new Queue();
+	const full = new Queue();
+	const connections = Array.from({ length: options.max }, () => createConnection(options, closed, {
+		onopen,
+		onend,
+		onclose
+	}));
+	return {
+		unsafe: unsafeOn(pooled),
+		group,
+		begin,
+		reserve,
+		end,
+		options
+	};
+	function group(statements) {
+		if (statements.length === 0) throw generic("EMPTY_GROUP", "A group needs a statement");
+		const write = statements.find((statement) => !plainRead(statement.query));
+		if (write !== void 0) throw generic("GROUP_NOT_READ", `A group holds plain reads alone, select …, not: ${write.query.slice(0, 80)}`);
+		const query = new Query(statements.map((statement) => statement.query).join(";\n"), [], pooled, { simple: false }, Boolean(options.debug));
+		query.group = statements.map(({ query: text, parameters = [], arrays = false }) => ({
+			text,
+			args: parameters,
+			arrays,
+			parameters: [],
+			statement: null
+		}));
+		return query;
+	}
+	/** `unsafe`, sending each statement through `handler`. */
+	function unsafeOn(handler) {
+		return (text, args = [], { simple = args.length === 0 } = {}) => new Query(text, args, handler, { simple }, Boolean(options.debug));
+	}
+	/** A connection of the pool's own, held until given back: `reserve`'s, and a transaction's. */
+	async function hold() {
+		if (ending) throw connection("CONNECTION_ENDED", options);
+		return move(open.length ? open.pop() : await new Promise((resolve, reject) => {
+			const query = {
+				reserve: resolve,
+				reject
+			};
+			if (closed.length) connect(closed.shift(), query);
+			else queries.push(query);
+		}), reserved);
+	}
+	async function reserve() {
+		const queue = new Queue();
+		const c = await hold();
+		c.reserved = { next: () => queue.length ? c.execute(queue.shift()) : move(c, reserved) };
+		return {
+			unsafe: unsafeOn(onReserved),
+			release: () => c.release()
+		};
+		/** A statement on the connection held: sent, or queued until the connection can take more. */
+		function onReserved(q) {
+			if (c.queue === full) queue.push(q);
+			else if (!c.execute(q)) move(c, full);
+		}
+	}
+	async function begin(...args) {
+		const [mode, fn] = args.length === 1 ? ["", args[0]] : args;
+		const queries = new Queue();
+		let savepoints = 0;
+		/** The transaction's first statement, which carries its BEGIN (`toBuffer`, connection.ts), once asked. */
+		let first = null;
+		/** Every statement of the transaction's asked: it ends once each has answered. */
+		const asked = /* @__PURE__ */ new Set();
+		/** Its end is decided, COMMIT or ROLLBACK: what its work asks now is refused, unsent. */
+		let decided = false;
+		/** Asked of it once its end was decided, and refused, before its COMMIT went: its work is not all done, it rolls back. */
+		let unfinished = null;
+		/** Its COMMIT or ROLLBACK has gone: what is refused now changes nothing. */
+		let closing = false;
+		/** Why it failed, a savepoint's statements included: what a COMMIT Postgres answered with ROLLBACK says. */
+		let failure;
+		/**
+		* Why nothing more of the transaction is sent, which would run outside it: its BEGIN failed, its connection closed,
+		* or it has ended, and its connection is the pool's again (what its work left running may still ask).
+		*/
+		let stopped = null;
+		const stop = (error) => {
+			stopped ??= error;
+			while (queries.length) queries.shift().reject(stopped);
+		};
+		const c = await hold();
+		const mine = { next: () => {
+			if (first !== null && !first.began) {
+				stop(generic("TRANSACTION_NOT_BEGUN", "The transaction did not begin, so its statements were not sent"));
+				move(c, reserved);
+				return;
+			}
+			move(c, reserved);
+			while (queries.length) if (!c.execute(queries.shift())) return void move(c, full);
+		} };
+		c.reserved = mine;
+		try {
+			return await Promise.race([scope(fn), new Promise((_, reject) => c.onclose = (error) => {
+				stop(error);
+				reject(error);
+			})]);
+		} finally {
+			stop(generic("TRANSACTION_ENDED", "The transaction has ended, so the statement was not sent"));
+			c.onclose = null;
+			if (c.reserved === mine) c.release();
+		}
+		async function scope(fn, name) {
+			let uncaughtError;
+			let result;
+			const sql = {
+				unsafe: unsafeOn(inTransaction),
+				savepoint: (fn) => scope(fn, "s" + savepoints++)
+			};
+			const own = (text) => sql.unsafe(text);
+			if (name) await own("savepoint " + quote(name));
+			try {
+				result = await new Promise((resolve, reject) => {
+					const x = fn(sql);
+					Promise.resolve(Array.isArray(x) ? Promise.all(x) : x).then(resolve, reject);
+				});
+				if (!name) await settle();
+				if (uncaughtError) throw uncaughtError;
+				if (!name && unfinished) throw unfinished;
+			} catch (e) {
+				if (!name) await settle();
+				if (!stopped && (name || first?.began)) await (name ? own("rollback to " + quote(name)) : last("rollback"));
+				if (aborted(e)) throw (uncaughtError !== void 0 && !aborted(uncaughtError) ? uncaughtError : failure) ?? e;
+				throw e;
+			}
+			if (!name && first !== null) {
+				if ((await last("commit")).command === "ROLLBACK") throw failure ?? generic("TRANSACTION_ROLLED_BACK", "Postgres rolled the transaction back at its COMMIT");
+			}
+			return result;
+			/** A statement of the transaction's: one that fails and is not waited for fails the transaction all the same. */
+			function inTransaction(q) {
+				if (decided) {
+					const refused = stopped ?? generic("TRANSACTION_ENDED", "The transaction has ended, so the statement was not sent");
+					if (!closing) unfinished ??= generic("TRANSACTION_UNFINISHED", "The transaction's work asked a statement once it had settled, so the transaction rolled back");
+					q.catch(() => {});
+					return q.reject(refused);
+				}
+				q.catch((e) => {
+					uncaughtError ||= e;
+					if (e instanceof PostgresError && !aborted(e)) failure = e;
+					else failure ??= e;
+				});
+				asked.add(q);
+				send(q);
+			}
+		}
+		/**
+		* Coffre: the end decided, nothing more of the work's is sent, and the transaction ends once what it asked has
+		* answered, with a ROLLBACK if any of it failed. Upstream sent the COMMIT at once: what the work asked after it ran
+		* outside the transaction, in autocommit, and a statement that failed unwaited left a COMMIT that Postgres
+		* answered with ROLLBACK, which upstream took for success.
+		*/
+		async function settle() {
+			decided = true;
+			await Promise.allSettled(asked);
+		}
+		/** The transaction's COMMIT or ROLLBACK, past the door that settle closed. */
+		function last(text) {
+			closing = true;
+			return new Query(text, [], send, { simple: true }, Boolean(options.debug));
+		}
+		/** `q` on the transaction's connection: sent, or queued until the connection can take more. */
+		function send(q) {
+			if (stopped) return q.reject(stopped);
+			if (first === null) {
+				first = q;
+				q.begin = "begin " + mode.replace(/[^a-z ]/gi, "");
+			}
+			if (c.queue === full) queries.push(q);
+			else if (!c.execute(q) || q === first) move(c, full);
+		}
+	}
+	function move(c, queue) {
+		c.queue.remove(c);
+		queue.push(c);
+		c.queue = queue;
+		if (queue === open) c.idleTimer.start();
+		else c.idleTimer.cancel();
+		return c;
+	}
+	/** A statement of the pool's: sent on an open connection, one opened for it, a busy one, or queued for the first free. */
+	function pooled(query) {
+		if (ending) return query.reject(connection("CONNECTION_ENDED", options));
+		if (open.length) return void go(open.pop(), query);
+		if (closed.length) return void connect(closed.shift(), query);
+		if (busy.length) go(busy.shift(), query);
+		else queries.push(query);
+	}
+	function go(c, query) {
+		return c.execute(query) ? move(c, busy) : move(c, full);
+	}
+	async function end({ timeout = null } = {}) {
+		if (ending) return ending;
+		await null;
+		let timer;
+		return ending = Promise.race([new Promise((resolve) => {
+			if (timeout !== null) timer = setTimeout(() => void destroy(resolve), timeout * 1e3);
+		}), Promise.all(connections.map((c) => c.end())).then(() => void 0)]).then(() => clearTimeout(timer));
+	}
+	async function destroy(resolve) {
+		await Promise.all(connections.map((c) => c.terminate(true)));
+		while (queries.length) queries.shift().reject(connection("CONNECTION_DESTROYED", options));
+		resolve();
+	}
+	function connect(c, query) {
+		move(c, connecting);
+		c.connect(query);
+		return c;
+	}
+	function onend(c) {
+		move(c, ended);
+	}
+	function onopen(c) {
+		if (queries.length === 0) return void move(c, open);
+		let max = Math.ceil(queries.length / (connecting.length + 1));
+		let ready = true;
+		while (ready && queries.length && max-- > 0) {
+			const query = queries.shift();
+			if ("reserve" in query) return void query.reserve(move(c, reserved));
+			ready = c.execute(query);
+		}
+		if (ready) move(c, busy);
+		else move(c, full);
+	}
+	function onclose(c, e) {
+		move(c, closed);
+		c.reserved = null;
+		if (c.onclose) {
+			c.onclose(e);
+			c.onclose = null;
+		}
+		options.onclose?.(c.id);
+		if (ending) {
+			while (queries.length) queries.shift().reject(connection("CONNECTION_ENDED", options));
+			return;
+		}
+		if (queries.length) connect(c, queries.shift());
+	}
+}
+/** Postgres's "current transaction is aborted": a statement after one that failed. */
+const aborted = (error) => error instanceof PostgresError && error.code === "25P02";
+/** `options`, each one not given at its default. */
+function settle(options) {
+	return {
+		host: options.host ?? "localhost",
+		port: options.port ?? 5432,
+		path: options.path,
+		database: options.database,
+		user: options.user ?? "",
+		pass: options.pass ?? "",
+		ssl: options.ssl ?? false,
+		sslnegotiation: options.sslnegotiation,
+		max: options.max ?? 10,
+		max_pipeline: options.max_pipeline ?? 100,
+		idle_timeout: options.idle_timeout,
+		connect_timeout: "connect_timeout" in options ? options.connect_timeout : 30,
+		max_lifetime: "max_lifetime" in options ? options.max_lifetime : () => 60 * (30 + Math.random() * 30),
+		backoff: options.backoff ?? ((retries) => (.5 + Math.random() / 2) * Math.min(3 ** retries / 100, 20)),
+		keep_alive: "keep_alive" in options ? options.keep_alive : 60,
+		debug: options.debug ?? false,
+		connection: {
+			application_name: "postgres.js",
+			...options.connection
+		},
+		onnotice: options.onnotice,
+		onclose: options.onclose,
+		socket: options.socket,
+		...defaultTypes(),
+		parameters: {},
+		shared: { retries: 0 }
+	};
+}
+/** `name` as an identifier, quoted. */
+function quote(name) {
+	return "\"" + name.replace(/"/g, "\"\"").replace(/\./g, "\".\"") + "\"";
+}
+//#endregion
+//#region src/postgres.ts
+/**
+* A client for `url`, as coffre opens every one: the driver's defaults (10
+* connections, every statement unnamed, as node-postgres sends them), but
+*
+* - notices dropped rather than logged;
+* - no connection closed for its age (`max_lifetime`), as node-postgres
+*   closed none: a backup's session holds its snapshot while pg_dump reads.
+*
+* The driver reads no array type from `pg_type` (postgres.js's
+* `fetch_types`, a round trip more per connection), and would answer one as
+* its text: Postgres's own are taken as known instead (`ARRAYS`). Arrays and
+* dates go as node-postgres sends them (`asPgSends`).
+*/
+function postgresClient(url, options = {}) {
+	const { application_name, connection, ...rest } = options;
+	const target = postgresOptions(url);
+	return asPgSends(arrayTypes(postgres({
+		onnotice: () => {},
+		max_lifetime: null,
+		...target,
+		...rest,
+		connection: {
+			...target.connection,
+			...application_name === void 0 ? {} : { application_name },
+			...connection
+		}
+	})));
+}
+/** A statement asked of a session that lost its connection, and with it its transaction, its locks and its settings. */
+var SessionLost = class extends Error {
+	constructor() {
+		super("the database session was lost: its connection closed, and with it its transaction, locks and settings");
+		this.name = "SessionLost";
+	}
+};
+/** What is asked of a session: each fails once it is lost. */
+const ASKED = /* @__PURE__ */ new Set([
+	"unsafe",
+	"begin",
+	"reserve"
+]);
+/**
+* One connection to `url`, kept as a session, as node-postgres's Client
+* kept one: what a statement sets (SET, BEGIN, a session's advisory lock)
+* holds for every statement after. A client of postgres.js would dial a new
+* connection for the next statement once its own closed, which holds none of
+* it: a migration going on without its lock, a probe meant to be rolled back
+* committed, a backup read outside its snapshot. A session does not: once
+* its connection has closed, by the server, the network or `end`, every
+* statement after fails, `SessionLost`.
+*/
+function postgresSession(url, options = {}) {
+	let lost = false;
+	const client = postgresClient(url, {
+		...options,
+		max: 1,
+		onclose: (id) => (lost = true, options.onclose?.(id))
+	});
+	/** A statement refused: rejected, and still a statement, whose `values()` and `execute()` Drizzle and callers ask for. */
+	const refused = () => {
+		const answer = Promise.reject(new SessionLost());
+		answer.catch(() => {});
+		return Object.assign(answer, {
+			values: () => answer,
+			execute: () => answer
+		});
+	};
+	return new Proxy(client, { get(target, key) {
+		const value = Reflect.get(target, key, target);
+		if (typeof value !== "function" || !ASKED.has(key)) return value;
+		return (...args) => lost ? refused() : value.apply(target, args);
+	} });
+}
+/**
+* `client`, sending a statement's values as node-postgres sends them: an
+* array as Postgres's text for one (`{"a","b"}`, bytes as `\\x…`), a date
+* as its ISO text and a plain object as its JSON, each for the server to
+* type, with the statement, in one round trip; `undefined` as NULL. Its
+* transactions', savepoints' and reserved connections' alike. The driver
+* would type an array by its first element, the element's type rather than
+* the array's, and so bind `[1, 2]` as one integer and mistype a `bytea[]`;
+* and it would ask the server first how to send an array of text.
+*/
+function asPgSends(client) {
+	return new Proxy(client, { get(target, key) {
+		const value = Reflect.get(target, key, target);
+		if (key === "unsafe") return (text, values, ...rest) => value.call(target, text, Array.isArray(values) ? values.map(sent) : values, ...rest);
+		if (key === "group") return (statements) => value.call(target, statements.map((statement) => ({
+			...statement,
+			parameters: statement.parameters?.map(sent)
+		})));
+		if (key === "begin" || key === "savepoint" || key === "reserve") return (...args) => {
+			const work = args.at(-1);
+			if (typeof work !== "function") return value.apply(target, args).then(asPgSends);
+			return value.apply(target, [...args.slice(0, -1), (tx) => work(asPgSends(tx))]);
+		};
+		return value;
+	} });
+}
+/**
+* A value as node-postgres sends it: an array, a date or a plain object (as
+* its JSON) as text, bytes of any view as bytes, `undefined` as NULL. What
+* else there is goes as it is.
+*/
+function sent(value) {
+	if (value === void 0) return null;
+	if (Array.isArray(value)) return arrayText(value);
+	if (value instanceof Date) return value.toISOString();
+	const bytes = bytesOf(value);
+	if (bytes !== null) return bytes;
+	return plain(value) ? JSON.stringify(value) : value;
+}
+/** An object made as `{…}` is: no class of its own. */
+function plain(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+/** Bytes, from any view of them or their buffer, as a Uint8Array; null for anything else. */
+function bytesOf(value) {
+	if (value instanceof Uint8Array) return value;
+	if (ArrayBuffer.isView(value)) return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+	if (value instanceof ArrayBuffer) return Buffer.from(value);
+	return null;
+}
+/** An array as Postgres's text for one, as node-postgres writes it: elements quoted, bytes as hex, nulls as NULL. */
+function arrayText(values) {
+	return `{${values.map((value) => {
+		if (value === null || value === void 0) return "NULL";
+		if (Array.isArray(value)) return arrayText(value);
+		const bytes = bytesOf(value);
+		if (bytes !== null) return `\\\\x${Buffer.from(bytes).toString("hex")}`;
+		return `"${(value instanceof Date ? value.toISOString() : typeof value === "object" ? JSON.stringify(value) : String(value)).replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+	}).join(",")}}`;
+}
+/**
+* Postgres's built-in types and their arrays, element and array oid, as
+* `fetch_types` would read them from `pg_type` at each connection: those a
+* hand-written statement may send or answer, as node-postgres knew them. An
+* array of any other type (ranges, geometry, `macaddr8`, a type of one's
+* own) is answered as Postgres's text for it: add it here to read it.
+*/
+const ARRAYS = [
+	[16, 1e3],
+	[17, 1001],
+	[18, 1002],
+	[19, 1003],
+	[20, 1016],
+	[21, 1005],
+	[23, 1007],
+	[25, 1009],
+	[26, 1028],
+	[114, 199],
+	[650, 651],
+	[700, 1021],
+	[701, 1022],
+	[829, 1040],
+	[869, 1041],
+	[1042, 1014],
+	[1043, 1015],
+	[1082, 1182],
+	[1083, 1183],
+	[1114, 1115],
+	[1184, 1185],
+	[1186, 1187],
+	[1266, 1270],
+	[1700, 1231],
+	[2950, 2951],
+	[3802, 3807]
+];
+/** `client`, which reads Postgres's arrays as node-postgres reads them, each element by its type's parser. */
+function arrayTypes(client) {
+	const parsers = client.options.parsers;
+	for (const [element, array] of ARRAYS) {
+		const parse = parsers[element];
+		parsers[array] = (text) => arrayOf(text, parse);
+	}
+	return client;
+}
+/**
+* Postgres's text for an array, `{a,"b,c",NULL,{1,2}}`, as its values: a
+* quoted element is text (`"NULL"` included), an unquoted NULL is null, and
+* explicit bounds (`[0:1]={…}`) are read past.
+*/
+function arrayOf(text, parse) {
+	let at = text.startsWith("[") ? text.indexOf("=") + 1 : 0;
+	const list = () => {
+		const values = [];
+		at += 1;
+		if (text[at] === "}") {
+			at += 1;
+			return values;
+		}
+		for (;;) {
+			if (text[at] === "{") values.push(list());
+			else if (text[at] === "\"") {
+				let element = "";
+				for (at += 1; text[at] !== "\""; at += 1) element += text[text[at] === "\\" ? ++at : at];
+				at += 1;
+				values.push(parse ? parse(element) : element);
+			} else {
+				const start = at;
+				while (text[at] !== "," && text[at] !== "}") at += 1;
+				const element = text.slice(start, at);
+				values.push(element === "NULL" ? null : parse ? parse(element) : element);
+			}
+			if (text[at++] === "}") return values;
+		}
+	};
+	return list();
+}
+/**
+* The Postgres types Drizzle maps from their text itself: dates and times,
+* and arrays of them and of numerics, as Drizzle's own drivers set them up,
+* postgres.js's (`construct`) and node-postgres's alike.
+*/
+const TEXT_TYPES = [
+	1184,
+	1082,
+	1083,
+	1114,
+	1182,
+	1185,
+	1115,
+	1231
+];
+/**
+* `client`, set up as Drizzle's own postgres.js driver sets one up: dates
+* and times come as Postgres's text, which each column maps, and JSON goes
+* as Drizzle writes it. For every statement of the client, `unsafe`'s
+* included: a client made a database (`createDatabase`) answers a raw
+* `now()` as text, not a Date.
+*/
+function textTypes(client) {
+	const identity = (value) => value;
+	for (const type of TEXT_TYPES) {
+		client.options.parsers[type] = identity;
+		client.options.serializers[type] = identity;
+	}
+	client.options.serializers[114] = identity;
+	client.options.serializers[3802] = identity;
+	return client;
+}
+/**
+* The connection `url` names, as node-postgres and its pg-connection-string
+* read one. The driver reads no URL: it is given the parts. (Upstream
+* postgres.js read URLs otherwise: it sent every query parameter it did not
+* know to the server as a setting, which refused the connection over one it
+* did not know either, `sslrootcert` or `uselibpqcompat`; its
+* `sslmode=require` skipped the certificate check, where coffre's URLs, as
+* pg reads them, verify; and it checked an IP address against `localhost`.)
+*
+* TLS is:
+*
+*   no sslmode, sslmode=disable               none
+*   sslmode=prefer, require, verify-ca,       the certificate chain and the host verified
+*     verify-full; ssl=true or 1
+*   sslmode=no-verify                         TLS, nothing verified
+*   uselibpqcompat=true                       libpq's modes: prefer and require verify nothing
+*                                             (require with a sslrootcert, the chain), verify-ca
+*                                             the chain, verify-full the chain and the host
+*   sslrootcert=system                        Node's trusted CAs; only with verify-full or no sslmode
+*   sslrootcert, sslcert, sslkey (files)      read from disk, as pg does
+*
+* The host is verified against the URL's own, an IP address included.
+*/
+function postgresOptions(url) {
+	const hostless = /^[a-z]+:\/\/([^/?#@]*@)?\//i.test(url);
+	if (/^[a-z]+:\/\/([^/?#@]*@)?[^/?#]*,/i.test(url)) throw new Error("a Postgres URL names one host: several, as libpq takes them, are not supported");
+	let read;
+	try {
+		const parsed = new URL(hostless ? url.replace(/^([a-z]+:\/\/([^/?#@]*@)?)/i, "$1localhost") : url);
+		const query = new Map([...parsed.searchParams].filter(([, value]) => value !== ""));
+		const port = query.get("port") ?? (parsed.port || "5432");
+		if (!/^\d{1,5}$/.test(port) || Number(port) === 0 || Number(port) > 65535) throw new Error("no port");
+		read = {
+			query,
+			host: query.get("host") ?? decodeURIComponent(parsed.hostname.replace(/^\[(.*)\]$/, "$1")),
+			port: Number(port),
+			user: query.get("user") ?? decodeURIComponent(parsed.username),
+			pass: query.get("password") ?? decodeURIComponent(parsed.password),
+			database: decodeURIComponent(parsed.pathname.slice(1)) || void 0
+		};
+	} catch {
+		throw new Error("invalid Postgres URL");
+	}
+	const { query, host, port, user, pass, database } = read;
+	if (user === "") throw new Error("a Postgres URL names its user: postgresql://<user>@<host>/<database>");
+	if (host.includes(",")) throw new Error("a Postgres URL names one host: several, as libpq takes them, are not supported");
+	if (query.has("query_timeout")) throw new Error("a Postgres URL's query_timeout is not supported: statement_timeout bounds a statement in the server");
+	const connectTimeout = query.get("connect_timeout");
+	if (connectTimeout !== void 0 && !/^\d+$/.test(connectTimeout)) throw new Error("invalid Postgres URL");
+	const mode = query.get("sslmode");
+	if (mode !== void 0 && ![
+		"disable",
+		"allow",
+		"prefer",
+		"require",
+		"verify-ca",
+		"verify-full",
+		"no-verify"
+	].includes(mode)) throw new Error(`a Postgres URL's sslmode is one of libpq's, not ${mode}`);
+	if (![
+		"postgres",
+		"direct",
+		void 0
+	].includes(query.get("sslnegotiation"))) throw new Error("a Postgres URL's sslnegotiation is postgres or direct");
+	if (query.get("channel_binding") === "require") throw new Error("a Postgres URL's channel_binding=require is not supported: SCRAM goes without channel binding");
+	const connection = {};
+	for (const name of [
+		"application_name",
+		"fallback_application_name",
+		"options",
+		"statement_timeout",
+		"lock_timeout",
+		"idle_in_transaction_session_timeout"
+	]) {
+		const value = query.get(name);
+		if (value !== void 0) connection[name] = value;
+	}
+	const sslnegotiation = query.get("sslnegotiation") === "direct" ? "direct" : void 0;
+	return {
+		...host.startsWith("/") ? { path: `${host}/.s.PGSQL.${port}` } : { host },
+		port,
+		user,
+		pass,
+		database,
+		ssl: tlsFor(query, host, sslnegotiation !== void 0),
+		...sslnegotiation === void 0 ? {} : { sslnegotiation },
+		...connectTimeout === void 0 ? {} : { connect_timeout: Number(connectTimeout) },
+		connection
+	};
+}
+function tlsFor(query, host, direct) {
+	const mode = query.get("sslmode");
+	let rootcert = query.get("sslrootcert");
+	if (rootcert === "system") {
+		if (mode !== void 0 && mode !== "verify-full") throw new Error("sslrootcert=system requires sslmode=verify-full");
+		if (!host || host.startsWith("/")) throw new Error("sslrootcert=system requires a Postgres hostname");
+		rootcert = void 0;
+	}
+	const files = {
+		cert: query.get("sslcert"),
+		key: query.get("sslkey"),
+		ca: rootcert
+	};
+	const flag = query.get("ssl");
+	if (!(mode !== void 0 || Object.values(files).some((file) => file !== void 0) || query.get("sslrootcert") === "system" || flag === "true" || flag === "1" || direct) || mode === "disable") return false;
+	const tls = {};
+	for (const [name, file] of Object.entries(files)) if (file !== void 0) tls[name] = readFileSync(file).toString();
+	const passphrase = query.get("sslpassword");
+	if (passphrase !== void 0) tls.passphrase = passphrase;
+	const libpq = query.get("uselibpqcompat") === "true";
+	const verify = !libpq ? mode === "no-verify" ? "none" : "full" : mode === "prefer" || mode === "require" && tls.ca === void 0 ? "none" : mode === "require" || mode === "verify-ca" ? "chain" : "full";
+	if (libpq && mode === "verify-ca" && tls.ca === void 0) throw new Error("sslmode=verify-ca requires a CA in sslrootcert: with a public CA, it lets anyone with a certificate from it pass as the database. Use sslmode=verify-full");
+	if (verify === "none") return {
+		...tls,
+		rejectUnauthorized: false
+	};
+	return {
+		...tls,
+		rejectUnauthorized: true,
+		checkServerIdentity: verify === "chain" ? () => void 0 : (_hostname, certificate) => checkServerIdentity(host, certificate),
+		...isIP(host) === 0 ? { servername: host } : {}
+	};
+}
+/** `name` as a Postgres identifier, quoted, as node-postgres's `escapeIdentifier` writes one. */
+function quoteIdentifier(name) {
+	return `"${name.replaceAll("\"", "\"\"")}"`;
+}
+/** `text` as a Postgres string literal, as node-postgres's `escapeLiteral` writes one: `E'…'` when it holds a backslash. */
+function quoteLiteral(text) {
+	const quoted = `'${text.replaceAll("'", "''").replaceAll("\\", "\\\\")}'`;
+	return text.includes("\\") ? ` E${quoted}` : quoted;
+}
+//#endregion
+export { quoteIdentifier as a, plainRead as c, postgresSession as i, postgresClient as n, quoteLiteral as o, postgresOptions as r, textTypes as s, SessionLost as t };