@fragno-dev/workflows 0.0.1

package/dist/node/node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/textParsers.js

@@ -0,0 +1,169 @@
+import { __commonJS } from "../../../../../../_virtual/rolldown_runtime.js";
+import { require_postgres_array } from "../../../../postgres-array@2.0.0/node_modules/postgres-array/index.js";
+import { require_arrayParser } from "./arrayParser.js";
+import { require_postgres_date } from "../../../../postgres-date@1.0.7/node_modules/postgres-date/index.js";
+import { require_postgres_interval } from "../../../../postgres-interval@1.2.0/node_modules/postgres-interval/index.js";
+import { require_postgres_bytea } from "../../../../postgres-bytea@1.0.1/node_modules/postgres-bytea/index.js";
+
+//#region ../../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/textParsers.js
+var require_textParsers = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/textParsers.js": ((exports, module) => {
+	var array = require_postgres_array();
+	var arrayParser = require_arrayParser();
+	var parseDate = require_postgres_date();
+	var parseInterval = require_postgres_interval();
+	var parseByteA = require_postgres_bytea();
+	function allowNull(fn) {
+		return function nullAllowed(value) {
+			if (value === null) return value;
+			return fn(value);
+		};
+	}
+	function parseBool(value) {
+		if (value === null) return value;
+		return value === "TRUE" || value === "t" || value === "true" || value === "y" || value === "yes" || value === "on" || value === "1";
+	}
+	function parseBoolArray(value) {
+		if (!value) return null;
+		return array.parse(value, parseBool);
+	}
+	function parseBaseTenInt(string) {
+		return parseInt(string, 10);
+	}
+	function parseIntegerArray(value) {
+		if (!value) return null;
+		return array.parse(value, allowNull(parseBaseTenInt));
+	}
+	function parseBigIntegerArray(value) {
+		if (!value) return null;
+		return array.parse(value, allowNull(function(entry) {
+			return parseBigInteger(entry).trim();
+		}));
+	}
+	var parsePointArray = function(value) {
+		if (!value) return null;
+		return arrayParser.create(value, function(entry) {
+			if (entry !== null) entry = parsePoint(entry);
+			return entry;
+		}).parse();
+	};
+	var parseFloatArray = function(value) {
+		if (!value) return null;
+		return arrayParser.create(value, function(entry) {
+			if (entry !== null) entry = parseFloat(entry);
+			return entry;
+		}).parse();
+	};
+	var parseStringArray = function(value) {
+		if (!value) return null;
+		return arrayParser.create(value).parse();
+	};
+	var parseDateArray = function(value) {
+		if (!value) return null;
+		return arrayParser.create(value, function(entry) {
+			if (entry !== null) entry = parseDate(entry);
+			return entry;
+		}).parse();
+	};
+	var parseIntervalArray = function(value) {
+		if (!value) return null;
+		return arrayParser.create(value, function(entry) {
+			if (entry !== null) entry = parseInterval(entry);
+			return entry;
+		}).parse();
+	};
+	var parseByteAArray = function(value) {
+		if (!value) return null;
+		return array.parse(value, allowNull(parseByteA));
+	};
+	var parseInteger = function(value) {
+		return parseInt(value, 10);
+	};
+	var parseBigInteger = function(value) {
+		var valStr = String(value);
+		if (/^\d+$/.test(valStr)) return valStr;
+		return value;
+	};
+	var parseJsonArray = function(value) {
+		if (!value) return null;
+		return array.parse(value, allowNull(JSON.parse));
+	};
+	var parsePoint = function(value) {
+		if (value[0] !== "(") return null;
+		value = value.substring(1, value.length - 1).split(",");
+		return {
+			x: parseFloat(value[0]),
+			y: parseFloat(value[1])
+		};
+	};
+	var parseCircle = function(value) {
+		if (value[0] !== "<" && value[1] !== "(") return null;
+		var point = "(";
+		var radius = "";
+		var pointParsed = false;
+		for (var i = 2; i < value.length - 1; i++) {
+			if (!pointParsed) point += value[i];
+			if (value[i] === ")") {
+				pointParsed = true;
+				continue;
+			} else if (!pointParsed) continue;
+			if (value[i] === ",") continue;
+			radius += value[i];
+		}
+		var result = parsePoint(point);
+		result.radius = parseFloat(radius);
+		return result;
+	};
+	var init = function(register) {
+		register(20, parseBigInteger);
+		register(21, parseInteger);
+		register(23, parseInteger);
+		register(26, parseInteger);
+		register(700, parseFloat);
+		register(701, parseFloat);
+		register(16, parseBool);
+		register(1082, parseDate);
+		register(1114, parseDate);
+		register(1184, parseDate);
+		register(600, parsePoint);
+		register(651, parseStringArray);
+		register(718, parseCircle);
+		register(1e3, parseBoolArray);
+		register(1001, parseByteAArray);
+		register(1005, parseIntegerArray);
+		register(1007, parseIntegerArray);
+		register(1028, parseIntegerArray);
+		register(1016, parseBigIntegerArray);
+		register(1017, parsePointArray);
+		register(1021, parseFloatArray);
+		register(1022, parseFloatArray);
+		register(1231, parseFloatArray);
+		register(1014, parseStringArray);
+		register(1015, parseStringArray);
+		register(1008, parseStringArray);
+		register(1009, parseStringArray);
+		register(1040, parseStringArray);
+		register(1041, parseStringArray);
+		register(1115, parseDateArray);
+		register(1182, parseDateArray);
+		register(1185, parseDateArray);
+		register(1186, parseInterval);
+		register(1187, parseIntervalArray);
+		register(17, parseByteA);
+		register(114, JSON.parse.bind(JSON));
+		register(3802, JSON.parse.bind(JSON));
+		register(199, parseJsonArray);
+		register(3807, parseJsonArray);
+		register(3907, parseStringArray);
+		register(2951, parseStringArray);
+		register(791, parseStringArray);
+		register(1183, parseStringArray);
+		register(1270, parseStringArray);
+	};
+	module.exports = { init };
+}) });
+
+//#endregion
+export default require_textParsers();
+
+export { require_textParsers };
+//# sourceMappingURL=textParsers.js.map

