@event-driven-io/dumbo 0.13.0-beta.42 → 0.13.0-beta.43

package/dist/core-BPSzA-lq.cjs

@@ -1,3259 +0,0 @@
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-let uuid = require("uuid");
-let ansis = require("ansis");
-ansis = __toESM(ansis, 1);
-
-//#region src/core/errors/index.ts
-const isNumber = (val) => typeof val === "number" && val === val;
-const isString = (val) => typeof val === "string";
-var DumboError = class DumboError extends Error {
-	static ErrorCode = 500;
-	static ErrorType = "DumboError";
-	errorCode;
-	errorType;
-	innerError;
-	constructor(options) {
-		const errorCode = options && typeof options === "object" && "errorCode" in options ? options.errorCode : isNumber(options) ? options : DumboError.ErrorCode;
-		const errorType = options && typeof options === "object" && "errorType" in options ? options.errorType ?? DumboError.ErrorType : DumboError.ErrorType;
-		const message = options && typeof options === "object" && "message" in options ? options.message : isString(options) ? options : `Error with status code '${errorCode}' ocurred during DumboError processing`;
-		const innerError = options && typeof options === "object" && "innerError" in options ? options.innerError : void 0;
-		super(message, { cause: innerError });
-		this.errorCode = errorCode;
-		this.errorType = errorType;
-		this.innerError = innerError;
-		Object.setPrototypeOf(this, DumboError.prototype);
-	}
-	static isInstanceOf(error, options) {
-		if (typeof error !== "object" || error === null || !("errorCode" in error) || !isNumber(error.errorCode) || !("errorType" in error) || !isString(error.errorType)) return false;
-		if (!options) return true;
-		if (options.errorCode !== void 0 && error.errorCode !== options.errorCode) return false;
-		if (options.errorType !== void 0 && error.errorType !== options.errorType) return false;
-		return true;
-	}
-};
-var ConcurrencyError = class ConcurrencyError extends DumboError {
-	static ErrorCode = 412;
-	static ErrorType = "ConcurrencyError";
-	constructor(message, innerError) {
-		super({
-			errorCode: ConcurrencyError.ErrorCode,
-			errorType: ConcurrencyError.ErrorType,
-			message: message ?? `Expected document state does not match current one!`,
-			innerError
-		});
-		Object.setPrototypeOf(this, ConcurrencyError.prototype);
-	}
-};
-var TransientDatabaseError = class TransientDatabaseError extends DumboError {
-	static ErrorCode = 503;
-	static ErrorType = "TransientDatabaseError";
-	constructor(message, innerError) {
-		super({
-			errorCode: TransientDatabaseError.ErrorCode,
-			errorType: TransientDatabaseError.ErrorType,
-			message: message ?? `A transient error occurred during database operation. Retrying the operation might succeed.`,
-			innerError
-		});
-		Object.setPrototypeOf(this, TransientDatabaseError.prototype);
-	}
-};
-var ConnectionError = class ConnectionError extends TransientDatabaseError {
-	static ErrorCode = 503;
-	static ErrorType = "ConnectionError";
-	constructor(message, innerError) {
-		super(message ?? `A connection error occurred during database operation.`, innerError);
-		this.errorType = ConnectionError.ErrorType;
-		Object.setPrototypeOf(this, ConnectionError.prototype);
-	}
-};
-var SerializationError = class SerializationError extends TransientDatabaseError {
-	static ErrorCode = 503;
-	static ErrorType = "SerializationError";
-	constructor(message, innerError) {
-		super(message ?? `A serialization failure occurred. The transaction can be retried.`, innerError);
-		this.errorType = SerializationError.ErrorType;
-		Object.setPrototypeOf(this, SerializationError.prototype);
-	}
-};
-var DeadlockError = class DeadlockError extends TransientDatabaseError {
-	static ErrorCode = 503;
-	static ErrorType = "DeadlockError";
-	constructor(message, innerError) {
-		super(message ?? `A deadlock was detected. The transaction can be retried.`, innerError);
-		this.errorType = DeadlockError.ErrorType;
-		Object.setPrototypeOf(this, DeadlockError.prototype);
-	}
-};
-var LockNotAvailableError = class LockNotAvailableError extends TransientDatabaseError {
-	static ErrorCode = 503;
-	static ErrorType = "LockNotAvailableError";
-	constructor(message, innerError) {
-		super(message ?? `The requested lock is not available.`, innerError);
-		this.errorType = LockNotAvailableError.ErrorType;
-		Object.setPrototypeOf(this, LockNotAvailableError.prototype);
-	}
-};
-var InsufficientResourcesError = class InsufficientResourcesError extends TransientDatabaseError {
-	static ErrorCode = 503;
-	static ErrorType = "InsufficientResourcesError";
-	constructor(message, innerError) {
-		super(message ?? `Insufficient resources to complete the database operation (e.g. disk full, out of memory, too many connections).`, innerError);
-		this.errorType = InsufficientResourcesError.ErrorType;
-		Object.setPrototypeOf(this, InsufficientResourcesError.prototype);
-	}
-};
-var SystemError = class SystemError extends TransientDatabaseError {
-	static ErrorCode = 503;
-	static ErrorType = "SystemError";
-	constructor(message, innerError) {
-		super(message ?? `A system-level error occurred (e.g. I/O error).`, innerError);
-		this.errorType = SystemError.ErrorType;
-		Object.setPrototypeOf(this, SystemError.prototype);
-	}
-};
-var AdminShutdownError = class AdminShutdownError extends TransientDatabaseError {
-	static ErrorCode = 503;
-	static ErrorType = "AdminShutdownError";
-	constructor(message, innerError) {
-		super(message ?? `The database server is shutting down or restarting.`, innerError);
-		this.errorType = AdminShutdownError.ErrorType;
-		Object.setPrototypeOf(this, AdminShutdownError.prototype);
-	}
-};
-var QueryCanceledError = class QueryCanceledError extends TransientDatabaseError {
-	static ErrorCode = 503;
-	static ErrorType = "QueryCanceledError";
-	constructor(message, innerError) {
-		super(message ?? `The query was canceled, e.g. due to statement timeout or user request.`, innerError);
-		this.errorType = QueryCanceledError.ErrorType;
-		Object.setPrototypeOf(this, QueryCanceledError.prototype);
-	}
-};
-var IntegrityConstraintViolationError = class IntegrityConstraintViolationError extends DumboError {
-	static ErrorCode = 409;
-	static ErrorType = "IntegrityConstraintViolationError";
-	constructor(message, innerError) {
-		super({
-			errorCode: IntegrityConstraintViolationError.ErrorCode,
-			errorType: IntegrityConstraintViolationError.ErrorType,
-			message: message ?? `An integrity constraint violation occurred!`,
-			innerError
-		});
-		Object.setPrototypeOf(this, IntegrityConstraintViolationError.prototype);
-	}
-};
-var UniqueConstraintError = class UniqueConstraintError extends IntegrityConstraintViolationError {
-	static ErrorCode = 409;
-	static ErrorType = "UniqueConstraintError";
-	constructor(message, innerError) {
-		super(message ?? `Unique constraint violation occurred!`, innerError);
-		this.errorType = UniqueConstraintError.ErrorType;
-		Object.setPrototypeOf(this, UniqueConstraintError.prototype);
-	}
-};
-var ForeignKeyViolationError = class ForeignKeyViolationError extends IntegrityConstraintViolationError {
-	static ErrorCode = 409;
-	static ErrorType = "ForeignKeyViolationError";
-	constructor(message, innerError) {
-		super(message ?? `Foreign key constraint violation occurred!`, innerError);
-		this.errorType = ForeignKeyViolationError.ErrorType;
-		Object.setPrototypeOf(this, ForeignKeyViolationError.prototype);
-	}
-};
-var NotNullViolationError = class NotNullViolationError extends IntegrityConstraintViolationError {
-	static ErrorCode = 409;
-	static ErrorType = "NotNullViolationError";
-	constructor(message, innerError) {
-		super(message ?? `NOT NULL constraint violation occurred!`, innerError);
-		this.errorType = NotNullViolationError.ErrorType;
-		Object.setPrototypeOf(this, NotNullViolationError.prototype);
-	}
-};
-var CheckViolationError = class CheckViolationError extends IntegrityConstraintViolationError {
-	static ErrorCode = 409;
-	static ErrorType = "CheckViolationError";
-	constructor(message, innerError) {
-		super(message ?? `CHECK constraint violation occurred!`, innerError);
-		this.errorType = CheckViolationError.ErrorType;
-		Object.setPrototypeOf(this, CheckViolationError.prototype);
-	}
-};
-var ExclusionViolationError = class ExclusionViolationError extends IntegrityConstraintViolationError {
-	static ErrorCode = 409;
-	static ErrorType = "ExclusionViolationError";
-	constructor(message, innerError) {
-		super(message ?? `Exclusion constraint violation occurred!`, innerError);
-		this.errorType = ExclusionViolationError.ErrorType;
-		Object.setPrototypeOf(this, ExclusionViolationError.prototype);
-	}
-};
-var DataError = class DataError extends DumboError {
-	static ErrorCode = 400;
-	static ErrorType = "DataError";
-	constructor(message, innerError) {
-		super({
-			errorCode: DataError.ErrorCode,
-			errorType: DataError.ErrorType,
-			message: message ?? `A data error occurred (e.g. invalid value, type mismatch).`,
-			innerError
-		});
-		Object.setPrototypeOf(this, DataError.prototype);
-	}
-};
-var InvalidOperationError = class InvalidOperationError extends DumboError {
-	static ErrorCode = 400;
-	static ErrorType = "InvalidOperationError";
-	constructor(message, innerError) {
-		super({
-			errorCode: InvalidOperationError.ErrorCode,
-			errorType: InvalidOperationError.ErrorType,
-			message: message ?? `Invalid operation (e.g. syntax error, insufficient privileges, undefined table).`,
-			innerError
-		});
-		Object.setPrototypeOf(this, InvalidOperationError.prototype);
-	}
-};
-
-//#endregion
-//#region src/core/execute/execute.ts
-const mapColumnToJSON = (column, serializer, options) => ({ [column]: (value) => {
-	if (typeof value === "string") try {
-		return serializer.deserialize(value, options);
-	} catch {}
-	return value;
-} });
-const mapColumnToBigint = (column) => ({ [column]: (value) => {
-	if (typeof value === "number" || typeof value === "string") return BigInt(value);
-	return value;
-} });
-const mapColumnToDate = (column) => ({ [column]: (value) => {
-	if (typeof value === "number" || typeof value === "string") return new Date(value);
-	return value;
-} });
-const mapSQLQueryResult = (result, mapping) => {
-	if (typeof result !== "object" || result === null) return result;
-	const mappedResult = { ...result };
-	for (const column of Object.keys(mapping)) if (column in mappedResult) mappedResult[column] = mapping[column](mappedResult[column]);
-	return mappedResult;
-};
-var BatchCommandNoChangesError = class BatchCommandNoChangesError extends DumboError {
-	static ErrorCode = 409;
-	static ErrorType = "BatchCommandNoChangesError";
-	statementIndex;
-	constructor(statementIndex) {
-		super({
-			errorCode: BatchCommandNoChangesError.ErrorCode,
-			errorType: BatchCommandNoChangesError.ErrorType,
-			message: `Batch command at index ${statementIndex} affected no rows`
-		});
-		this.name = "BatchCommandNoChangesError";
-		this.statementIndex = statementIndex;
-		Object.setPrototypeOf(this, BatchCommandNoChangesError.prototype);
-	}
-};
-const sqlExecutor = (sqlExecutor, options) => ({
-	query: (sql, queryOptions) => executeInNewDbClient((client) => sqlExecutor.query(client, sql, queryOptions), options),
-	batchQuery: (sqls, queryOptions) => executeInNewDbClient((client) => sqlExecutor.batchQuery(client, sqls, queryOptions), options),
-	command: (sql, commandOptions) => executeInNewDbClient((client) => sqlExecutor.command(client, sql, commandOptions), options),
-	batchCommand: (sqls, commandOptions) => executeInNewDbClient((client) => sqlExecutor.batchCommand(client, sqls, commandOptions), options)
-});
-const sqlExecutorInNewConnection = (options) => ({
-	query: (sql, queryOptions) => executeInNewConnection((connection) => connection.execute.query(sql, queryOptions), options),
-	batchQuery: (sqls, queryOptions) => executeInNewConnection((connection) => connection.execute.batchQuery(sqls, queryOptions), options),
-	command: (sql, commandOptions) => executeInNewConnection((connection) => connection.execute.command(sql, commandOptions), options),
-	batchCommand: (sqls, commandOptions) => executeInNewConnection((connection) => connection.execute.batchCommand(sqls, commandOptions), options)
-});
-const sqlExecutorInAmbientConnection = (options) => ({
-	query: (sql, queryOptions) => executeInAmbientConnection((connection) => connection.execute.query(sql, queryOptions), options),
-	batchQuery: (sqls, queryOptions) => executeInAmbientConnection((connection) => connection.execute.batchQuery(sqls, queryOptions), options),
-	command: (sql, commandOptions) => executeInAmbientConnection((connection) => connection.execute.command(sql, commandOptions), options),
-	batchCommand: (sqls, commandOptions) => executeInAmbientConnection((connection) => connection.execute.batchCommand(sqls, commandOptions), options)
-});
-const executeInNewDbClient = async (handle, options) => {
-	const { connect, close } = options;
-	const client = await connect();
-	try {
-		return await handle(client);
-	} catch (error) {
-		if (close) await close(client, error);
-		throw error;
-	}
-};
-const executeInNewConnection = async (handle, options) => {
-	const connection = await options.connection();
-	try {
-		return await handle(connection);
-	} finally {
-		await connection.close();
-	}
-};
-const executeInAmbientConnection = async (handle, options) => {
-	const connection = await options.connection();
-	try {
-		return await handle(connection);
-	} finally {}
-};
-
-//#endregion
-//#region src/core/connections/transaction.ts
-const toTransactionResult = (transactionResult) => transactionResult !== void 0 && transactionResult !== null && typeof transactionResult === "object" && "success" in transactionResult ? transactionResult : {
-	success: true,
-	result: transactionResult
-};
-const executeInTransaction = async (transaction, handle) => {
-	await transaction.begin();
-	try {
-		const { success, result } = toTransactionResult(await handle(transaction));
-		if (success) await transaction.commit();
-		else await transaction.rollback();
-		return result;
-	} catch (e) {
-		await transaction.rollback();
-		throw e;
-	}
-};
-const transactionFactoryWithDbClient = (connect, initTransaction) => {
-	let currentTransaction = void 0;
-	const getOrInitCurrentTransaction = (options) => currentTransaction ?? (currentTransaction = initTransaction(connect(), {
-		close: () => {
-			currentTransaction = void 0;
-			return Promise.resolve();
-		},
-		...options ?? {}
-	}));
-	return {
-		transaction: getOrInitCurrentTransaction,
-		withTransaction: (handle, options) => executeInTransaction(getOrInitCurrentTransaction(options), handle)
-	};
-};
-const wrapInConnectionClosure = async (connection, handle) => {
-	try {
-		return await handle();
-	} finally {
-		await connection.close();
-	}
-};
-const transactionFactoryWithNewConnection = (connect) => ({
-	transaction: (options) => {
-		const connection = connect();
-		const transaction = connection.transaction(options);
-		return {
-			...transaction,
-			commit: () => wrapInConnectionClosure(connection, () => transaction.commit()),
-			rollback: () => wrapInConnectionClosure(connection, () => transaction.rollback())
-		};
-	},
-	withTransaction: (handle, options) => {
-		const connection = connect();
-		const withTx = connection.withTransaction;
-		return wrapInConnectionClosure(connection, () => withTx(handle, options));
-	}
-});
-const transactionFactoryWithAmbientConnection = (connect) => ({
-	transaction: (options) => {
-		const transaction = connect().transaction(options);
-		return {
-			...transaction,
-			commit: () => transaction.commit(),
-			rollback: () => transaction.rollback()
-		};
-	},
-	withTransaction: (handle, options) => {
-		const withTx = connect().withTransaction;
-		return withTx(handle, options);
-	}
-});
-const transactionFactoryWithAsyncAmbientConnection = (driverType, connect, close) => {
-	close ??= () => Promise.resolve();
-	return {
-		transaction: (options) => {
-			let conn = null;
-			let innerTx = null;
-			let connectingPromise = null;
-			const ensureConnection = async () => {
-				if (conn) return innerTx;
-				if (!connectingPromise) connectingPromise = (async () => {
-					conn = await connect();
-					innerTx = conn.transaction(options);
-				})();
-				await connectingPromise;
-				return innerTx;
-			};
-			return {
-				driverType,
-				get connection() {
-					if (!conn) throw new Error("Transaction not started - call begin() first");
-					return conn;
-				},
-				execute: {
-					query: async (sql, queryOptions) => {
-						return (await ensureConnection()).execute.query(sql, queryOptions);
-					},
-					batchQuery: async (sqls, queryOptions) => {
-						return (await ensureConnection()).execute.batchQuery(sqls, queryOptions);
-					},
-					command: async (sql, commandOptions) => {
-						return (await ensureConnection()).execute.command(sql, commandOptions);
-					},
-					batchCommand: async (sqls, commandOptions) => {
-						return (await ensureConnection()).execute.batchCommand(sqls, commandOptions);
-					}
-				},
-				begin: async () => {
-					return (await ensureConnection()).begin();
-				},
-				commit: async () => {
-					if (!innerTx) throw new Error("Transaction not started");
-					try {
-						return await innerTx.commit();
-					} finally {
-						if (conn) await close(conn);
-					}
-				},
-				rollback: async (error) => {
-					if (!innerTx) {
-						if (conn) await close(conn);
-						return;
-					}
-					try {
-						return await innerTx.rollback(error);
-					} finally {
-						if (conn) await close(conn);
-					}
-				},
-				_transactionOptions: void 0
-			};
-		},
-		withTransaction: async (handle, options) => {
-			const conn = await connect();
-			try {
-				const withTx = conn.withTransaction;
-				return await withTx(handle, options);
-			} finally {
-				await close(conn);
-			}
-		}
-	};
-};
-
-//#endregion
-//#region src/core/connections/connection.ts
-const createAmbientConnection = (options) => {
-	const { driverType, client, executor, initTransaction, serializer } = options;
-	const clientPromise = Promise.resolve(client);
-	const closePromise = Promise.resolve();
-	const open = () => clientPromise;
-	const close = () => closePromise;
-	const typedConnection = {
-		driverType,
-		open,
-		close,
-		...transactionFactoryWithDbClient(open, initTransaction(() => typedConnection)),
-		execute: sqlExecutor(executor({ serializer }), { connect: open }),
-		_transactionType: void 0
-	};
-	return typedConnection;
-};
-const createSingletonConnection = (options) => {
-	const { driverType, connect, close, initTransaction, executor, serializer } = options;
-	let client = null;
-	let connectPromise = null;
-	const getClient = async () => {
-		if (client) return client;
-		if (!connectPromise) connectPromise = connect().then((c) => {
-			client = c;
-			return c;
-		});
-		return connectPromise;
-	};
-	const typedConnection = {
-		driverType,
-		open: getClient,
-		close: () => client ? close(client) : Promise.resolve(),
-		...transactionFactoryWithDbClient(getClient, initTransaction(() => typedConnection)),
-		execute: sqlExecutor(executor({ serializer }), { connect: getClient }),
-		_transactionType: void 0
-	};
-	return typedConnection;
-};
-const createTransientConnection = (options) => {
-	const { driverType, open, close, initTransaction, executor, serializer } = options;
-	const typedConnection = {
-		driverType,
-		open,
-		close,
-		...transactionFactoryWithDbClient(open, initTransaction(() => typedConnection)),
-		execute: sqlExecutor(executor({ serializer }), { connect: open }),
-		_transactionType: void 0
-	};
-	return typedConnection;
-};
-const createConnection = (options) => {
-	const { driverType, connect, close, initTransaction, executor, serializer } = options;
-	let client = null;
-	let connectPromise = null;
-	const getClient = async () => {
-		if (client) return client;
-		if (!connectPromise) connectPromise = connect().then((c) => {
-			client = c;
-			return c;
-		});
-		return connectPromise;
-	};
-	const typedConnection = {
-		driverType,
-		open: getClient,
-		close: () => client ? close(client) : Promise.resolve(),
-		...transactionFactoryWithDbClient(getClient, initTransaction(() => typedConnection)),
-		execute: sqlExecutor(executor({ serializer }), { connect: getClient }),
-		_transactionType: void 0
-	};
-	return typedConnection;
-};
-
-//#endregion
-//#region src/core/taskProcessing/taskProcessor.ts
-var TaskProcessor = class {
-	queue = [];
-	isProcessing = false;
-	activeTasks = 0;
-	activeGroups = /* @__PURE__ */ new Set();
-	options;
-	stopped = false;
-	constructor(options) {
-		this.options = options;
-	}
-	enqueue(task, options) {
-		if (this.stopped) return Promise.reject(new DumboError("TaskProcessor has been stopped"));
-		if (this.queue.length >= this.options.maxQueueSize) return Promise.reject(new TransientDatabaseError("Too many pending connections. Please try again later."));
-		return this.schedule(task, options);
-	}
-	waitForEndOfProcessing() {
-		return this.schedule(({ ack }) => Promise.resolve(ack()));
-	}
-	async stop(options) {
-		if (this.stopped) return;
-		this.stopped = true;
-		this.queue.length = 0;
-		this.activeGroups.clear();
-		if (!options?.force) await this.waitForEndOfProcessing();
-	}
-	schedule(task, options) {
-		return promiseWithDeadline((resolve, reject) => {
-			const taskWithContext = () => {
-				return new Promise((resolveTask, failTask) => {
-					task({ ack: resolveTask }).then(resolve).catch((err) => {
-						failTask(err);
-						reject(err);
-					});
-				});
-			};
-			this.queue.push({
-				task: taskWithContext,
-				options
-			});
-			if (!this.isProcessing) this.ensureProcessing();
-		}, { deadline: this.options.maxTaskIdleTime });
-	}
-	ensureProcessing() {
-		if (this.isProcessing) return;
-		this.isProcessing = true;
-		this.processQueue();
-	}
-	processQueue() {
-		try {
-			while (this.activeTasks < this.options.maxActiveTasks && this.queue.length > 0) {
-				const item = this.takeFirstAvailableItem();
-				if (item === null) return;
-				const groupId = item.options?.taskGroupId;
-				if (groupId) this.activeGroups.add(groupId);
-				this.activeTasks++;
-				this.executeItem(item);
-			}
-		} catch (error) {
-			console.error(error);
-			throw error;
-		} finally {
-			this.isProcessing = false;
-			if (this.hasItemsToProcess() && this.activeTasks < this.options.maxActiveTasks) this.ensureProcessing();
-		}
-	}
-	async executeItem({ task, options }) {
-		try {
-			await task();
-		} finally {
-			this.activeTasks--;
-			if (options && options.taskGroupId) this.activeGroups.delete(options.taskGroupId);
-			this.ensureProcessing();
-		}
-	}
-	takeFirstAvailableItem = () => {
-		const taskIndex = this.queue.findIndex((item) => !item.options?.taskGroupId || !this.activeGroups.has(item.options.taskGroupId));
-		if (taskIndex === -1) return null;
-		const [item] = this.queue.splice(taskIndex, 1);
-		return item ?? null;
-	};
-	hasItemsToProcess = () => this.queue.findIndex((item) => !item.options?.taskGroupId || !this.activeGroups.has(item.options.taskGroupId)) !== -1;
-};
-const DEFAULT_PROMISE_DEADLINE = 2147483647;
-const promiseWithDeadline = (executor, options) => {
-	return new Promise((resolve, reject) => {
-		let taskStarted = false;
-		let timeoutId = null;
-		const deadline = options.deadline ?? DEFAULT_PROMISE_DEADLINE;
-		timeoutId = setTimeout(() => {
-			if (!taskStarted) reject(/* @__PURE__ */ new Error("Task was not started within the maximum waiting time"));
-		}, deadline);
-		timeoutId.unref();
-		executor((value) => {
-			taskStarted = true;
-			if (timeoutId) clearTimeout(timeoutId);
-			timeoutId = null;
-			resolve(value);
-		}, (reason) => {
-			if (timeoutId) clearTimeout(timeoutId);
-			timeoutId = null;
-			reject(reason);
-		});
-	});
-};
-
-//#endregion
-//#region src/core/taskProcessing/executionGuards.ts
-const guardBoundedAccess = (getResource, options) => {
-	let isStopped = false;
-	const taskProcessor = new TaskProcessor({
-		maxActiveTasks: options.maxResources,
-		maxQueueSize: options.maxQueueSize ?? 1e3
-	});
-	const resourcePool = [];
-	const allResources = /* @__PURE__ */ new Set();
-	const ackCallbacks = /* @__PURE__ */ new Map();
-	const acquire = async () => taskProcessor.enqueue(async ({ ack }) => {
-		try {
-			let resource;
-			if (options.reuseResources) resource = resourcePool.pop();
-			if (!resource) {
-				resource = await getResource();
-				allResources.add(resource);
-			}
-			ackCallbacks.set(resource, ack);
-			return resource;
-		} catch (e) {
-			ack();
-			throw e;
-		}
-	});
-	const release = (resource) => {
-		const ack = ackCallbacks.get(resource);
-		if (ack) {
-			ackCallbacks.delete(resource);
-			if (options.reuseResources) resourcePool.push(resource);
-			ack();
-		}
-	};
-	const execute = async (operation) => {
-		const resource = await acquire();
-		try {
-			return await operation(resource);
-		} finally {
-			release(resource);
-		}
-	};
-	return {
-		acquire,
-		release,
-		execute,
-		waitForIdle: () => taskProcessor.waitForEndOfProcessing(),
-		stop: async (stopOptions) => {
-			if (isStopped) return;
-			isStopped = true;
-			if (options?.closeResource) {
-				const resources = [...allResources];
-				allResources.clear();
-				resourcePool.length = 0;
-				await Promise.all(resources.map(async (resource) => await options.closeResource(resource)));
-			}
-			await taskProcessor.stop(stopOptions);
-		}
-	};
-};
-const guardInitializedOnce = (initialize, options) => {
-	let initPromise = null;
-	const taskProcessor = new TaskProcessor({
-		maxActiveTasks: 1,
-		maxQueueSize: options?.maxQueueSize ?? 1e3
-	});
-	const ensureInitialized = async (retryCount = 0) => {
-		if (initPromise !== null) return initPromise;
-		return taskProcessor.enqueue(async ({ ack }) => {
-			if (initPromise !== null) {
-				ack();
-				return initPromise;
-			}
-			try {
-				const promise = initialize();
-				initPromise = promise;
-				const result = await promise;
-				ack();
-				return result;
-			} catch (error) {
-				initPromise = null;
-				ack();
-				if (retryCount < (options?.maxRetries ?? 3)) return ensureInitialized(retryCount + 1);
-				throw error;
-			}
-		}, { taskGroupId: (0, uuid.v7)() });
-	};
-	return {
-		ensureInitialized,
-		reset: () => {
-			initPromise = null;
-		},
-		stop: (options) => taskProcessor.stop(options)
-	};
-};
-
-//#endregion
-//#region src/core/connections/pool.ts
-const wrapPooledConnection = (conn, onClose) => ({
-	...conn,
-	close: onClose
-});
-const createAmbientConnectionPool = (options) => {
-	const { driverType, connection } = options;
-	return createConnectionPool({
-		driverType,
-		getConnection: () => connection,
-		execute: connection.execute,
-		transaction: (options) => connection.transaction(options),
-		withConnection: (handle, _options) => handle(connection),
-		withTransaction: (handle, options) => {
-			const withTx = connection.withTransaction;
-			return withTx(handle, options);
-		}
-	});
-};
-const createSingletonConnectionPool = (options) => {
-	const { driverType, getConnection } = options;
-	let connectionPromise = null;
-	const getExistingOrNewConnection = () => {
-		if (!connectionPromise) connectionPromise ??= Promise.resolve(getConnection());
-		return connectionPromise;
-	};
-	return {
-		driverType,
-		connection: () => getExistingOrNewConnection().then((conn) => wrapPooledConnection(conn, () => Promise.resolve())),
-		execute: sqlExecutorInAmbientConnection({
-			driverType,
-			connection: getExistingOrNewConnection
-		}),
-		withConnection: (handle, _options) => executeInAmbientConnection(handle, { connection: getExistingOrNewConnection }),
-		...transactionFactoryWithAsyncAmbientConnection(options.driverType, getExistingOrNewConnection, options.closeConnection),
-		close: async () => {
-			if (!connectionPromise) return;
-			await (await connectionPromise).close();
-		}
-	};
-};
-const createBoundedConnectionPool = (options) => {
-	const { driverType, maxConnections } = options;
-	const guardMaxConnections = guardBoundedAccess(options.getConnection, {
-		maxResources: maxConnections,
-		reuseResources: true
-	});
-	let closed = false;
-	const executeWithPooling = async (operation) => {
-		const conn = await guardMaxConnections.acquire();
-		try {
-			return await operation(conn);
-		} finally {
-			guardMaxConnections.release(conn);
-		}
-	};
-	return {
-		driverType,
-		connection: async () => {
-			const conn = await guardMaxConnections.acquire();
-			return wrapPooledConnection(conn, () => Promise.resolve(guardMaxConnections.release(conn)));
-		},
-		execute: {
-			query: (sql, opts) => executeWithPooling((c) => c.execute.query(sql, opts)),
-			batchQuery: (sqls, opts) => executeWithPooling((c) => c.execute.batchQuery(sqls, opts)),
-			command: (sql, opts) => executeWithPooling((c) => c.execute.command(sql, opts)),
-			batchCommand: (sqls, opts) => executeWithPooling((c) => c.execute.batchCommand(sqls, opts))
-		},
-		withConnection: executeWithPooling,
-		...transactionFactoryWithAsyncAmbientConnection(driverType, guardMaxConnections.acquire, guardMaxConnections.release),
-		close: async () => {
-			if (closed) return;
-			closed = true;
-			await guardMaxConnections.stop({ force: true });
-		}
-	};
-};
-const createSingletonClientConnectionPool = (options) => {
-	const { driverType, dbClient } = options;
-	return createSingletonConnectionPool({
-		getConnection: () => options.connectionFactory({ dbClient }),
-		driverType
-	});
-};
-const createAlwaysNewConnectionPool = (options) => {
-	const { driverType, getConnection, connectionOptions } = options;
-	return createConnectionPool({
-		driverType,
-		getConnection: () => connectionOptions ? getConnection(connectionOptions) : getConnection()
-	});
-};
-const createConnectionPool = (pool) => {
-	const { driverType, getConnection } = pool;
-	const connection = "connection" in pool ? pool.connection : () => Promise.resolve(getConnection());
-	return {
-		driverType,
-		connection,
-		withConnection: "withConnection" in pool ? pool.withConnection : (handle, _options) => executeInNewConnection(handle, { connection }),
-		close: "close" in pool ? pool.close : () => Promise.resolve(),
-		execute: "execute" in pool ? pool.execute : sqlExecutorInNewConnection({
-			driverType,
-			connection
-		}),
-		..."transaction" in pool && "withTransaction" in pool ? {
-			transaction: pool.transaction,
-			withTransaction: pool.withTransaction
-		} : transactionFactoryWithNewConnection(getConnection)
-	};
-};
-
-//#endregion
-//#region src/core/drivers/databaseDriver.ts
-const canHandleDriverWithConnectionString = (driver, tryParseConnectionString) => (options) => {
-	if ("driverType" in options) return options.driverType === driver;
-	if ("connectionString" in options && typeof options.connectionString === "string") return tryParseConnectionString(options.connectionString) !== null;
-	return false;
-};
-const DumboDatabaseDriverRegistry = () => {
-	const drivers = /* @__PURE__ */ new Map();
-	const register = (driverType, plugin) => {
-		const entry = drivers.get(driverType);
-		if (entry && (typeof entry !== "function" || typeof plugin === "function")) return;
-		drivers.set(driverType, plugin);
-	};
-	const getDriver = (options) => options.driverType ? drivers.get(options.driverType) : [...drivers.values()].find((d) => typeof d !== "function" && d.canHandle(options));
-	const tryResolve = async (options) => {
-		const driver = getDriver(options);
-		if (!driver) return null;
-		if (typeof driver !== "function") return driver;
-		const plugin = await driver();
-		register(plugin.driverType, plugin);
-		return plugin;
-	};
-	const tryGet = (options) => {
-		const driver = getDriver(options);
-		return driver && typeof driver !== "function" ? driver : null;
-	};
-	const has = (driverType) => drivers.has(driverType);
-	return {
-		register,
-		tryResolve,
-		tryGet,
-		has,
-		get databaseDriverTypes() {
-			return Array.from(drivers.keys());
-		}
-	};
-};
-const dumboDatabaseDriverRegistry = globalThis.dumboDatabaseDriverRegistry = globalThis.dumboDatabaseDriverRegistry ?? DumboDatabaseDriverRegistry();
-
-//#endregion
-//#region src/core/drivers/index.ts
-/**
-* Accepts a `databaseType` (e.g. PostgreSQL, SQLite) and a `driverName`
-* (the library name, e.g. pg, sqlite3) and combines them to a singular
-* `databaseDriverType` which can be used in database handling.
-*/
-function toDatabaseDriverType(databaseType, driverName) {
-	return `${databaseType}:${driverName}`;
-}
-/**
-* Accepts a fully formatted `driverType` and returns the broken down
-* `databaseType` and `driverName`.
-*/
-function fromDatabaseDriverType(databaseDriverType) {
-	const parts = databaseDriverType.split(":");
-	return {
-		databaseType: parts[0],
-		driverName: parts[1]
-	};
-}
-/**
-* Accepts a fully formatted `databaseDriverType` and returns the `driverName`.
-*/
-function getDatabaseDriverName(databaseDriverType) {
-	const { driverName } = fromDatabaseDriverType(databaseDriverType);
-	return driverName;
-}
-/**
-* Accepts a fully formatted `databaseDriverType` and returns the `databaseType`.
-*/
-function getDatabaseType(databaseDriverType) {
-	const { databaseType } = fromDatabaseDriverType(databaseDriverType);
-	return databaseType;
-}
-
-//#endregion
-//#region src/core/locks/databaseLock.ts
-const defaultDatabaseLockOptions = { timeoutMs: 1e4 };
-const NoDatabaseLock = {
-	acquire: () => Promise.resolve(),
-	tryAcquire: () => Promise.resolve(true),
-	release: () => Promise.resolve(true),
-	withAcquire: (_execute, handle, _options) => handle()
-};
-
-//#endregion
-//#region src/core/query/selectors.ts
-const firstOrNull = async (getResult) => {
-	const result = await getResult;
-	return result.rows.length > 0 ? result.rows[0] ?? null : null;
-};
-const first = async (getResult) => {
-	const result = await getResult;
-	if (result.rows.length === 0) throw new Error("Query didn't return any result");
-	return result.rows[0];
-};
-const singleOrNull = async (getResult) => {
-	const result = await getResult;
-	if (result.rows.length > 1) throw new Error("Query had more than one result");
-	return result.rows.length > 0 ? result.rows[0] ?? null : null;
-};
-const single = async (getResult) => {
-	const result = await getResult;
-	if (result.rows.length === 0) throw new Error("Query didn't return any result");
-	if (result.rows.length > 1) throw new Error("Query had more than one result");
-	return result.rows[0];
-};
-const count = async (getResult) => {
-	const result = await single(getResult);
-	return Number(result.count);
-};
-const exists = async (getResult) => {
-	const result = await single(getResult);
-	return result.exists === true || result.exists === 1;
-};
-
-//#endregion
-//#region src/core/schema/schemaComponent.ts
-const schemaComponent = (key, options) => {
-	const componentsMap = new Map(options.components?.map((comp) => [comp.schemaComponentKey, comp]));
-	const migrations = [...options.migrations ?? []];
-	return {
-		schemaComponentKey: key,
-		components: componentsMap,
-		get migrations() {
-			return [...migrations, ...Array.from(componentsMap.values()).flatMap((c) => c.migrations)];
-		},
-		addComponent: (component) => {
-			componentsMap.set(component.schemaComponentKey, component);
-			migrations.push(...component.migrations);
-			return component;
-		},
-		addMigration: (migration) => {
-			migrations.push(migration);
-		}
-	};
-};
-const isSchemaComponentOfType = (component, prefix) => component.schemaComponentKey.startsWith(prefix);
-const filterSchemaComponentsOfType = (components, prefix) => mapSchemaComponentsOfType(components, prefix);
-const mapSchemaComponentsOfType = (components, prefix, keyMapper) => new Map(Array.from(components.entries()).filter(([urn]) => urn.startsWith(prefix)).map(([urn, component]) => [keyMapper ? keyMapper(component) : urn, component]));
-const findSchemaComponentsOfType = (root, prefix) => {
-	const results = [];
-	const traverse = (component) => {
-		if (component.schemaComponentKey.startsWith(prefix)) results.push(component);
-		for (const child of component.components.values()) traverse(child);
-	};
-	traverse(root);
-	return results;
-};
-
-//#endregion
-//#region src/core/schema/components/columnSchemaComponent.ts
-const ColumnURNType = "sc:dumbo:column";
-const ColumnURN = ({ name }) => `${ColumnURNType}:${name}`;
-const columnSchemaComponent = (params) => {
-	const { columnName, type, notNull, unique, primaryKey, default: defaultValue, ...schemaOptions } = params;
-	return {
-		...schemaComponent(ColumnURN({ name: columnName }), schemaOptions),
-		columnName,
-		notNull,
-		unique,
-		primaryKey,
-		defaultValue,
-		sqlTokenType: "SQL_COLUMN",
-		name: columnName,
-		type
-	};
-};
-
-//#endregion
-//#region src/core/schema/components/indexSchemaComponent.ts
-const IndexURNType = "sc:dumbo:index";
-const IndexURN = ({ name }) => `${IndexURNType}:${name}`;
-const indexSchemaComponent = ({ indexName, columnNames, isUnique, ...migrationsOrComponents }) => {
-	return {
-		...schemaComponent(IndexURN({ name: indexName }), {
-			migrations: migrationsOrComponents.migrations ?? [],
-			components: [...migrationsOrComponents.components ?? []]
-		}),
-		indexName,
-		get columnNames() {
-			return columnNames;
-		},
-		addColumn: (column) => columnNames.push(typeof column === "string" ? column : column.columnName),
-		isUnique
-	};
-};
-
-//#endregion
-//#region src/core/schema/components/tableSchemaComponent.ts
-const TableURNType = "sc:dumbo:table";
-const TableURN = ({ name }) => `${TableURNType}:${name}`;
-const tableSchemaComponent = ({ tableName, columns, primaryKey, relationships, ...migrationsOrComponents }) => {
-	columns ??= {};
-	relationships ??= {};
-	const base = schemaComponent(TableURN({ name: tableName }), {
-		migrations: migrationsOrComponents.migrations ?? [],
-		components: [...migrationsOrComponents.components ?? [], ...Object.values(columns)]
-	});
-	return {
-		...base,
-		tableName,
-		primaryKey: primaryKey ?? [],
-		relationships,
-		get columns() {
-			const columnsMap = mapSchemaComponentsOfType(base.components, ColumnURNType, (c) => c.columnName);
-			return Object.assign(columnsMap, columns);
-		},
-		get indexes() {
-			return mapSchemaComponentsOfType(base.components, IndexURNType, (c) => c.indexName);
-		},
-		addColumn: (column) => base.addComponent(column),
-		addIndex: (index) => base.addComponent(index)
-	};
-};
-
-//#endregion
-//#region src/core/schema/components/databaseSchemaSchemaComponent.ts
-const DatabaseSchemaURNType = "sc:dumbo:database_schema";
-const DatabaseSchemaURN = ({ name }) => `${DatabaseSchemaURNType}:${name}`;
-const databaseSchemaSchemaComponent = ({ schemaName, tables, ...migrationsOrComponents }) => {
-	const base = schemaComponent(DatabaseSchemaURN({ name: schemaName }), {
-		migrations: migrationsOrComponents.migrations ?? [],
-		components: [...migrationsOrComponents.components ?? [], ...Object.values(tables ?? {})]
-	});
-	return {
-		...base,
-		schemaName,
-		get tables() {
-			const tablesMap = mapSchemaComponentsOfType(base.components, TableURNType, (c) => c.tableName);
-			return Object.assign(tablesMap, tables);
-		},
-		addTable: (table) => base.addComponent(typeof table === "string" ? tableSchemaComponent({ tableName: table }) : table)
-	};
-};
-
-//#endregion
-//#region src/core/schema/components/databaseSchemaComponent.ts
-const DatabaseURNType = "sc:dumbo:database";
-const DatabaseURN = ({ name }) => `${DatabaseURNType}:${name}`;
-const databaseSchemaComponent = ({ databaseName, schemas, ...migrationsOrComponents }) => {
-	schemas ??= {};
-	const base = schemaComponent(DatabaseURN({ name: databaseName }), {
-		migrations: migrationsOrComponents.migrations ?? [],
-		components: [...migrationsOrComponents.components ?? [], ...Object.values(schemas)]
-	});
-	return {
-		...base,
-		databaseName,
-		get schemas() {
-			const schemasMap = mapSchemaComponentsOfType(base.components, DatabaseSchemaURNType, (c) => c.schemaName);
-			return Object.assign(schemasMap, schemas);
-		},
-		addSchema: (schema) => base.addComponent(typeof schema === "string" ? databaseSchemaSchemaComponent({ schemaName: schema }) : schema)
-	};
-};
-
-//#endregion
-//#region src/core/schema/components/index.ts
-const schemaComponentURN = {
-	database: DatabaseURN,
-	schema: DatabaseSchemaURN,
-	table: TableURN,
-	column: ColumnURN,
-	index: IndexURN,
-	extractName: (urn) => {
-		const parts = urn.split(":");
-		return parts[parts.length - 1] || "";
-	}
-};
-
-//#endregion
-//#region src/core/schema/databaseMetadata/databaseMetadata.ts
-const DumboDatabaseMetadataRegistry = () => {
-	const infos = /* @__PURE__ */ new Map();
-	const register = (databaseType, info) => {
-		const entry = infos.get(databaseType);
-		if (entry && (typeof entry !== "function" || typeof info === "function")) return;
-		infos.set(databaseType, info);
-	};
-	const tryResolve = async (databaseType) => {
-		const entry = infos.get(databaseType);
-		if (!entry) return null;
-		if (typeof entry !== "function") return entry;
-		const resolved = await entry();
-		register(databaseType, resolved);
-		return resolved;
-	};
-	const tryGet = (databaseType) => {
-		const entry = infos.get(databaseType);
-		return entry && typeof entry !== "function" ? entry : null;
-	};
-	const has = (databaseType) => infos.has(databaseType);
-	return {
-		register,
-		tryResolve,
-		tryGet,
-		has,
-		get databaseTypes() {
-			return Array.from(infos.keys());
-		}
-	};
-};
-const dumboDatabaseMetadataRegistry = globalThis.dumboDatabaseMetadataRegistry = globalThis.dumboDatabaseMetadataRegistry ?? DumboDatabaseMetadataRegistry();
-const getDatabaseMetadata = (driverType) => {
-	const { databaseType } = fromDatabaseDriverType(driverType);
-	return dumboDatabaseMetadataRegistry.tryGet(databaseType);
-};
-const resolveDatabaseMetadata = async (driverType, driverOverride) => {
-	if (driverOverride) return driverOverride;
-	const { databaseType } = fromDatabaseDriverType(driverType);
-	return dumboDatabaseMetadataRegistry.tryResolve(databaseType);
-};
-const getDefaultDatabase = (driverType) => {
-	return getDatabaseMetadata(driverType)?.defaultDatabaseName;
-};
-const getDefaultDatabaseAsync = async (driverType) => {
-	return (await resolveDatabaseMetadata(driverType))?.defaultDatabaseName;
-};
-
-//#endregion
-//#region src/core/schema/dumboSchema/dumboSchema.ts
-const DEFAULT_DATABASE_NAME = "__default_database__";
-const DEFAULT_DATABASE_SCHEMA_NAME = "__default_database_schema__";
-const dumboColumn = (name, type, options) => columnSchemaComponent({
-	columnName: name,
-	type,
-	...options
-});
-const dumboIndex = (name, columnNames, options) => indexSchemaComponent({
-	indexName: name,
-	columnNames,
-	isUnique: options?.unique ?? false,
-	...options
-});
-const dumboTable = (name, definition) => {
-	const { columns, indexes, primaryKey, relationships, ...options } = definition;
-	const components = [...indexes ? Object.values(indexes) : []];
-	return tableSchemaComponent({
-		tableName: name,
-		columns: columns ?? {},
-		primaryKey: primaryKey ?? [],
-		...relationships !== void 0 ? { relationships } : {},
-		components,
-		...options
-	});
-};
-function dumboDatabaseSchema(nameOrTables, tables, options) {
-	return databaseSchemaSchemaComponent({
-		schemaName: typeof nameOrTables === "string" ? nameOrTables : DEFAULT_DATABASE_SCHEMA_NAME,
-		tables: (typeof nameOrTables === "string" ? tables : nameOrTables) ?? {},
-		...options
-	});
-}
-dumboDatabaseSchema.from = (schemaName, tableNames) => {
-	const tables = tableNames.reduce((acc, tableName) => {
-		acc[tableName] = dumboTable(tableName, {});
-		return acc;
-	}, {});
-	return schemaName ? dumboDatabaseSchema(schemaName, tables) : dumboDatabaseSchema(tables);
-};
-function dumboDatabase(nameOrSchemas, schemasOrOptions, options) {
-	const databaseName = typeof nameOrSchemas === "string" ? nameOrSchemas : DEFAULT_DATABASE_NAME;
-	const schemasOrSchema = typeof nameOrSchemas === "string" ? schemasOrOptions ?? {} : nameOrSchemas;
-	return databaseSchemaComponent({
-		databaseName,
-		schemas: "schemaComponentKey" in schemasOrSchema && isSchemaComponentOfType(schemasOrSchema, "sc:dumbo:database_schema") ? { [DEFAULT_DATABASE_SCHEMA_NAME]: schemasOrSchema } : schemasOrSchema,
-		...typeof nameOrSchemas === "string" ? options : schemasOrOptions
-	});
-}
-dumboDatabase.from = (databaseName, schemaNames) => {
-	const schemas = schemaNames.reduce((acc, schemaName) => {
-		acc[schemaName] = dumboDatabaseSchema(schemaName, {});
-		return acc;
-	}, {});
-	return databaseName ? dumboDatabase(databaseName, schemas) : dumboDatabase(schemas);
-};
-dumboDatabase.defaultName = DEFAULT_DATABASE_NAME;
-dumboDatabaseSchema.defaultName = DEFAULT_DATABASE_SCHEMA_NAME;
-const dumboSchema = {
-	database: dumboDatabase,
-	schema: dumboDatabaseSchema,
-	table: dumboTable,
-	column: dumboColumn,
-	index: dumboIndex
-};
-
-//#endregion
-//#region src/core/serializer/json/index.ts
-const bigIntReplacer = (_key, value) => {
-	return typeof value === "bigint" ? value.toString() : value;
-};
-const dateReplacer = (_key, value) => {
-	return value instanceof Date ? value.toISOString() : value;
-};
-const isFirstLetterNumeric = (str) => {
-	const c = str.charCodeAt(0);
-	return c >= 48 && c <= 57;
-};
-const isFirstLetterNumericOrMinus = (str) => {
-	const c = str.charCodeAt(0);
-	return c >= 48 && c <= 57 || c === 45;
-};
-const bigIntReviver = (_key, value, context) => {
-	if (typeof value === "number" && Number.isInteger(value) && !Number.isSafeInteger(value)) try {
-		return BigInt(context?.source ?? value.toString());
-	} catch {
-		return value;
-	}
-	if (typeof value === "string" && value.length > 15) {
-		if (isFirstLetterNumericOrMinus(value)) {
-			const num = Number(value);
-			if (Number.isFinite(num) && !Number.isSafeInteger(num)) try {
-				return BigInt(value);
-			} catch {}
-		}
-	}
-	return value;
-};
-const dateReviver = (_key, value) => {
-	if (typeof value === "string" && value.length === 24 && isFirstLetterNumeric(value) && value[10] === "T" && value[23] === "Z") {
-		const date = new Date(value);
-		if (!isNaN(date.getTime())) return date;
-	}
-	return value;
-};
-const composeJSONReplacers = (...replacers) => {
-	const filteredReplacers = replacers.filter((r) => r !== void 0);
-	if (filteredReplacers.length === 0) return void 0;
-	return (key, value) => filteredReplacers.reduce((accValue, replacer) => replacer(key, accValue), value);
-};
-const composeJSONRevivers = (...revivers) => {
-	const filteredRevivers = revivers.filter((r) => r !== void 0);
-	if (filteredRevivers.length === 0) return void 0;
-	return (key, value, context) => filteredRevivers.reduce((accValue, reviver) => reviver(key, accValue, context), value);
-};
-const JSONReplacer = (opts) => composeJSONReplacers(opts?.replacer, opts?.failOnBigIntSerialization !== true ? JSONReplacers.bigInt : void 0, opts?.useDefaultDateSerialization !== true ? JSONReplacers.date : void 0);
-const JSONReviver = (opts) => composeJSONRevivers(opts?.reviver, opts?.parseBigInts === true ? JSONRevivers.bigInt : void 0, opts?.parseDates === true ? JSONRevivers.date : void 0);
-const JSONReplacers = {
-	bigInt: bigIntReplacer,
-	date: dateReplacer
-};
-const JSONRevivers = {
-	bigInt: bigIntReviver,
-	date: dateReviver
-};
-const jsonSerializer = (options) => {
-	const defaultReplacer = JSONReplacer(options);
-	const defaultReviver = JSONReviver(options);
-	return {
-		serialize: (object, serializerOptions) => JSON.stringify(object, serializerOptions ? JSONReplacer(serializerOptions) : defaultReplacer),
-		deserialize: (payload, deserializerOptions) => JSON.parse(payload, deserializerOptions ? JSONReviver(deserializerOptions) : defaultReviver)
-	};
-};
-const JSONSerializer = Object.assign(jsonSerializer(), { from: (options) => options?.serialization?.serializer ?? (options?.serialization?.options ? jsonSerializer(options?.serialization?.options) : JSONSerializer) });
-const JSONCodec = (options) => {
-	const serializer = "serializer" in options ? options.serializer : jsonSerializer("serializerOptions" in options ? options.serializerOptions : void 0);
-	const upcast = options.upcast ?? ((doc) => doc);
-	const downcast = options.downcast ?? ((doc) => doc);
-	return {
-		decode: (payload, decodeOptions) => {
-			return upcast(decodeOptions ? serializer.deserialize(payload, decodeOptions) : serializer.deserialize(payload));
-		},
-		encode: (object, encodeOptions) => {
-			const downcasted = downcast(object);
-			return encodeOptions ? serializer.serialize(downcasted, encodeOptions) : serializer.serialize(downcasted);
-		}
-	};
-};
-
-//#endregion
-//#region src/core/sql/parametrizedSQL/parametrizedSQL.ts
-const ParametrizedSQLBuilder = ({ mapParamPlaceholder }) => {
-	const sql = [];
-	const params = [];
-	return {
-		addSQL(str) {
-			sql.push(str);
-			return this;
-		},
-		addParam(value) {
-			sql.push(mapParamPlaceholder(params.length, value));
-			params.push(value);
-			return this;
-		},
-		addParams(values) {
-			const placeholders = values.map((value, i) => mapParamPlaceholder(params.length + i, value));
-			this.addSQL(`${placeholders.join(", ")}`);
-			params.push(...values);
-			return this;
-		},
-		build() {
-			return {
-				query: sql.join(""),
-				params
-			};
-		}
-	};
-};
-
-//#endregion
-//#region src/core/sql/tokens/sqlToken.ts
-const SQLToken = (sqlTokenType, map) => {
-	const factory = (input) => {
-		let props;
-		if (map !== void 0) props = map(input);
-		else if (input === void 0 || input === null) props = {};
-		else if (typeof input === "object" && !Array.isArray(input)) props = input;
-		else throw new Error(`Cannot create SQLToken of type ${sqlTokenType} with input: ${input}`);
-		return {
-			sqlTokenType,
-			[sqlTokenType]: true,
-			...props
-		};
-	};
-	const check = (token) => SQLToken.check(token) && token.sqlTokenType === sqlTokenType;
-	return {
-		from: factory,
-		check,
-		type: sqlTokenType
-	};
-};
-SQLToken.check = (token) => token !== null && typeof token === "object" && "sqlTokenType" in token;
-const SQLIdentifier = SQLToken("SQL_IDENTIFIER", (value) => ({ value }));
-const SQLPlain = SQLToken("SQL_RAW", (value) => ({ value }));
-const SQLLiteral = SQLToken("SQL_LITERAL", (value) => ({ value }));
-const SQLArray = SQLToken("SQL_ARRAY", (input) => {
-	if (Array.isArray(input)) return { value: input };
-	return input.mode !== void 0 ? {
-		value: input.value,
-		mode: input.mode
-	} : { value: input.value };
-});
-const SQLIn = SQLToken("SQL_IN", ({ column, values, mode }) => mode !== void 0 ? {
-	column: SQLIdentifier.from(column),
-	values: SQLArray.from(values),
-	mode
-} : {
-	column: SQLIdentifier.from(column),
-	values: SQLArray.from(values)
-});
-
-//#endregion
-//#region src/core/sql/tokens/columnTokens.ts
-const ColumnTypeToken = (sqlTokenType, jsTypeName, map) => {
-	const factory = (input) => {
-		let props;
-		if (map !== void 0) props = map(input);
-		else if (input === void 0 || input === null) props = {};
-		else if (typeof input === "object" && !Array.isArray(input)) props = input;
-		else throw new Error(`Cannot create SQLToken of type ${sqlTokenType} with input: ${input}`);
-		return {
-			sqlTokenType,
-			[sqlTokenType]: true,
-			jsTypeName,
-			...props
-		};
-	};
-	const check = (token) => SQLToken.check(token) && token.sqlTokenType === sqlTokenType;
-	return {
-		from: factory,
-		check,
-		type: sqlTokenType
-	};
-};
-const SerialToken = ColumnTypeToken("SQL_COLUMN_SERIAL", "value_type:js:number");
-const BigSerialToken = ColumnTypeToken("SQL_COLUMN_BIGSERIAL", "value_type:js:bigint");
-const IntegerToken = ColumnTypeToken("SQL_COLUMN_INTEGER", "value_type:js:number");
-const BigIntegerToken = ColumnTypeToken("SQL_COLUMN_BIGINT", "value_type:js:bigint");
-const JSONBToken = {
-	type: "SQL_COLUMN_JSONB",
-	from: () => {
-		return {
-			sqlTokenType: "SQL_COLUMN_JSONB",
-			["SQL_COLUMN_JSONB"]: true
-		};
-	},
-	check: (token) => SQLToken.check(token) && token.sqlTokenType === "SQL_COLUMN_JSONB"
-};
-const TimestampToken = ColumnTypeToken("SQL_COLUMN_TIMESTAMP", "value_type:js:date");
-const TimestamptzToken = ColumnTypeToken("SQL_COLUMN_TIMESTAMPTZ", "value_type:js:date");
-const VarcharToken = ColumnTypeToken("SQL_COLUMN_VARCHAR", "value_type:js:string", (length) => ({
-	length: length ?? "max",
-	jsTypeName: "value_type:js:string"
-}));
-const AutoIncrementSQLColumnToken = ColumnTypeToken("SQL_COLUMN_AUTO_INCREMENT", "value_type:js:bigint");
-const SQLColumnTypeTokens = {
-	AutoIncrement: AutoIncrementSQLColumnToken,
-	BigInteger: BigIntegerToken,
-	BigSerial: BigSerialToken,
-	Integer: IntegerToken,
-	JSONB: JSONBToken,
-	Serial: SerialToken,
-	Timestamp: TimestampToken,
-	Timestamptz: TimestamptzToken,
-	Varchar: VarcharToken
-};
-const SQLColumnTypeTokensFactory = {
-	AutoIncrement: AutoIncrementSQLColumnToken.from,
-	BigInteger: BigIntegerToken.from(),
-	BigSerial: BigSerialToken.from(),
-	Integer: IntegerToken.from(),
-	JSONB: JSONBToken.from,
-	Serial: SerialToken.from(),
-	Timestamp: TimestampToken.from(),
-	Timestamptz: TimestamptzToken.from(),
-	Varchar: VarcharToken.from
-};
-const SQLColumnToken = SQLToken("SQL_COLUMN");
-
-//#endregion
-//#region src/core/sql/processors/sqlProcessor.ts
-const SQLProcessor = (options) => options;
-
-//#endregion
-//#region src/core/sql/processors/defaultProcessors.ts
-const ExpandArrayProcessor = SQLProcessor({
-	canHandle: "SQL_ARRAY",
-	handle: (token, { builder, serializer, mapper }) => {
-		if (token.value.length === 0) throw new Error("Empty arrays are not supported. If you're using it with SELECT IN statement Use SQL.in(column, array) helper instead.");
-		builder.addParams(mapper.mapValue(token.value, serializer));
-	}
-});
-const ExpandSQLInProcessor = SQLProcessor({
-	canHandle: "SQL_IN",
-	handle: (token, context) => {
-		const { builder, mapper, processorsRegistry, serializer } = context;
-		const { values: inValues, column } = token;
-		if (inValues.value.length === 0) {
-			builder.addParam(mapper.mapValue(false, serializer));
-			return;
-		}
-		builder.addSQL(mapper.mapValue(column.value, serializer));
-		builder.addSQL(` IN (`);
-		const arrayProcessor = processorsRegistry.get(SQLArray.type);
-		if (!arrayProcessor) throw new Error("No sql processor registered for an array. Cannot expand IN statement");
-		arrayProcessor.handle(inValues, {
-			builder,
-			mapper,
-			processorsRegistry,
-			serializer
-		});
-		builder.addSQL(`)`);
-	}
-});
-const FormatIdentifierProcessor = SQLProcessor({
-	canHandle: "SQL_IDENTIFIER",
-	handle: (token, { builder, mapper, serializer }) => {
-		builder.addSQL(mapper.mapValue(token, serializer));
-	}
-});
-const MapLiteralProcessor = SQLProcessor({
-	canHandle: "SQL_LITERAL",
-	handle: (token, { builder, mapper, serializer }) => builder.addParam(mapper.mapValue(token.value, serializer))
-});
-
-//#endregion
-//#region src/core/sql/processors/sqlProcessorRegistry.ts
-const SQLProcessorsRegistry = (options) => {
-	const processors = options ? new Map(options.from.all()) : /* @__PURE__ */ new Map();
-	function register(...args) {
-		if (args.length === 1 && typeof args[0] === "object" && !Array.isArray(args[0])) Object.entries(args[0]).forEach(([_, processor]) => {
-			processors.set(processor.canHandle, processor);
-		});
-		else args.forEach((p) => processors.set(p.canHandle, p));
-		return registry;
-	}
-	const registry = {
-		register,
-		get: (tokenType) => {
-			return processors.get(tokenType) ?? null;
-		},
-		all: () => processors
-	};
-	return registry;
-};
-
-//#endregion
-//#region src/core/sql/processors/columnProcessors.ts
-const mapDefaultSQLColumnProcessors = (mapColumnType) => ({
-	AutoIncrement: SQLProcessor({
-		canHandle: "SQL_COLUMN_AUTO_INCREMENT",
-		handle: (token, context) => {
-			mapColumnType(token, context);
-		}
-	}),
-	BigInteger: SQLProcessor({
-		canHandle: "SQL_COLUMN_BIGINT",
-		handle: (token, context) => mapColumnType(token, context)
-	}),
-	BigSerial: SQLProcessor({
-		canHandle: "SQL_COLUMN_BIGSERIAL",
-		handle: (token, context) => mapColumnType(token, context)
-	}),
-	Serial: SQLProcessor({
-		canHandle: "SQL_COLUMN_SERIAL",
-		handle: (token, context) => mapColumnType(token, context)
-	}),
-	Integer: SQLProcessor({
-		canHandle: "SQL_COLUMN_INTEGER",
-		handle: (token, context) => mapColumnType(token, context)
-	}),
-	JSONB: SQLProcessor({
-		canHandle: "SQL_COLUMN_JSONB",
-		handle: (token, context) => mapColumnType(token, context)
-	}),
-	Timestamp: SQLProcessor({
-		canHandle: "SQL_COLUMN_TIMESTAMP",
-		handle: (token, context) => mapColumnType(token, context)
-	}),
-	Timestamptz: SQLProcessor({
-		canHandle: "SQL_COLUMN_TIMESTAMPTZ",
-		handle: (token, context) => mapColumnType(token, context)
-	}),
-	Varchar: SQLProcessor({
-		canHandle: "SQL_COLUMN_VARCHAR",
-		handle: (token, context) => mapColumnType(token, context)
-	})
-});
-
-//#endregion
-//#region src/core/sql/processors/index.ts
-const defaultProcessorsRegistry = globalThis.defaultProcessorsRegistry = globalThis.defaultProcessorsRegistry ?? SQLProcessorsRegistry().register(FormatIdentifierProcessor, MapLiteralProcessor, ExpandArrayProcessor, ExpandSQLInProcessor);
-
-//#endregion
-//#region src/core/sql/tokenizedSQL/tokenizedSQL.ts
-const TokenizedSQLBuilder = () => {
-	const sqlChunks = [];
-	const sqlTokens = [];
-	return {
-		addSQL(str) {
-			sqlChunks.push(str);
-		},
-		addSQLs(str) {
-			sqlChunks.push(...str);
-		},
-		addToken(value) {
-			sqlTokens.push(value);
-		},
-		addTokens(vals) {
-			sqlTokens.push(...vals);
-		},
-		build() {
-			return sqlChunks.length > 0 ? {
-				__brand: "tokenized-sql",
-				sqlChunks,
-				sqlTokens
-			} : TokenizedSQL.empty;
-		}
-	};
-};
-const TokenizedSQL = (strings, values) => {
-	const builder = TokenizedSQLBuilder();
-	for (let i = 0; i < strings.length; i++) {
-		if (strings[i] !== "") builder.addSQL(strings[i]);
-		if (i >= values.length) break;
-		const value = values[i];
-		if (isTokenizedSQL(value)) {
-			builder.addSQLs(value.sqlChunks);
-			builder.addTokens(value.sqlTokens);
-		} else if (SQLPlain.check(value)) builder.addSQL(value.value);
-		else {
-			builder.addSQL(TokenizedSQL.paramPlaceholder);
-			builder.addToken(SQLToken.check(value) ? value : Array.isArray(value) ? SQLArray.from(value) : SQLLiteral.from(value));
-		}
-	}
-	return builder.build();
-};
-const isTokenizedSQL = (value) => {
-	return value !== null && typeof value === "object" && "__brand" in value && value.__brand === "tokenized-sql";
-};
-TokenizedSQL.paramPlaceholder = `__P__`;
-TokenizedSQL.empty = {
-	__brand: "tokenized-sql",
-	sqlChunks: [""],
-	sqlTokens: []
-};
-
-//#endregion
-//#region src/core/sql/sql.ts
-const createSQL = (strings, ...values) => {
-	return TokenizedSQL(strings, values);
-};
-/**
-* Creates SQL by interpolating values directly into the statement.
-*
-* Prefer {@link SQL} for query execution. `RawSQL` is for trusted SQL text that
-* is already safe to inline.
-*/
-function RawSQL(strings, ...values) {
-	let result = "";
-	for (let i = 0; i < strings.length; i++) {
-		result += strings[i];
-		if (i < values.length) result += String(values[i]);
-	}
-	return {
-		__brand: "tokenized-sql",
-		sqlChunks: [result],
-		sqlTokens: []
-	};
-}
-/** Returns true when the value is a tokenized SQL statement. */
-const isSQL = (value) => {
-	if (value === void 0 || value === null) return false;
-	return isTokenizedSQL(value);
-};
-const emptySQL = {
-	__brand: "tokenized-sql",
-	sqlChunks: [""],
-	sqlTokens: []
-};
-const mergeSQL = (sqls, separator = " ") => {
-	const parametrized = sqls.filter((sql) => !isEmpty(sql)).map((sql) => sql);
-	const params = parametrized.flatMap((p) => p.sqlTokens);
-	const sqlChunks = parametrized.flatMap((p, i) => i == parametrized.length - 1 || separator === "" ? p.sqlChunks : [...p.sqlChunks, separator]);
-	return sqlChunks.length > 0 ? {
-		__brand: "tokenized-sql",
-		sqlChunks,
-		sqlTokens: params
-	} : TokenizedSQL.empty;
-};
-const concatSQL = (...sqls) => mergeSQL(sqls, "");
-const literal = (value) => SQLPlain.from(`'${value.replace(/'/g, "''")}'`);
-const isEmpty = (sql) => {
-	if (isTokenizedSQL(sql)) {
-		const parametrized = sql;
-		return parametrized.sqlChunks.every((chunk) => chunk.trim() === "") && parametrized.sqlTokens.length === 0;
-	}
-	return false;
-};
-const columnFactory = SQLColumnToken.from;
-columnFactory.type = SQLColumnTypeTokensFactory;
-const schemaColumnFactory = ((name, type, options) => columnSchemaComponent({
-	columnName: name,
-	type,
-	...options
-}));
-const SQL = Object.assign(createSQL, {
-	EMPTY: emptySQL,
-	concat: concatSQL,
-	merge: mergeSQL,
-	format: (sql, formatter, options) => formatSQL(sql, formatter, options?.serializer ?? JSONSerializer, options),
-	describe: (sql, formatter, options) => describeSQL(sql, formatter, options?.serializer ?? JSONSerializer, options),
-	in: (column, values, options) => options?.mode ? SQLIn.from({
-		column,
-		values,
-		mode: options.mode
-	}) : SQLIn.from({
-		column,
-		values
-	}),
-	array: (values, options) => SQLArray.from(options?.mode ? {
-		value: values,
-		mode: options.mode
-	} : values),
-	identifier: SQLIdentifier.from,
-	plain: SQLPlain.from,
-	literal,
-	check: {
-		isSQL,
-		isTokenizedSQL: (value) => isTokenizedSQL(value),
-		isEmpty,
-		isIdentifier: SQLIdentifier.check,
-		isPlain: SQLPlain.check,
-		isSQLIn: SQLIn.check
-	},
-	column: columnFactory,
-	columnN: Object.assign(schemaColumnFactory, { type: SQLColumnTypeTokensFactory })
-});
-
-//#endregion
-//#region src/core/sql/valueMappers/reservedSqlWords.ts
-const ansiSqlReservedMap = {
-	ALL: true,
-	AND: true,
-	ANY: true,
-	ARRAY: true,
-	AS: true,
-	ASC: true,
-	AUTHORIZATION: true,
-	BETWEEN: true,
-	BINARY: true,
-	BOTH: true,
-	CASE: true,
-	CAST: true,
-	CHECK: true,
-	COLLATE: true,
-	COLUMN: true,
-	CONSTRAINT: true,
-	CREATE: true,
-	CROSS: true,
-	CURRENT_DATE: true,
-	CURRENT_TIME: true,
-	CURRENT_TIMESTAMP: true,
-	CURRENT_USER: true,
-	DEFAULT: true,
-	DEFERRABLE: true,
-	DESC: true,
-	DISTINCT: true,
-	DO: true,
-	ELSE: true,
-	END: true,
-	EXCEPT: true,
-	FALSE: true,
-	FOR: true,
-	FOREIGN: true,
-	FROM: true,
-	FULL: true,
-	GRANT: true,
-	GROUP: true,
-	HAVING: true,
-	IN: true,
-	INITIALLY: true,
-	INNER: true,
-	INTERSECT: true,
-	INTO: true,
-	IS: true,
-	JOIN: true,
-	LEADING: true,
-	LEFT: true,
-	LIKE: true,
-	LOCALTIME: true,
-	LOCALTIMESTAMP: true,
-	NATURAL: true,
-	NEW: true,
-	NOT: true,
-	NULL: true,
-	NULLS: true,
-	OLD: true,
-	ON: true,
-	ONLY: true,
-	OPEN: true,
-	OR: true,
-	ORDER: true,
-	OUTER: true,
-	OVERLAPS: true,
-	PARTITION: true,
-	PLACING: true,
-	PRIMARY: true,
-	REFERENCES: true,
-	RIGHT: true,
-	SELECT: true,
-	SESSION_USER: true,
-	SIMILAR: true,
-	SOME: true,
-	TABLE: true,
-	THEN: true,
-	TO: true,
-	TRAILING: true,
-	TRUE: true,
-	UNION: true,
-	UNIQUE: true,
-	USER: true,
-	USING: true,
-	WHEN: true,
-	WHERE: true,
-	WITH: true,
-	WITHOUT: true,
-	ADD: true,
-	ALTER: true,
-	ARE: true,
-	AT: true,
-	BEGIN: true,
-	BY: true,
-	CASCADE: true,
-	CLOSE: true,
-	COMMIT: true,
-	CONNECT: true,
-	CONTINUE: true,
-	CORRESPONDING: true,
-	CURSOR: true,
-	DEALLOCATE: true,
-	DECLARE: true,
-	DELETE: true,
-	DESCRIBE: true,
-	DISCONNECT: true,
-	DROP: true,
-	ESCAPE: true,
-	EXECUTE: true,
-	EXISTS: true,
-	FETCH: true,
-	FIRST: true,
-	FLOAT: true,
-	GET: true,
-	GLOBAL: true,
-	GO: true,
-	GOTO: true,
-	HOUR: true,
-	IMMEDIATE: true,
-	INDICATOR: true,
-	INPUT: true,
-	INSERT: true,
-	INT: true,
-	INTEGER: true,
-	INTERVAL: true,
-	LANGUAGE: true,
-	LAST: true,
-	LOCAL: true,
-	MATCH: true,
-	MINUTE: true,
-	MODULE: true,
-	MONTH: true,
-	NATIONAL: true,
-	NEXT: true,
-	NO: true,
-	OF: true,
-	OUTPUT: true,
-	PARTIAL: true,
-	PREPARE: true,
-	PRESERVE: true,
-	PRIOR: true,
-	PRIVILEGES: true,
-	PROCEDURE: true,
-	PUBLIC: true,
-	READ: true,
-	REAL: true,
-	RESTRICT: true,
-	REVOKE: true,
-	ROLLBACK: true,
-	ROWS: true,
-	SCHEMA: true,
-	SCROLL: true,
-	SECOND: true,
-	SECTION: true,
-	SET: true,
-	SIZE: true,
-	SMALLINT: true,
-	SQL: true,
-	SQLCODE: true,
-	SQLERROR: true,
-	SQLSTATE: true,
-	TEMPORARY: true,
-	TIMEZONE_HOUR: true,
-	TIMEZONE_MINUTE: true,
-	TRANSACTION: true,
-	TRANSLATE: true,
-	TRANSLATION: true,
-	UNKNOWN: true,
-	UPDATE: true,
-	VALUE: true,
-	VALUES: true,
-	VARCHAR: true,
-	VARYING: true,
-	VIEW: true,
-	WHENEVER: true,
-	WORK: true,
-	WRITE: true,
-	YEAR: true,
-	ZONE: true
-};
-
-//#endregion
-//#region src/core/sql/valueMappers/sqlValueMapper.ts
-const ANSISQLParamPlaceholder = "?";
-const ANSISQLIdentifierQuote = "\"";
-const mapANSISQLParamPlaceholder = () => "?";
-const isReserved = (value, reserved) => !!reserved[value.toUpperCase()];
-const mapSQLIdentifier = (value, options) => {
-	if (value === void 0 || value === null) throw new Error("SQL identifier cannot be null or undefined");
-	const ident = value.toString().slice(0);
-	const quoteSign = options?.quote ?? "\"";
-	if (/^[a-z_][a-z0-9_$]*$/.test(ident) && !isReserved(ident, options?.reservedWords ?? ansiSqlReservedMap)) return ident;
-	let quoted = quoteSign;
-	for (let i = 0; i < ident.length; i++) {
-		const c = ident[i];
-		quoted += c === quoteSign ? c + c : c;
-	}
-	quoted += quoteSign;
-	return quoted;
-};
-const DefaultMapSQLParamValueOptions = {
-	mapPlaceholder: mapANSISQLParamPlaceholder,
-	mapIdentifier: mapSQLIdentifier
-};
-const SQLValueMapper = (options) => {
-	const mapSQLParamValueOptions = {
-		...DefaultMapSQLParamValueOptions,
-		...options ?? {}
-	};
-	return {
-		mapValue: (value, serializer, mapOptions) => mapSQLParamValue(value, serializer, {
-			...mapSQLParamValueOptions,
-			...mapOptions
-		}),
-		mapPlaceholder: mapSQLParamValueOptions.mapPlaceholder,
-		mapIdentifier: mapSQLParamValueOptions.mapIdentifier
-	};
-};
-function mapSQLParamValue(value, serializer, options) {
-	if (value === null || value === void 0) return null;
-	else if (typeof value === "number") return value;
-	else if (typeof value === "string") return value;
-	else if (Array.isArray(value)) {
-		const mapValue = options?.mapValue ?? mapSQLParamValue;
-		return options?.mapArray ? options.mapArray(value, mapValue) : value.map((item) => mapValue(item, serializer, options));
-	} else if (typeof value === "boolean") return options?.mapBoolean ? options.mapBoolean(value) : value;
-	else if (typeof value === "bigint") return options?.mapBigInt ? options.mapBigInt(value) : value.toString();
-	else if (value instanceof Date) return options?.mapDate ? options.mapDate(value) : value.toISOString();
-	else if (SQL.check.isIdentifier(value)) return (options?.mapIdentifier ?? mapSQLIdentifier)(value.value);
-	else if (typeof value === "object") return options?.mapObject ? options.mapObject(value) : serializer.serialize(value);
-	else return serializer.serialize(value);
-}
-
-//#endregion
-//#region src/core/sql/formatters/sqlFormatter.ts
-const SQLFormatter = ({ format, describe, valueMapper: valueMapperOptions, processorsRegistry }) => {
-	const valueMapper = SQLValueMapper(valueMapperOptions);
-	const options = {
-		builder: ParametrizedSQLBuilder({ mapParamPlaceholder: valueMapper.mapPlaceholder }),
-		mapper: valueMapper,
-		processorsRegistry: processorsRegistry ?? defaultProcessorsRegistry
-	};
-	const resultFormatter = {
-		format: format ?? ((sql, methodOptions) => formatSQL(sql, resultFormatter, methodOptions?.serializer ?? JSONSerializer, {
-			...options,
-			...methodOptions ?? {}
-		})),
-		describe: describe ?? ((sql, methodOptions) => describeSQL(sql, resultFormatter, methodOptions?.serializer ?? JSONSerializer, {
-			...options,
-			...methodOptions ?? {}
-		})),
-		valueMapper
-	};
-	return resultFormatter;
-};
-const dumboSQLFormatters = globalThis.dumboSQLFormatters = globalThis.dumboSQLFormatters ?? {};
-const registerFormatter = (dialect, formatter) => {
-	dumboSQLFormatters[dialect] = formatter;
-};
-const getFormatter = (dialect) => {
-	const formatterKey = dialect;
-	if (!dumboSQLFormatters[formatterKey]) throw new Error(`No SQL formatter registered for dialect: ${dialect}`);
-	return dumboSQLFormatters[formatterKey];
-};
-function formatSQL(sql, formatter, serializer, context) {
-	const mapper = context?.mapper == void 0 ? formatter.valueMapper : {
-		...formatter.valueMapper,
-		...context.mapper
-	};
-	const processorsRegistry = context?.processorsRegistry ?? defaultProcessorsRegistry;
-	const merged = Array.isArray(sql) ? SQL.merge(sql, "\n") : sql;
-	if (!isTokenizedSQL(merged)) throw new Error("Expected TokenizedSQL, got string-based SQL");
-	const builder = ParametrizedSQLBuilder({ mapParamPlaceholder: mapper.mapPlaceholder });
-	let paramIndex = 0;
-	for (let i = 0; i < merged.sqlChunks.length; i++) {
-		const sqlChunk = merged.sqlChunks[i];
-		if (sqlChunk !== TokenizedSQL.paramPlaceholder) {
-			builder.addSQL(sqlChunk);
-			continue;
-		}
-		const token = merged.sqlTokens[paramIndex++];
-		const processor = processorsRegistry.get(token.sqlTokenType);
-		if (!processor) throw new Error(`No SQL processor registered for token type: ${token.sqlTokenType}`);
-		processor.handle(token, {
-			builder,
-			processorsRegistry,
-			serializer,
-			mapper
-		});
-	}
-	return builder.build();
-}
-const describeSQL = (sql, formatter, serializer, options) => formatSQL(sql, formatter, serializer, {
-	...options ?? {},
-	mapper: { mapPlaceholder: (_, value) => serializer.serialize(value) }
-}).query;
-
-//#endregion
-//#region src/core/tracing/printing/color.ts
-let enableColors = true;
-const color = {
-	set level(value) {
-		enableColors = value === 1;
-	},
-	hex: (value) => (text) => enableColors ? ansis.default.hex(value)(text) : text,
-	red: (value) => enableColors ? ansis.default.red(value) : value,
-	green: (value) => enableColors ? ansis.default.green(value) : value,
-	blue: (value) => enableColors ? ansis.default.blue(value) : value,
-	cyan: (value) => enableColors ? ansis.default.cyan(value) : value,
-	yellow: (value) => enableColors ? ansis.default.yellow(value) : value
-};
-
-//#endregion
-//#region src/core/tracing/printing/pretty.ts
-const TWO_SPACES = "  ";
-const COLOR_STRING = color.hex("#98c379");
-const COLOR_KEY = color.hex("#61afef");
-const COLOR_NUMBER_OR_DATE = color.hex("#d19a66");
-const COLOR_BOOLEAN = color.hex("#c678dd");
-const COLOR_NULL_OR_UNDEFINED = color.hex("#c678dd");
-const COLOR_BRACKETS = color.hex("#abb2bf");
-const processString = (str, indent, handleMultiline) => {
-	if (handleMultiline && str.includes("\n")) {
-		const indentedLines = str.split("\n").map((line) => indent + TWO_SPACES + COLOR_STRING(line));
-		return COLOR_STRING("\"") + "\n" + indentedLines.join("\n") + "\n" + indent + COLOR_STRING("\"");
-	}
-	return COLOR_STRING(`"${str}"`);
-};
-const shouldPrint = (obj) => typeof obj !== "function" && typeof obj !== "symbol";
-const formatJson = (obj, indentLevel = 0, handleMultiline = false) => {
-	const indent = TWO_SPACES.repeat(indentLevel);
-	if (obj === null) return COLOR_NULL_OR_UNDEFINED("null");
-	if (obj === void 0) return COLOR_NULL_OR_UNDEFINED("undefined");
-	if (typeof obj === "string") return processString(obj, indent, handleMultiline);
-	if (typeof obj === "number" || typeof obj === "bigint" || obj instanceof Date) return COLOR_NUMBER_OR_DATE(String(obj));
-	if (typeof obj === "boolean") return COLOR_BOOLEAN(String(obj));
-	if (obj instanceof Error) {
-		const errorObj = {};
-		Object.getOwnPropertyNames(obj).forEach((key) => {
-			errorObj[key] = obj[key];
-		});
-		return formatJson(errorObj, indentLevel, handleMultiline);
-	}
-	if (obj instanceof Promise) return COLOR_STRING("Promise {pending}");
-	if (Array.isArray(obj)) {
-		const arrayItems = obj.map((item) => formatJson(item, indentLevel + 1, handleMultiline));
-		return `${COLOR_BRACKETS("[")}\n${indent}  ${arrayItems.join(`,\n${indent}  `)}\n${indent}${COLOR_BRACKETS("]")}`;
-	}
-	const entries = Object.entries(obj).filter(([_, value]) => shouldPrint(value)).map(([key, value]) => `${COLOR_KEY(`"${key}"`)}: ${formatJson(value, indentLevel + 1, handleMultiline)}`);
-	return `${COLOR_BRACKETS("{")}\n${indent}  ${entries.join(`,\n${indent}  `)}\n${indent}${COLOR_BRACKETS("}")}`;
-};
-const prettyJson = (obj, options) => formatJson(obj, 0, options?.handleMultiline);
-
-//#endregion
-//#region src/core/tracing/index.ts
-const tracer = () => {};
-const LogLevel = {
-	DISABLED: "DISABLED",
-	INFO: "INFO",
-	LOG: "LOG",
-	WARN: "WARN",
-	ERROR: "ERROR"
-};
-const LogStyle = {
-	RAW: "RAW",
-	PRETTY: "PRETTY"
-};
-const getEnvVariable = (name) => {
-	try {
-		if (typeof process !== "undefined" && process.env) return process.env[name];
-		return;
-	} catch {
-		return;
-	}
-};
-const shouldLog = (logLevel) => {
-	const definedLogLevel = getEnvVariable("DUMBO_LOG_LEVEL") ?? LogLevel.ERROR;
-	if (definedLogLevel === LogLevel.ERROR && logLevel === LogLevel.ERROR) return true;
-	if (definedLogLevel === LogLevel.WARN && [LogLevel.ERROR, LogLevel.WARN].includes(logLevel)) return true;
-	if (definedLogLevel === LogLevel.LOG && [
-		LogLevel.ERROR,
-		LogLevel.WARN,
-		LogLevel.LOG
-	].includes(logLevel)) return true;
-	if (definedLogLevel === LogLevel.INFO && [
-		LogLevel.ERROR,
-		LogLevel.WARN,
-		LogLevel.LOG,
-		LogLevel.INFO
-	].includes(logLevel)) return true;
-	return false;
-};
-const nulloTraceEventRecorder = () => {};
-const getTraceEventFormatter = (logStyle, serializer = JSONSerializer) => (event) => {
-	switch (logStyle) {
-		case "RAW": return serializer.serialize(event);
-		case "PRETTY": return prettyJson(event, { handleMultiline: true });
-	}
-};
-const getTraceEventRecorder = (logLevel, logStyle) => {
-	const format = getTraceEventFormatter(logStyle);
-	switch (logLevel) {
-		case "DISABLED": return nulloTraceEventRecorder;
-		case "INFO": return (event) => console.info(format(event));
-		case "LOG": return (event) => console.log(format(event));
-		case "WARN": return (event) => console.warn(format(event));
-		case "ERROR": return (event) => console.error(format(event));
-	}
-};
-const recordTraceEvent = (logLevel, eventName, attributes) => {
-	if (!shouldLog(LogLevel.LOG)) return;
-	const event = {
-		name: eventName,
-		timestamp: (/* @__PURE__ */ new Date()).getTime(),
-		...attributes
-	};
-	getTraceEventRecorder(logLevel, getEnvVariable("DUMBO_LOG_STYLE") ?? "RAW")(event);
-};
-tracer.info = (eventName, attributes) => recordTraceEvent(LogLevel.INFO, eventName, attributes);
-tracer.warn = (eventName, attributes) => recordTraceEvent(LogLevel.WARN, eventName, attributes);
-tracer.log = (eventName, attributes) => recordTraceEvent(LogLevel.LOG, eventName, attributes);
-tracer.error = (eventName, attributes) => recordTraceEvent(LogLevel.ERROR, eventName, attributes);
-
-//#endregion
-//#region src/core/schema/sqlMigration.ts
-const sqlMigration = (name, sqls) => ({
-	name,
-	sqls
-});
-
-//#endregion
-//#region src/core/schema/migrators/schemaComponentMigrator.ts
-const { AutoIncrement, Varchar, Timestamp } = SQL.column.type;
-const migrationTableSQL = SQL`
-  CREATE TABLE IF NOT EXISTS dmb_migrations (
-    id ${AutoIncrement({ primaryKey: true })},
-    name ${Varchar(255)} NOT NULL UNIQUE,
-    application ${Varchar(255)} NOT NULL DEFAULT 'default',
-    sql_hash ${Varchar(64)} NOT NULL,
-    timestamp ${Timestamp} NOT NULL DEFAULT CURRENT_TIMESTAMP
-  );
-`;
-const migrationTableSchemaComponent = schemaComponent("dumbo:schema-component:migrations-table", { migrations: [sqlMigration("dumbo:migrationTable:001", [migrationTableSQL])] });
-const SchemaComponentMigrator = (component, dumbo) => {
-	const completedMigrations = [];
-	return {
-		component,
-		run: async (options) => {
-			const pendingMigrations = component.migrations.filter((m) => !completedMigrations.includes(`${component.schemaComponentKey}:${m.name}`));
-			if (pendingMigrations.length === 0) return;
-			await runSQLMigrations(dumbo, pendingMigrations, options);
-			completedMigrations.push(...pendingMigrations.map((m) => `${component.schemaComponentKey}:${m.name}`));
-		}
-	};
-};
-
-//#endregion
-//#region src/core/schema/migrators/migrator.ts
-const MIGRATIONS_LOCK_ID = 999956789;
-const defaultMigratorOptions = globalThis.defaultMigratorOptions = globalThis.defaultMigratorOptions ?? {};
-const registerDefaultMigratorOptions = (databaseType, options) => {
-	defaultMigratorOptions[databaseType] = options;
-};
-const getDefaultMigratorOptionsFromRegistry = (databaseType) => {
-	if (!defaultMigratorOptions[databaseType]) throw new Error(`No default migrator options registered for database type: ${databaseType}`);
-	return defaultMigratorOptions[databaseType];
-};
-const runSQLMigrations = (pool, migrations, partialOptions) => pool.withTransaction(async ({ execute }) => {
-	const databaseType = fromDatabaseDriverType(pool.driverType).databaseType;
-	const defaultOptions = getDefaultMigratorOptionsFromRegistry(databaseType);
-	partialOptions ??= {};
-	const options = {
-		...defaultOptions,
-		...partialOptions,
-		schema: {
-			...defaultOptions.schema,
-			...partialOptions?.schema ?? {}
-		},
-		lock: {
-			...defaultOptions.lock,
-			...partialOptions?.lock,
-			options: {
-				lockId: MIGRATIONS_LOCK_ID,
-				...defaultOptions.lock?.options,
-				...partialOptions?.lock?.options
-			}
-		},
-		dryRun: defaultOptions.dryRun ?? partialOptions?.dryRun,
-		ignoreMigrationHashMismatch: defaultOptions.ignoreMigrationHashMismatch ?? partialOptions?.ignoreMigrationHashMismatch,
-		migrationTimeoutMs: defaultOptions.migrationTimeoutMs ?? partialOptions?.migrationTimeoutMs
-	};
-	const { databaseLock: _, ...rest } = options.lock ?? {};
-	const databaseLock = options.lock?.databaseLock ?? NoDatabaseLock;
-	const lockOptions = {
-		lockId: MIGRATIONS_LOCK_ID,
-		...rest
-	};
-	const coreMigrations = (options.schema?.migrationTable ?? migrationTableSchemaComponent).migrations;
-	const result = {
-		applied: [],
-		skipped: []
-	};
-	await databaseLock.withAcquire(execute, async () => {
-		for (const migration of coreMigrations) await execute.batchCommand(migration.sqls, { timeoutMs: options.migrationTimeoutMs });
-		for (const migration of migrations) if (await runSQLMigration(databaseType, execute, migration, {
-			ignoreMigrationHashMismatch: options.ignoreMigrationHashMismatch ?? false,
-			migrationTimeoutMs: options.migrationTimeoutMs
-		})) result.applied.push(migration);
-		else result.skipped.push(migration);
-	}, lockOptions);
-	return {
-		success: options.dryRun ? false : true,
-		result
-	};
-});
-const runSQLMigration = async (databaseType, execute, migration, options) => {
-	const sqls = combineMigrations(migration);
-	const sqlHash = await getMigrationHash(migration, getFormatter(databaseType));
-	try {
-		const newMigration = {
-			name: migration.name,
-			sqlHash
-		};
-		const checkResult = await ensureMigrationWasNotAppliedYet(execute, newMigration);
-		if (checkResult.exists === true) {
-			if (checkResult.hashesMatch === true) {
-				tracer.info("migration-already-applied", { migrationName: migration.name });
-				return false;
-			}
-			if (options?.ignoreMigrationHashMismatch !== true) throw new Error(`Migration hash mismatch for "${migration.name}". Aborting migration.`);
-			tracer.warn("migration-hash-mismatch", {
-				migrationName: migration.name,
-				expectedHash: sqlHash,
-				actualHash: checkResult.hashFromDB
-			});
-			await updateMigrationHash(execute, newMigration);
-			return false;
-		}
-		await execute.batchCommand(sqls, { timeoutMs: options?.migrationTimeoutMs });
-		await recordMigration(execute, newMigration);
-		return true;
-	} catch (error) {
-		tracer.error("migration-error", {
-			migationName: migration.name,
-			error
-		});
-		throw error;
-	}
-};
-const getMigrationHash = async (sqlMigration, sqlFormatter) => {
-	const content = sqlFormatter.describe(sqlMigration.sqls, { serializer: JSONSerializer });
-	const data = new TextEncoder().encode(content);
-	const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-	return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
-};
-const combineMigrations = (...migration) => migration.flatMap((m) => m.sqls);
-const ensureMigrationWasNotAppliedYet = async (execute, migration) => {
-	const result = await singleOrNull(execute.query(SQL`SELECT sql_hash as "sqlHash" FROM dmb_migrations WHERE name = ${migration.name}`));
-	if (result === null) return { exists: false };
-	const { sqlHash } = result;
-	return {
-		exists: true,
-		hashesMatch: sqlHash === migration.sqlHash,
-		hashFromDB: sqlHash
-	};
-};
-const recordMigration = async (execute, migration) => {
-	await execute.command(SQL`
-      INSERT INTO dmb_migrations (name, sql_hash)
-      VALUES (${migration.name}, ${migration.sqlHash})`);
-};
-const updateMigrationHash = async (execute, migration) => {
-	await execute.command(SQL`
-      UPDATE dmb_migrations
-      SET sql_hash = ${migration.sqlHash}, timestamp = ${/* @__PURE__ */ new Date()}
-      WHERE name = ${migration.name}
-      `);
-};
-
-//#endregion
-Object.defineProperty(exports, 'ANSISQLIdentifierQuote', {
-  enumerable: true,
-  get: function () {
-    return ANSISQLIdentifierQuote;
-  }
-});
-Object.defineProperty(exports, 'ANSISQLParamPlaceholder', {
-  enumerable: true,
-  get: function () {
-    return ANSISQLParamPlaceholder;
-  }
-});
-Object.defineProperty(exports, 'AdminShutdownError', {
-  enumerable: true,
-  get: function () {
-    return AdminShutdownError;
-  }
-});
-Object.defineProperty(exports, 'AutoIncrementSQLColumnToken', {
-  enumerable: true,
-  get: function () {
-    return AutoIncrementSQLColumnToken;
-  }
-});
-Object.defineProperty(exports, 'BatchCommandNoChangesError', {
-  enumerable: true,
-  get: function () {
-    return BatchCommandNoChangesError;
-  }
-});
-Object.defineProperty(exports, 'BigIntegerToken', {
-  enumerable: true,
-  get: function () {
-    return BigIntegerToken;
-  }
-});
-Object.defineProperty(exports, 'BigSerialToken', {
-  enumerable: true,
-  get: function () {
-    return BigSerialToken;
-  }
-});
-Object.defineProperty(exports, 'CheckViolationError', {
-  enumerable: true,
-  get: function () {
-    return CheckViolationError;
-  }
-});
-Object.defineProperty(exports, 'ColumnTypeToken', {
-  enumerable: true,
-  get: function () {
-    return ColumnTypeToken;
-  }
-});
-Object.defineProperty(exports, 'ColumnURN', {
-  enumerable: true,
-  get: function () {
-    return ColumnURN;
-  }
-});
-Object.defineProperty(exports, 'ColumnURNType', {
-  enumerable: true,
-  get: function () {
-    return ColumnURNType;
-  }
-});
-Object.defineProperty(exports, 'ConcurrencyError', {
-  enumerable: true,
-  get: function () {
-    return ConcurrencyError;
-  }
-});
-Object.defineProperty(exports, 'ConnectionError', {
-  enumerable: true,
-  get: function () {
-    return ConnectionError;
-  }
-});
-Object.defineProperty(exports, 'DataError', {
-  enumerable: true,
-  get: function () {
-    return DataError;
-  }
-});
-Object.defineProperty(exports, 'DatabaseSchemaURN', {
-  enumerable: true,
-  get: function () {
-    return DatabaseSchemaURN;
-  }
-});
-Object.defineProperty(exports, 'DatabaseSchemaURNType', {
-  enumerable: true,
-  get: function () {
-    return DatabaseSchemaURNType;
-  }
-});
-Object.defineProperty(exports, 'DatabaseURN', {
-  enumerable: true,
-  get: function () {
-    return DatabaseURN;
-  }
-});
-Object.defineProperty(exports, 'DatabaseURNType', {
-  enumerable: true,
-  get: function () {
-    return DatabaseURNType;
-  }
-});
-Object.defineProperty(exports, 'DeadlockError', {
-  enumerable: true,
-  get: function () {
-    return DeadlockError;
-  }
-});
-Object.defineProperty(exports, 'DefaultMapSQLParamValueOptions', {
-  enumerable: true,
-  get: function () {
-    return DefaultMapSQLParamValueOptions;
-  }
-});
-Object.defineProperty(exports, 'DumboDatabaseDriverRegistry', {
-  enumerable: true,
-  get: function () {
-    return DumboDatabaseDriverRegistry;
-  }
-});
-Object.defineProperty(exports, 'DumboDatabaseMetadataRegistry', {
-  enumerable: true,
-  get: function () {
-    return DumboDatabaseMetadataRegistry;
-  }
-});
-Object.defineProperty(exports, 'DumboError', {
-  enumerable: true,
-  get: function () {
-    return DumboError;
-  }
-});
-Object.defineProperty(exports, 'ExclusionViolationError', {
-  enumerable: true,
-  get: function () {
-    return ExclusionViolationError;
-  }
-});
-Object.defineProperty(exports, 'ExpandArrayProcessor', {
-  enumerable: true,
-  get: function () {
-    return ExpandArrayProcessor;
-  }
-});
-Object.defineProperty(exports, 'ExpandSQLInProcessor', {
-  enumerable: true,
-  get: function () {
-    return ExpandSQLInProcessor;
-  }
-});
-Object.defineProperty(exports, 'ForeignKeyViolationError', {
-  enumerable: true,
-  get: function () {
-    return ForeignKeyViolationError;
-  }
-});
-Object.defineProperty(exports, 'FormatIdentifierProcessor', {
-  enumerable: true,
-  get: function () {
-    return FormatIdentifierProcessor;
-  }
-});
-Object.defineProperty(exports, 'IndexURN', {
-  enumerable: true,
-  get: function () {
-    return IndexURN;
-  }
-});
-Object.defineProperty(exports, 'IndexURNType', {
-  enumerable: true,
-  get: function () {
-    return IndexURNType;
-  }
-});
-Object.defineProperty(exports, 'InsufficientResourcesError', {
-  enumerable: true,
-  get: function () {
-    return InsufficientResourcesError;
-  }
-});
-Object.defineProperty(exports, 'IntegerToken', {
-  enumerable: true,
-  get: function () {
-    return IntegerToken;
-  }
-});
-Object.defineProperty(exports, 'IntegrityConstraintViolationError', {
-  enumerable: true,
-  get: function () {
-    return IntegrityConstraintViolationError;
-  }
-});
-Object.defineProperty(exports, 'InvalidOperationError', {
-  enumerable: true,
-  get: function () {
-    return InvalidOperationError;
-  }
-});
-Object.defineProperty(exports, 'JSONBToken', {
-  enumerable: true,
-  get: function () {
-    return JSONBToken;
-  }
-});
-Object.defineProperty(exports, 'JSONCodec', {
-  enumerable: true,
-  get: function () {
-    return JSONCodec;
-  }
-});
-Object.defineProperty(exports, 'JSONReplacer', {
-  enumerable: true,
-  get: function () {
-    return JSONReplacer;
-  }
-});
-Object.defineProperty(exports, 'JSONReplacers', {
-  enumerable: true,
-  get: function () {
-    return JSONReplacers;
-  }
-});
-Object.defineProperty(exports, 'JSONReviver', {
-  enumerable: true,
-  get: function () {
-    return JSONReviver;
-  }
-});
-Object.defineProperty(exports, 'JSONRevivers', {
-  enumerable: true,
-  get: function () {
-    return JSONRevivers;
-  }
-});
-Object.defineProperty(exports, 'JSONSerializer', {
-  enumerable: true,
-  get: function () {
-    return JSONSerializer;
-  }
-});
-Object.defineProperty(exports, 'LockNotAvailableError', {
-  enumerable: true,
-  get: function () {
-    return LockNotAvailableError;
-  }
-});
-Object.defineProperty(exports, 'LogLevel', {
-  enumerable: true,
-  get: function () {
-    return LogLevel;
-  }
-});
-Object.defineProperty(exports, 'LogStyle', {
-  enumerable: true,
-  get: function () {
-    return LogStyle;
-  }
-});
-Object.defineProperty(exports, 'MIGRATIONS_LOCK_ID', {
-  enumerable: true,
-  get: function () {
-    return MIGRATIONS_LOCK_ID;
-  }
-});
-Object.defineProperty(exports, 'MapLiteralProcessor', {
-  enumerable: true,
-  get: function () {
-    return MapLiteralProcessor;
-  }
-});
-Object.defineProperty(exports, 'NoDatabaseLock', {
-  enumerable: true,
-  get: function () {
-    return NoDatabaseLock;
-  }
-});
-Object.defineProperty(exports, 'NotNullViolationError', {
-  enumerable: true,
-  get: function () {
-    return NotNullViolationError;
-  }
-});
-Object.defineProperty(exports, 'ParametrizedSQLBuilder', {
-  enumerable: true,
-  get: function () {
-    return ParametrizedSQLBuilder;
-  }
-});
-Object.defineProperty(exports, 'QueryCanceledError', {
-  enumerable: true,
-  get: function () {
-    return QueryCanceledError;
-  }
-});
-Object.defineProperty(exports, 'RawSQL', {
-  enumerable: true,
-  get: function () {
-    return RawSQL;
-  }
-});
-Object.defineProperty(exports, 'SQL', {
-  enumerable: true,
-  get: function () {
-    return SQL;
-  }
-});
-Object.defineProperty(exports, 'SQLArray', {
-  enumerable: true,
-  get: function () {
-    return SQLArray;
-  }
-});
-Object.defineProperty(exports, 'SQLColumnToken', {
-  enumerable: true,
-  get: function () {
-    return SQLColumnToken;
-  }
-});
-Object.defineProperty(exports, 'SQLColumnTypeTokens', {
-  enumerable: true,
-  get: function () {
-    return SQLColumnTypeTokens;
-  }
-});
-Object.defineProperty(exports, 'SQLColumnTypeTokensFactory', {
-  enumerable: true,
-  get: function () {
-    return SQLColumnTypeTokensFactory;
-  }
-});
-Object.defineProperty(exports, 'SQLFormatter', {
-  enumerable: true,
-  get: function () {
-    return SQLFormatter;
-  }
-});
-Object.defineProperty(exports, 'SQLIdentifier', {
-  enumerable: true,
-  get: function () {
-    return SQLIdentifier;
-  }
-});
-Object.defineProperty(exports, 'SQLIn', {
-  enumerable: true,
-  get: function () {
-    return SQLIn;
-  }
-});
-Object.defineProperty(exports, 'SQLLiteral', {
-  enumerable: true,
-  get: function () {
-    return SQLLiteral;
-  }
-});
-Object.defineProperty(exports, 'SQLPlain', {
-  enumerable: true,
-  get: function () {
-    return SQLPlain;
-  }
-});
-Object.defineProperty(exports, 'SQLProcessor', {
-  enumerable: true,
-  get: function () {
-    return SQLProcessor;
-  }
-});
-Object.defineProperty(exports, 'SQLProcessorsRegistry', {
-  enumerable: true,
-  get: function () {
-    return SQLProcessorsRegistry;
-  }
-});
-Object.defineProperty(exports, 'SQLToken', {
-  enumerable: true,
-  get: function () {
-    return SQLToken;
-  }
-});
-Object.defineProperty(exports, 'SQLValueMapper', {
-  enumerable: true,
-  get: function () {
-    return SQLValueMapper;
-  }
-});
-Object.defineProperty(exports, 'SchemaComponentMigrator', {
-  enumerable: true,
-  get: function () {
-    return SchemaComponentMigrator;
-  }
-});
-Object.defineProperty(exports, 'SerialToken', {
-  enumerable: true,
-  get: function () {
-    return SerialToken;
-  }
-});
-Object.defineProperty(exports, 'SerializationError', {
-  enumerable: true,
-  get: function () {
-    return SerializationError;
-  }
-});
-Object.defineProperty(exports, 'SystemError', {
-  enumerable: true,
-  get: function () {
-    return SystemError;
-  }
-});
-Object.defineProperty(exports, 'TableURN', {
-  enumerable: true,
-  get: function () {
-    return TableURN;
-  }
-});
-Object.defineProperty(exports, 'TableURNType', {
-  enumerable: true,
-  get: function () {
-    return TableURNType;
-  }
-});
-Object.defineProperty(exports, 'TaskProcessor', {
-  enumerable: true,
-  get: function () {
-    return TaskProcessor;
-  }
-});
-Object.defineProperty(exports, 'TimestampToken', {
-  enumerable: true,
-  get: function () {
-    return TimestampToken;
-  }
-});
-Object.defineProperty(exports, 'TimestamptzToken', {
-  enumerable: true,
-  get: function () {
-    return TimestamptzToken;
-  }
-});
-Object.defineProperty(exports, 'TokenizedSQL', {
-  enumerable: true,
-  get: function () {
-    return TokenizedSQL;
-  }
-});
-Object.defineProperty(exports, 'TransientDatabaseError', {
-  enumerable: true,
-  get: function () {
-    return TransientDatabaseError;
-  }
-});
-Object.defineProperty(exports, 'UniqueConstraintError', {
-  enumerable: true,
-  get: function () {
-    return UniqueConstraintError;
-  }
-});
-Object.defineProperty(exports, 'VarcharToken', {
-  enumerable: true,
-  get: function () {
-    return VarcharToken;
-  }
-});
-Object.defineProperty(exports, '__toESM', {
-  enumerable: true,
-  get: function () {
-    return __toESM;
-  }
-});
-Object.defineProperty(exports, 'ansiSqlReservedMap', {
-  enumerable: true,
-  get: function () {
-    return ansiSqlReservedMap;
-  }
-});
-Object.defineProperty(exports, 'canHandleDriverWithConnectionString', {
-  enumerable: true,
-  get: function () {
-    return canHandleDriverWithConnectionString;
-  }
-});
-Object.defineProperty(exports, 'color', {
-  enumerable: true,
-  get: function () {
-    return color;
-  }
-});
-Object.defineProperty(exports, 'columnSchemaComponent', {
-  enumerable: true,
-  get: function () {
-    return columnSchemaComponent;
-  }
-});
-Object.defineProperty(exports, 'combineMigrations', {
-  enumerable: true,
-  get: function () {
-    return combineMigrations;
-  }
-});
-Object.defineProperty(exports, 'composeJSONReplacers', {
-  enumerable: true,
-  get: function () {
-    return composeJSONReplacers;
-  }
-});
-Object.defineProperty(exports, 'composeJSONRevivers', {
-  enumerable: true,
-  get: function () {
-    return composeJSONRevivers;
-  }
-});
-Object.defineProperty(exports, 'count', {
-  enumerable: true,
-  get: function () {
-    return count;
-  }
-});
-Object.defineProperty(exports, 'createAlwaysNewConnectionPool', {
-  enumerable: true,
-  get: function () {
-    return createAlwaysNewConnectionPool;
-  }
-});
-Object.defineProperty(exports, 'createAmbientConnection', {
-  enumerable: true,
-  get: function () {
-    return createAmbientConnection;
-  }
-});
-Object.defineProperty(exports, 'createAmbientConnectionPool', {
-  enumerable: true,
-  get: function () {
-    return createAmbientConnectionPool;
-  }
-});
-Object.defineProperty(exports, 'createBoundedConnectionPool', {
-  enumerable: true,
-  get: function () {
-    return createBoundedConnectionPool;
-  }
-});
-Object.defineProperty(exports, 'createConnection', {
-  enumerable: true,
-  get: function () {
-    return createConnection;
-  }
-});
-Object.defineProperty(exports, 'createConnectionPool', {
-  enumerable: true,
-  get: function () {
-    return createConnectionPool;
-  }
-});
-Object.defineProperty(exports, 'createSingletonClientConnectionPool', {
-  enumerable: true,
-  get: function () {
-    return createSingletonClientConnectionPool;
-  }
-});
-Object.defineProperty(exports, 'createSingletonConnection', {
-  enumerable: true,
-  get: function () {
-    return createSingletonConnection;
-  }
-});
-Object.defineProperty(exports, 'createSingletonConnectionPool', {
-  enumerable: true,
-  get: function () {
-    return createSingletonConnectionPool;
-  }
-});
-Object.defineProperty(exports, 'createTransientConnection', {
-  enumerable: true,
-  get: function () {
-    return createTransientConnection;
-  }
-});
-Object.defineProperty(exports, 'databaseSchemaComponent', {
-  enumerable: true,
-  get: function () {
-    return databaseSchemaComponent;
-  }
-});
-Object.defineProperty(exports, 'databaseSchemaSchemaComponent', {
-  enumerable: true,
-  get: function () {
-    return databaseSchemaSchemaComponent;
-  }
-});
-Object.defineProperty(exports, 'defaultDatabaseLockOptions', {
-  enumerable: true,
-  get: function () {
-    return defaultDatabaseLockOptions;
-  }
-});
-Object.defineProperty(exports, 'defaultProcessorsRegistry', {
-  enumerable: true,
-  get: function () {
-    return defaultProcessorsRegistry;
-  }
-});
-Object.defineProperty(exports, 'describeSQL', {
-  enumerable: true,
-  get: function () {
-    return describeSQL;
-  }
-});
-Object.defineProperty(exports, 'dumboDatabaseDriverRegistry', {
-  enumerable: true,
-  get: function () {
-    return dumboDatabaseDriverRegistry;
-  }
-});
-Object.defineProperty(exports, 'dumboDatabaseMetadataRegistry', {
-  enumerable: true,
-  get: function () {
-    return dumboDatabaseMetadataRegistry;
-  }
-});
-Object.defineProperty(exports, 'dumboSchema', {
-  enumerable: true,
-  get: function () {
-    return dumboSchema;
-  }
-});
-Object.defineProperty(exports, 'executeInAmbientConnection', {
-  enumerable: true,
-  get: function () {
-    return executeInAmbientConnection;
-  }
-});
-Object.defineProperty(exports, 'executeInNewConnection', {
-  enumerable: true,
-  get: function () {
-    return executeInNewConnection;
-  }
-});
-Object.defineProperty(exports, 'executeInNewDbClient', {
-  enumerable: true,
-  get: function () {
-    return executeInNewDbClient;
-  }
-});
-Object.defineProperty(exports, 'executeInTransaction', {
-  enumerable: true,
-  get: function () {
-    return executeInTransaction;
-  }
-});
-Object.defineProperty(exports, 'exists', {
-  enumerable: true,
-  get: function () {
-    return exists;
-  }
-});
-Object.defineProperty(exports, 'filterSchemaComponentsOfType', {
-  enumerable: true,
-  get: function () {
-    return filterSchemaComponentsOfType;
-  }
-});
-Object.defineProperty(exports, 'findSchemaComponentsOfType', {
-  enumerable: true,
-  get: function () {
-    return findSchemaComponentsOfType;
-  }
-});
-Object.defineProperty(exports, 'first', {
-  enumerable: true,
-  get: function () {
-    return first;
-  }
-});
-Object.defineProperty(exports, 'firstOrNull', {
-  enumerable: true,
-  get: function () {
-    return firstOrNull;
-  }
-});
-Object.defineProperty(exports, 'formatSQL', {
-  enumerable: true,
-  get: function () {
-    return formatSQL;
-  }
-});
-Object.defineProperty(exports, 'fromDatabaseDriverType', {
-  enumerable: true,
-  get: function () {
-    return fromDatabaseDriverType;
-  }
-});
-Object.defineProperty(exports, 'getDatabaseDriverName', {
-  enumerable: true,
-  get: function () {
-    return getDatabaseDriverName;
-  }
-});
-Object.defineProperty(exports, 'getDatabaseMetadata', {
-  enumerable: true,
-  get: function () {
-    return getDatabaseMetadata;
-  }
-});
-Object.defineProperty(exports, 'getDatabaseType', {
-  enumerable: true,
-  get: function () {
-    return getDatabaseType;
-  }
-});
-Object.defineProperty(exports, 'getDefaultDatabase', {
-  enumerable: true,
-  get: function () {
-    return getDefaultDatabase;
-  }
-});
-Object.defineProperty(exports, 'getDefaultDatabaseAsync', {
-  enumerable: true,
-  get: function () {
-    return getDefaultDatabaseAsync;
-  }
-});
-Object.defineProperty(exports, 'getDefaultMigratorOptionsFromRegistry', {
-  enumerable: true,
-  get: function () {
-    return getDefaultMigratorOptionsFromRegistry;
-  }
-});
-Object.defineProperty(exports, 'getFormatter', {
-  enumerable: true,
-  get: function () {
-    return getFormatter;
-  }
-});
-Object.defineProperty(exports, 'guardInitializedOnce', {
-  enumerable: true,
-  get: function () {
-    return guardInitializedOnce;
-  }
-});
-Object.defineProperty(exports, 'indexSchemaComponent', {
-  enumerable: true,
-  get: function () {
-    return indexSchemaComponent;
-  }
-});
-Object.defineProperty(exports, 'isSQL', {
-  enumerable: true,
-  get: function () {
-    return isSQL;
-  }
-});
-Object.defineProperty(exports, 'isSchemaComponentOfType', {
-  enumerable: true,
-  get: function () {
-    return isSchemaComponentOfType;
-  }
-});
-Object.defineProperty(exports, 'isTokenizedSQL', {
-  enumerable: true,
-  get: function () {
-    return isTokenizedSQL;
-  }
-});
-Object.defineProperty(exports, 'jsonSerializer', {
-  enumerable: true,
-  get: function () {
-    return jsonSerializer;
-  }
-});
-Object.defineProperty(exports, 'mapANSISQLParamPlaceholder', {
-  enumerable: true,
-  get: function () {
-    return mapANSISQLParamPlaceholder;
-  }
-});
-Object.defineProperty(exports, 'mapColumnToBigint', {
-  enumerable: true,
-  get: function () {
-    return mapColumnToBigint;
-  }
-});
-Object.defineProperty(exports, 'mapColumnToDate', {
-  enumerable: true,
-  get: function () {
-    return mapColumnToDate;
-  }
-});
-Object.defineProperty(exports, 'mapColumnToJSON', {
-  enumerable: true,
-  get: function () {
-    return mapColumnToJSON;
-  }
-});
-Object.defineProperty(exports, 'mapDefaultSQLColumnProcessors', {
-  enumerable: true,
-  get: function () {
-    return mapDefaultSQLColumnProcessors;
-  }
-});
-Object.defineProperty(exports, 'mapSQLIdentifier', {
-  enumerable: true,
-  get: function () {
-    return mapSQLIdentifier;
-  }
-});
-Object.defineProperty(exports, 'mapSQLParamValue', {
-  enumerable: true,
-  get: function () {
-    return mapSQLParamValue;
-  }
-});
-Object.defineProperty(exports, 'mapSQLQueryResult', {
-  enumerable: true,
-  get: function () {
-    return mapSQLQueryResult;
-  }
-});
-Object.defineProperty(exports, 'mapSchemaComponentsOfType', {
-  enumerable: true,
-  get: function () {
-    return mapSchemaComponentsOfType;
-  }
-});
-Object.defineProperty(exports, 'migrationTableSchemaComponent', {
-  enumerable: true,
-  get: function () {
-    return migrationTableSchemaComponent;
-  }
-});
-Object.defineProperty(exports, 'prettyJson', {
-  enumerable: true,
-  get: function () {
-    return prettyJson;
-  }
-});
-Object.defineProperty(exports, 'registerDefaultMigratorOptions', {
-  enumerable: true,
-  get: function () {
-    return registerDefaultMigratorOptions;
-  }
-});
-Object.defineProperty(exports, 'registerFormatter', {
-  enumerable: true,
-  get: function () {
-    return registerFormatter;
-  }
-});
-Object.defineProperty(exports, 'resolveDatabaseMetadata', {
-  enumerable: true,
-  get: function () {
-    return resolveDatabaseMetadata;
-  }
-});
-Object.defineProperty(exports, 'runSQLMigrations', {
-  enumerable: true,
-  get: function () {
-    return runSQLMigrations;
-  }
-});
-Object.defineProperty(exports, 'schemaComponent', {
-  enumerable: true,
-  get: function () {
-    return schemaComponent;
-  }
-});
-Object.defineProperty(exports, 'schemaComponentURN', {
-  enumerable: true,
-  get: function () {
-    return schemaComponentURN;
-  }
-});
-Object.defineProperty(exports, 'single', {
-  enumerable: true,
-  get: function () {
-    return single;
-  }
-});
-Object.defineProperty(exports, 'singleOrNull', {
-  enumerable: true,
-  get: function () {
-    return singleOrNull;
-  }
-});
-Object.defineProperty(exports, 'sqlExecutor', {
-  enumerable: true,
-  get: function () {
-    return sqlExecutor;
-  }
-});
-Object.defineProperty(exports, 'sqlExecutorInAmbientConnection', {
-  enumerable: true,
-  get: function () {
-    return sqlExecutorInAmbientConnection;
-  }
-});
-Object.defineProperty(exports, 'sqlExecutorInNewConnection', {
-  enumerable: true,
-  get: function () {
-    return sqlExecutorInNewConnection;
-  }
-});
-Object.defineProperty(exports, 'sqlMigration', {
-  enumerable: true,
-  get: function () {
-    return sqlMigration;
-  }
-});
-Object.defineProperty(exports, 'tableSchemaComponent', {
-  enumerable: true,
-  get: function () {
-    return tableSchemaComponent;
-  }
-});
-Object.defineProperty(exports, 'toDatabaseDriverType', {
-  enumerable: true,
-  get: function () {
-    return toDatabaseDriverType;
-  }
-});
-Object.defineProperty(exports, 'tracer', {
-  enumerable: true,
-  get: function () {
-    return tracer;
-  }
-});
-Object.defineProperty(exports, 'transactionFactoryWithAmbientConnection', {
-  enumerable: true,
-  get: function () {
-    return transactionFactoryWithAmbientConnection;
-  }
-});
-Object.defineProperty(exports, 'transactionFactoryWithAsyncAmbientConnection', {
-  enumerable: true,
-  get: function () {
-    return transactionFactoryWithAsyncAmbientConnection;
-  }
-});
-Object.defineProperty(exports, 'transactionFactoryWithDbClient', {
-  enumerable: true,
-  get: function () {
-    return transactionFactoryWithDbClient;
-  }
-});
-Object.defineProperty(exports, 'transactionFactoryWithNewConnection', {
-  enumerable: true,
-  get: function () {
-    return transactionFactoryWithNewConnection;
-  }
-});
-//# sourceMappingURL=core-BPSzA-lq.cjs.map