package/dist/node/node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/textParsers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"textParsers.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/textParsers.js"],"sourcesContent":["var array = require('postgres-array')\nvar arrayParser = require('./arrayParser');\nvar parseDate = require('postgres-date');\nvar parseInterval = require('postgres-interval');\nvar parseByteA = require('postgres-bytea');\n\nfunction allowNull (fn) {\n  return function nullAllowed (value) {\n    if (value === null) return value\n    return fn(value)\n  }\n}\n\nfunction parseBool (value) {\n  if (value === null) return value\n  return value === 'TRUE' ||\n    value === 't' ||\n    value === 'true' ||\n    value === 'y' ||\n    value === 'yes' ||\n    value === 'on' ||\n    value === '1';\n}\n\nfunction parseBoolArray (value) {\n  if (!value) return null\n  return array.parse(value, parseBool)\n}\n\nfunction parseBaseTenInt (string) {\n  return parseInt(string, 10)\n}\n\nfunction parseIntegerArray (value) {\n  if (!value) return null\n  return array.parse(value, allowNull(parseBaseTenInt))\n}\n\nfunction parseBigIntegerArray (value) {\n  if (!value) return null\n  return array.parse(value, allowNull(function (entry) {\n    return parseBigInteger(entry).trim()\n  }))\n}\n\nvar parsePointArray = function(value) {\n  if(!value) { return null; }\n  var p = arrayParser.create(value, function(entry) {\n    if(entry !== null) {\n      entry = parsePoint(entry);\n    }\n    return entry;\n  });\n\n  return p.parse();\n};\n\nvar parseFloatArray = function(value) {\n  if(!value) { return null; }\n  var p = arrayParser.create(value, function(entry) {\n    if(entry !== null) {\n      entry = parseFloat(entry);\n    }\n    return entry;\n  });\n\n  return p.parse();\n};\n\nvar parseStringArray = function(value) {\n  if(!value) { return null; }\n\n  var p = arrayParser.create(value);\n  return p.parse();\n};\n\nvar parseDateArray = function(value) {\n  if (!value) { return null; }\n\n  var p = arrayParser.create(value, function(entry) {\n    if (entry !== null) {\n      entry = parseDate(entry);\n    }\n    return entry;\n  });\n\n  return p.parse();\n};\n\nvar parseIntervalArray = function(value) {\n  if (!value) { return null; }\n\n  var p = arrayParser.create(value, function(entry) {\n    if (entry !== null) {\n      entry = parseInterval(entry);\n    }\n    return entry;\n  });\n\n  return p.parse();\n};\n\nvar parseByteAArray = function(value) {\n  if (!value) { return null; }\n\n  return array.parse(value, allowNull(parseByteA));\n};\n\nvar parseInteger = function(value) {\n  return parseInt(value, 10);\n};\n\nvar parseBigInteger = function(value) {\n  var valStr = String(value);\n  if (/^\\d+$/.test(valStr)) { return valStr; }\n  return value;\n};\n\nvar parseJsonArray = function(value) {\n  if (!value) { return null; }\n\n  return array.parse(value, allowNull(JSON.parse));\n};\n\nvar parsePoint = function(value) {\n  if (value[0] !== '(') { return null; }\n\n  value = value.substring( 1, value.length - 1 ).split(',');\n\n  return {\n    x: parseFloat(value[0])\n  , y: parseFloat(value[1])\n  };\n};\n\nvar parseCircle = function(value) {\n  if (value[0] !== '<' && value[1] !== '(') { return null; }\n\n  var point = '(';\n  var radius = '';\n  var pointParsed = false;\n  for (var i = 2; i < value.length - 1; i++){\n    if (!pointParsed) {\n      point += value[i];\n    }\n\n    if (value[i] === ')') {\n      pointParsed = true;\n      continue;\n    } else if (!pointParsed) {\n      continue;\n    }\n\n    if (value[i] === ','){\n      continue;\n    }\n\n    radius += value[i];\n  }\n  var result = parsePoint(point);\n  result.radius = parseFloat(radius);\n\n  return result;\n};\n\nvar init = function(register) {\n  register(20, parseBigInteger); // int8\n  register(21, parseInteger); // int2\n  register(23, parseInteger); // int4\n  register(26, parseInteger); // oid\n  register(700, parseFloat); // float4/real\n  register(701, parseFloat); // float8/double\n  register(16, parseBool);\n  register(1082, parseDate); // date\n  register(1114, parseDate); // timestamp without timezone\n  register(1184, parseDate); // timestamp\n  register(600, parsePoint); // point\n  register(651, parseStringArray); // cidr[]\n  register(718, parseCircle); // circle\n  register(1000, parseBoolArray);\n  register(1001, parseByteAArray);\n  register(1005, parseIntegerArray); // _int2\n  register(1007, parseIntegerArray); // _int4\n  register(1028, parseIntegerArray); // oid[]\n  register(1016, parseBigIntegerArray); // _int8\n  register(1017, parsePointArray); // point[]\n  register(1021, parseFloatArray); // _float4\n  register(1022, parseFloatArray); // _float8\n  register(1231, parseFloatArray); // _numeric\n  register(1014, parseStringArray); //char\n  register(1015, parseStringArray); //varchar\n  register(1008, parseStringArray);\n  register(1009, parseStringArray);\n  register(1040, parseStringArray); // macaddr[]\n  register(1041, parseStringArray); // inet[]\n  register(1115, parseDateArray); // timestamp without time zone[]\n  register(1182, parseDateArray); // _date\n  register(1185, parseDateArray); // timestamp with time zone[]\n  register(1186, parseInterval);\n  register(1187, parseIntervalArray);\n  register(17, parseByteA);\n  register(114, JSON.parse.bind(JSON)); // json\n  register(3802, JSON.parse.bind(JSON)); // jsonb\n  register(199, parseJsonArray); // json[]\n  register(3807, parseJsonArray); // jsonb[]\n  register(3907, parseStringArray); // numrange[]\n  register(2951, parseStringArray); // uuid[]\n  register(791, parseStringArray); // money[]\n  register(1183, parseStringArray); // time[]\n  register(1270, parseStringArray); // timetz[]\n};\n\nmodule.exports = {\n  init: init\n};\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node/node_modules/.pnpm/pg@8.18.0/node_modules/pg/lib/client.js

@@ -0,0 +1,505 @@
+import { __commonJS, __require } from "../../../../../../_virtual/rolldown_runtime.js";
+import { require_defaults } from "./defaults.js";
+import { require_utils } from "./utils.js";
+import { require_utils as require_utils$1 } from "./crypto/utils.js";
+import { require_sasl } from "./crypto/sasl.js";
+import { require_type_overrides } from "./type-overrides.js";
+import { require_connection_parameters } from "./connection-parameters.js";
+import { require_query } from "./query.js";
+import { require_connection } from "./connection.js";
+import { require_lib } from "../../../../pgpass@1.0.5/node_modules/pgpass/lib/index.js";
+
+//#region ../../node_modules/.pnpm/pg@8.18.0/node_modules/pg/lib/client.js
+var require_client = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/pg@8.18.0/node_modules/pg/lib/client.js": ((exports, module) => {
+	const EventEmitter = __require("events").EventEmitter;
+	const utils = require_utils();
+	const nodeUtils = __require("util");
+	const sasl = require_sasl();
+	const TypeOverrides = require_type_overrides();
+	const ConnectionParameters = require_connection_parameters();
+	const Query = require_query();
+	const defaults = require_defaults();
+	const Connection = require_connection();
+	const crypto = require_utils$1();
+	const activeQueryDeprecationNotice = nodeUtils.deprecate(() => {}, "Client.activeQuery is deprecated and will be removed in a future version.");
+	const queryQueueDeprecationNotice = nodeUtils.deprecate(() => {}, "Client.queryQueue is deprecated and will be removed in a future version.");
+	const pgPassDeprecationNotice = nodeUtils.deprecate(() => {}, "pgpass support is deprecated and will be removed in a future version. You can provide an async function as the password property to the Client/Pool constructor that returns a password instead. Within this funciton you can call the pgpass module in your own code.");
+	const byoPromiseDeprecationNotice = nodeUtils.deprecate(() => {}, "Passing a custom Promise implementation to the Client/Pool constructor is deprecated and will be removed in a future version.");
+	var Client = class extends EventEmitter {
+		constructor(config) {
+			super();
+			this.connectionParameters = new ConnectionParameters(config);
+			this.user = this.connectionParameters.user;
+			this.database = this.connectionParameters.database;
+			this.port = this.connectionParameters.port;
+			this.host = this.connectionParameters.host;
+			Object.defineProperty(this, "password", {
+				configurable: true,
+				enumerable: false,
+				writable: true,
+				value: this.connectionParameters.password
+			});
+			this.replication = this.connectionParameters.replication;
+			const c = config || {};
+			if (c.Promise) byoPromiseDeprecationNotice();
+			this._Promise = c.Promise || global.Promise;
+			this._types = new TypeOverrides(c.types);
+			this._ending = false;
+			this._ended = false;
+			this._connecting = false;
+			this._connected = false;
+			this._connectionError = false;
+			this._queryable = true;
+			this._activeQuery = null;
+			this.enableChannelBinding = Boolean(c.enableChannelBinding);
+			this.connection = c.connection || new Connection({
+				stream: c.stream,
+				ssl: this.connectionParameters.ssl,
+				keepAlive: c.keepAlive || false,
+				keepAliveInitialDelayMillis: c.keepAliveInitialDelayMillis || 0,
+				encoding: this.connectionParameters.client_encoding || "utf8"
+			});
+			this._queryQueue = [];
+			this.binary = c.binary || defaults.binary;
+			this.processID = null;
+			this.secretKey = null;
+			this.ssl = this.connectionParameters.ssl || false;
+			if (this.ssl && this.ssl.key) Object.defineProperty(this.ssl, "key", { enumerable: false });
+			this._connectionTimeoutMillis = c.connectionTimeoutMillis || 0;
+		}
+		get activeQuery() {
+			activeQueryDeprecationNotice();
+			return this._activeQuery;
+		}
+		set activeQuery(val) {
+			activeQueryDeprecationNotice();
+			this._activeQuery = val;
+		}
+		_getActiveQuery() {
+			return this._activeQuery;
+		}
+		_errorAllQueries(err) {
+			const enqueueError = (query) => {
+				process.nextTick(() => {
+					query.handleError(err, this.connection);
+				});
+			};
+			const activeQuery = this._getActiveQuery();
+			if (activeQuery) {
+				enqueueError(activeQuery);
+				this._activeQuery = null;
+			}
+			this._queryQueue.forEach(enqueueError);
+			this._queryQueue.length = 0;
+		}
+		_connect(callback) {
+			const self = this;
+			const con = this.connection;
+			this._connectionCallback = callback;
+			if (this._connecting || this._connected) {
+				const err = /* @__PURE__ */ new Error("Client has already been connected. You cannot reuse a client.");
+				process.nextTick(() => {
+					callback(err);
+				});
+				return;
+			}
+			this._connecting = true;
+			if (this._connectionTimeoutMillis > 0) {
+				this.connectionTimeoutHandle = setTimeout(() => {
+					con._ending = true;
+					con.stream.destroy(/* @__PURE__ */ new Error("timeout expired"));
+				}, this._connectionTimeoutMillis);
+				if (this.connectionTimeoutHandle.unref) this.connectionTimeoutHandle.unref();
+			}
+			if (this.host && this.host.indexOf("/") === 0) con.connect(this.host + "/.s.PGSQL." + this.port);
+			else con.connect(this.port, this.host);
+			con.on("connect", function() {
+				if (self.ssl) con.requestSsl();
+				else con.startup(self.getStartupConf());
+			});
+			con.on("sslconnect", function() {
+				con.startup(self.getStartupConf());
+			});
+			this._attachListeners(con);
+			con.once("end", () => {
+				const error = this._ending ? /* @__PURE__ */ new Error("Connection terminated") : /* @__PURE__ */ new Error("Connection terminated unexpectedly");
+				clearTimeout(this.connectionTimeoutHandle);
+				this._errorAllQueries(error);
+				this._ended = true;
+				if (!this._ending) {
+					if (this._connecting && !this._connectionError) if (this._connectionCallback) this._connectionCallback(error);
+					else this._handleErrorEvent(error);
+					else if (!this._connectionError) this._handleErrorEvent(error);
+				}
+				process.nextTick(() => {
+					this.emit("end");
+				});
+			});
+		}
+		connect(callback) {
+			if (callback) {
+				this._connect(callback);
+				return;
+			}
+			return new this._Promise((resolve, reject) => {
+				this._connect((error) => {
+					if (error) reject(error);
+					else resolve(this);
+				});
+			});
+		}
+		_attachListeners(con) {
+			con.on("authenticationCleartextPassword", this._handleAuthCleartextPassword.bind(this));
+			con.on("authenticationMD5Password", this._handleAuthMD5Password.bind(this));
+			con.on("authenticationSASL", this._handleAuthSASL.bind(this));
+			con.on("authenticationSASLContinue", this._handleAuthSASLContinue.bind(this));
+			con.on("authenticationSASLFinal", this._handleAuthSASLFinal.bind(this));
+			con.on("backendKeyData", this._handleBackendKeyData.bind(this));
+			con.on("error", this._handleErrorEvent.bind(this));
+			con.on("errorMessage", this._handleErrorMessage.bind(this));
+			con.on("readyForQuery", this._handleReadyForQuery.bind(this));
+			con.on("notice", this._handleNotice.bind(this));
+			con.on("rowDescription", this._handleRowDescription.bind(this));
+			con.on("dataRow", this._handleDataRow.bind(this));
+			con.on("portalSuspended", this._handlePortalSuspended.bind(this));
+			con.on("emptyQuery", this._handleEmptyQuery.bind(this));
+			con.on("commandComplete", this._handleCommandComplete.bind(this));
+			con.on("parseComplete", this._handleParseComplete.bind(this));
+			con.on("copyInResponse", this._handleCopyInResponse.bind(this));
+			con.on("copyData", this._handleCopyData.bind(this));
+			con.on("notification", this._handleNotification.bind(this));
+		}
+		_getPassword(cb) {
+			const con = this.connection;
+			if (typeof this.password === "function") this._Promise.resolve().then(() => this.password()).then((pass) => {
+				if (pass !== void 0) {
+					if (typeof pass !== "string") {
+						con.emit("error", /* @__PURE__ */ new TypeError("Password must be a string"));
+						return;
+					}
+					this.connectionParameters.password = this.password = pass;
+				} else this.connectionParameters.password = this.password = null;
+				cb();
+			}).catch((err) => {
+				con.emit("error", err);
+			});
+			else if (this.password !== null) cb();
+			else try {
+				require_lib()(this.connectionParameters, (pass) => {
+					if (void 0 !== pass) {
+						pgPassDeprecationNotice();
+						this.connectionParameters.password = this.password = pass;
+					}
+					cb();
+				});
+			} catch (e) {
+				this.emit("error", e);
+			}
+		}
+		_handleAuthCleartextPassword(msg) {
+			this._getPassword(() => {
+				this.connection.password(this.password);
+			});
+		}
+		_handleAuthMD5Password(msg) {
+			this._getPassword(async () => {
+				try {
+					const hashedPassword = await crypto.postgresMd5PasswordHash(this.user, this.password, msg.salt);
+					this.connection.password(hashedPassword);
+				} catch (e) {
+					this.emit("error", e);
+				}
+			});
+		}
+		_handleAuthSASL(msg) {
+			this._getPassword(() => {
+				try {
+					this.saslSession = sasl.startSession(msg.mechanisms, this.enableChannelBinding && this.connection.stream);
+					this.connection.sendSASLInitialResponseMessage(this.saslSession.mechanism, this.saslSession.response);
+				} catch (err) {
+					this.connection.emit("error", err);
+				}
+			});
+		}
+		async _handleAuthSASLContinue(msg) {
+			try {
+				await sasl.continueSession(this.saslSession, this.password, msg.data, this.enableChannelBinding && this.connection.stream);
+				this.connection.sendSCRAMClientFinalMessage(this.saslSession.response);
+			} catch (err) {
+				this.connection.emit("error", err);
+			}
+		}
+		_handleAuthSASLFinal(msg) {
+			try {
+				sasl.finalizeSession(this.saslSession, msg.data);
+				this.saslSession = null;
+			} catch (err) {
+				this.connection.emit("error", err);
+			}
+		}
+		_handleBackendKeyData(msg) {
+			this.processID = msg.processID;
+			this.secretKey = msg.secretKey;
+		}
+		_handleReadyForQuery(msg) {
+			if (this._connecting) {
+				this._connecting = false;
+				this._connected = true;
+				clearTimeout(this.connectionTimeoutHandle);
+				if (this._connectionCallback) {
+					this._connectionCallback(null, this);
+					this._connectionCallback = null;
+				}
+				this.emit("connect");
+			}
+			const activeQuery = this._getActiveQuery();
+			this._activeQuery = null;
+			this.readyForQuery = true;
+			if (activeQuery) activeQuery.handleReadyForQuery(this.connection);
+			this._pulseQueryQueue();
+		}
+		_handleErrorWhileConnecting(err) {
+			if (this._connectionError) return;
+			this._connectionError = true;
+			clearTimeout(this.connectionTimeoutHandle);
+			if (this._connectionCallback) return this._connectionCallback(err);
+			this.emit("error", err);
+		}
+		_handleErrorEvent(err) {
+			if (this._connecting) return this._handleErrorWhileConnecting(err);
+			this._queryable = false;
+			this._errorAllQueries(err);
+			this.emit("error", err);
+		}
+		_handleErrorMessage(msg) {
+			if (this._connecting) return this._handleErrorWhileConnecting(msg);
+			const activeQuery = this._getActiveQuery();
+			if (!activeQuery) {
+				this._handleErrorEvent(msg);
+				return;
+			}
+			this._activeQuery = null;
+			activeQuery.handleError(msg, this.connection);
+		}
+		_handleRowDescription(msg) {
+			const activeQuery = this._getActiveQuery();
+			if (activeQuery == null) {
+				const error = /* @__PURE__ */ new Error("Received unexpected rowDescription message from backend.");
+				this._handleErrorEvent(error);
+				return;
+			}
+			activeQuery.handleRowDescription(msg);
+		}
+		_handleDataRow(msg) {
+			const activeQuery = this._getActiveQuery();
+			if (activeQuery == null) {
+				const error = /* @__PURE__ */ new Error("Received unexpected dataRow message from backend.");
+				this._handleErrorEvent(error);
+				return;
+			}
+			activeQuery.handleDataRow(msg);
+		}
+		_handlePortalSuspended(msg) {
+			const activeQuery = this._getActiveQuery();
+			if (activeQuery == null) {
+				const error = /* @__PURE__ */ new Error("Received unexpected portalSuspended message from backend.");
+				this._handleErrorEvent(error);
+				return;
+			}
+			activeQuery.handlePortalSuspended(this.connection);
+		}
+		_handleEmptyQuery(msg) {
+			const activeQuery = this._getActiveQuery();
+			if (activeQuery == null) {
+				const error = /* @__PURE__ */ new Error("Received unexpected emptyQuery message from backend.");
+				this._handleErrorEvent(error);
+				return;
+			}
+			activeQuery.handleEmptyQuery(this.connection);
+		}
+		_handleCommandComplete(msg) {
+			const activeQuery = this._getActiveQuery();
+			if (activeQuery == null) {
+				const error = /* @__PURE__ */ new Error("Received unexpected commandComplete message from backend.");
+				this._handleErrorEvent(error);
+				return;
+			}
+			activeQuery.handleCommandComplete(msg, this.connection);
+		}
+		_handleParseComplete() {
+			const activeQuery = this._getActiveQuery();
+			if (activeQuery == null) {
+				const error = /* @__PURE__ */ new Error("Received unexpected parseComplete message from backend.");
+				this._handleErrorEvent(error);
+				return;
+			}
+			if (activeQuery.name) this.connection.parsedStatements[activeQuery.name] = activeQuery.text;
+		}
+		_handleCopyInResponse(msg) {
+			const activeQuery = this._getActiveQuery();
+			if (activeQuery == null) {
+				const error = /* @__PURE__ */ new Error("Received unexpected copyInResponse message from backend.");
+				this._handleErrorEvent(error);
+				return;
+			}
+			activeQuery.handleCopyInResponse(this.connection);
+		}
+		_handleCopyData(msg) {
+			const activeQuery = this._getActiveQuery();
+			if (activeQuery == null) {
+				const error = /* @__PURE__ */ new Error("Received unexpected copyData message from backend.");
+				this._handleErrorEvent(error);
+				return;
+			}
+			activeQuery.handleCopyData(msg, this.connection);
+		}
+		_handleNotification(msg) {
+			this.emit("notification", msg);
+		}
+		_handleNotice(msg) {
+			this.emit("notice", msg);
+		}
+		getStartupConf() {
+			const params = this.connectionParameters;
+			const data = {
+				user: params.user,
+				database: params.database
+			};
+			const appName = params.application_name || params.fallback_application_name;
+			if (appName) data.application_name = appName;
+			if (params.replication) data.replication = "" + params.replication;
+			if (params.statement_timeout) data.statement_timeout = String(parseInt(params.statement_timeout, 10));
+			if (params.lock_timeout) data.lock_timeout = String(parseInt(params.lock_timeout, 10));
+			if (params.idle_in_transaction_session_timeout) data.idle_in_transaction_session_timeout = String(parseInt(params.idle_in_transaction_session_timeout, 10));
+			if (params.options) data.options = params.options;
+			return data;
+		}
+		cancel(client, query) {
+			if (client.activeQuery === query) {
+				const con = this.connection;
+				if (this.host && this.host.indexOf("/") === 0) con.connect(this.host + "/.s.PGSQL." + this.port);
+				else con.connect(this.port, this.host);
+				con.on("connect", function() {
+					con.cancel(client.processID, client.secretKey);
+				});
+			} else if (client._queryQueue.indexOf(query) !== -1) client._queryQueue.splice(client._queryQueue.indexOf(query), 1);
+		}
+		setTypeParser(oid, format, parseFn) {
+			return this._types.setTypeParser(oid, format, parseFn);
+		}
+		getTypeParser(oid, format) {
+			return this._types.getTypeParser(oid, format);
+		}
+		escapeIdentifier(str) {
+			return utils.escapeIdentifier(str);
+		}
+		escapeLiteral(str) {
+			return utils.escapeLiteral(str);
+		}
+		_pulseQueryQueue() {
+			if (this.readyForQuery === true) {
+				this._activeQuery = this._queryQueue.shift();
+				const activeQuery = this._getActiveQuery();
+				if (activeQuery) {
+					this.readyForQuery = false;
+					this.hasExecuted = true;
+					const queryError = activeQuery.submit(this.connection);
+					if (queryError) process.nextTick(() => {
+						activeQuery.handleError(queryError, this.connection);
+						this.readyForQuery = true;
+						this._pulseQueryQueue();
+					});
+				} else if (this.hasExecuted) {
+					this._activeQuery = null;
+					this.emit("drain");
+				}
+			}
+		}
+		query(config, values, callback) {
+			let query;
+			let result;
+			let readTimeout;
+			let readTimeoutTimer;
+			let queryCallback;
+			if (config === null || config === void 0) throw new TypeError("Client was passed a null or undefined query");
+			else if (typeof config.submit === "function") {
+				readTimeout = config.query_timeout || this.connectionParameters.query_timeout;
+				result = query = config;
+				if (typeof values === "function") query.callback = query.callback || values;
+			} else {
+				readTimeout = config.query_timeout || this.connectionParameters.query_timeout;
+				query = new Query(config, values, callback);
+				if (!query.callback) result = new this._Promise((resolve, reject) => {
+					query.callback = (err, res) => err ? reject(err) : resolve(res);
+				}).catch((err) => {
+					Error.captureStackTrace(err);
+					throw err;
+				});
+			}
+			if (readTimeout) {
+				queryCallback = query.callback;
+				readTimeoutTimer = setTimeout(() => {
+					const error = /* @__PURE__ */ new Error("Query read timeout");
+					process.nextTick(() => {
+						query.handleError(error, this.connection);
+					});
+					queryCallback(error);
+					query.callback = () => {};
+					const index = this._queryQueue.indexOf(query);
+					if (index > -1) this._queryQueue.splice(index, 1);
+					this._pulseQueryQueue();
+				}, readTimeout);
+				query.callback = (err, res) => {
+					clearTimeout(readTimeoutTimer);
+					queryCallback(err, res);
+				};
+			}
+			if (this.binary && !query.binary) query.binary = true;
+			if (query._result && !query._result._types) query._result._types = this._types;
+			if (!this._queryable) {
+				process.nextTick(() => {
+					query.handleError(/* @__PURE__ */ new Error("Client has encountered a connection error and is not queryable"), this.connection);
+				});
+				return result;
+			}
+			if (this._ending) {
+				process.nextTick(() => {
+					query.handleError(/* @__PURE__ */ new Error("Client was closed and is not queryable"), this.connection);
+				});
+				return result;
+			}
+			this._queryQueue.push(query);
+			this._pulseQueryQueue();
+			return result;
+		}
+		ref() {
+			this.connection.ref();
+		}
+		unref() {
+			this.connection.unref();
+		}
+		end(cb) {
+			this._ending = true;
+			if (!this.connection._connecting || this._ended) if (cb) cb();
+			else return this._Promise.resolve();
+			if (this._getActiveQuery() || !this._queryable) this.connection.stream.destroy();
+			else this.connection.end();
+			if (cb) this.connection.once("end", cb);
+			else return new this._Promise((resolve) => {
+				this.connection.once("end", resolve);
+			});
+		}
+		get queryQueue() {
+			queryQueueDeprecationNotice();
+			return this._queryQueue;
+		}
+	};
+	Client.Query = Query;
+	module.exports = Client;
+}) });
+
+//#endregion
+export default require_client();
+
+export { require_client };
+//# sourceMappingURL=client.js.map