orange-orm
Version:
Object Relational Mapper
5,915 lines • 207 kB
JavaScript
import { n as __toESM, t as __commonJSMin } from "./orange-orm.js";
import { t as require_browser_external_fs } from "./browser-external_fs-BjtkIK-z.js";
import { t as require_browser_external_path } from "./browser-external_path-Cd67fXdO.js";
import { t as require_browser_external_util } from "./browser-external_util-VL2wKZYX.js";
import { t as require_browser_external_stream } from "./browser-external_stream-BvvXfaxo.js";
//#region ../../node_modules/events/events.js
var require_events = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var R = typeof Reflect === "object" ? Reflect : null;
var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply(target, receiver, args) {
return Function.prototype.apply.call(target, receiver, args);
};
var ReflectOwnKeys;
if (R && typeof R.ownKeys === "function") ReflectOwnKeys = R.ownKeys;
else if (Object.getOwnPropertySymbols) ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
};
else ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target);
};
function ProcessEmitWarning(warning) {
if (console && console.warn) console.warn(warning);
}
var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
return value !== value;
};
function EventEmitter() {
EventEmitter.init.call(this);
}
module.exports = EventEmitter;
module.exports.once = once;
EventEmitter.EventEmitter = EventEmitter;
EventEmitter.prototype._events = void 0;
EventEmitter.prototype._eventsCount = 0;
EventEmitter.prototype._maxListeners = void 0;
var defaultMaxListeners = 10;
function checkListener(listener) {
if (typeof listener !== "function") throw new TypeError("The \"listener\" argument must be of type Function. Received type " + typeof listener);
}
Object.defineProperty(EventEmitter, "defaultMaxListeners", {
enumerable: true,
get: function() {
return defaultMaxListeners;
},
set: function(arg) {
if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) throw new RangeError("The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received " + arg + ".");
defaultMaxListeners = arg;
}
});
EventEmitter.init = function() {
if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
this._events = Object.create(null);
this._eventsCount = 0;
}
this._maxListeners = this._maxListeners || void 0;
};
EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) throw new RangeError("The value of \"n\" is out of range. It must be a non-negative number. Received " + n + ".");
this._maxListeners = n;
return this;
};
function _getMaxListeners(that) {
if (that._maxListeners === void 0) return EventEmitter.defaultMaxListeners;
return that._maxListeners;
}
EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
return _getMaxListeners(this);
};
EventEmitter.prototype.emit = function emit(type) {
var args = [];
for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
var doError = type === "error";
var events = this._events;
if (events !== void 0) doError = doError && events.error === void 0;
else if (!doError) return false;
if (doError) {
var er;
if (args.length > 0) er = args[0];
if (er instanceof Error) throw er;
var err = /* @__PURE__ */ new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
err.context = er;
throw err;
}
var handler = events[type];
if (handler === void 0) return false;
if (typeof handler === "function") ReflectApply(handler, this, args);
else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i) ReflectApply(listeners[i], this, args);
}
return true;
};
function _addListener(target, type, listener, prepend) {
var m;
var events;
var existing;
checkListener(listener);
events = target._events;
if (events === void 0) {
events = target._events = Object.create(null);
target._eventsCount = 0;
} else {
if (events.newListener !== void 0) {
target.emit("newListener", type, listener.listener ? listener.listener : listener);
events = target._events;
}
existing = events[type];
}
if (existing === void 0) {
existing = events[type] = listener;
++target._eventsCount;
} else {
if (typeof existing === "function") existing = events[type] = prepend ? [listener, existing] : [existing, listener];
else if (prepend) existing.unshift(listener);
else existing.push(listener);
m = _getMaxListeners(target);
if (m > 0 && existing.length > m && !existing.warned) {
existing.warned = true;
var w = /* @__PURE__ */ new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
w.name = "MaxListenersExceededWarning";
w.emitter = target;
w.type = type;
w.count = existing.length;
ProcessEmitWarning(w);
}
}
return target;
}
EventEmitter.prototype.addListener = function addListener(type, listener) {
return _addListener(this, type, listener, false);
};
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
EventEmitter.prototype.prependListener = function prependListener(type, listener) {
return _addListener(this, type, listener, true);
};
function onceWrapper() {
if (!this.fired) {
this.target.removeListener(this.type, this.wrapFn);
this.fired = true;
if (arguments.length === 0) return this.listener.call(this.target);
return this.listener.apply(this.target, arguments);
}
}
function _onceWrap(target, type, listener) {
var state = {
fired: false,
wrapFn: void 0,
target,
type,
listener
};
var wrapped = onceWrapper.bind(state);
wrapped.listener = listener;
state.wrapFn = wrapped;
return wrapped;
}
EventEmitter.prototype.once = function once(type, listener) {
checkListener(listener);
this.on(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
checkListener(listener);
this.prependListener(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter.prototype.removeListener = function removeListener(type, listener) {
var list, events, position, i, originalListener;
checkListener(listener);
events = this._events;
if (events === void 0) return this;
list = events[type];
if (list === void 0) return this;
if (list === listener || list.listener === listener) if (--this._eventsCount === 0) this._events = Object.create(null);
else {
delete events[type];
if (events.removeListener) this.emit("removeListener", type, list.listener || listener);
}
else if (typeof list !== "function") {
position = -1;
for (i = list.length - 1; i >= 0; i--) if (list[i] === listener || list[i].listener === listener) {
originalListener = list[i].listener;
position = i;
break;
}
if (position < 0) return this;
if (position === 0) list.shift();
else spliceOne(list, position);
if (list.length === 1) events[type] = list[0];
if (events.removeListener !== void 0) this.emit("removeListener", type, originalListener || listener);
}
return this;
};
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
var listeners, events = this._events, i;
if (events === void 0) return this;
if (events.removeListener === void 0) {
if (arguments.length === 0) {
this._events = Object.create(null);
this._eventsCount = 0;
} else if (events[type] !== void 0) if (--this._eventsCount === 0) this._events = Object.create(null);
else delete events[type];
return this;
}
if (arguments.length === 0) {
var keys = Object.keys(events);
var key;
for (i = 0; i < keys.length; ++i) {
key = keys[i];
if (key === "removeListener") continue;
this.removeAllListeners(key);
}
this.removeAllListeners("removeListener");
this._events = Object.create(null);
this._eventsCount = 0;
return this;
}
listeners = events[type];
if (typeof listeners === "function") this.removeListener(type, listeners);
else if (listeners !== void 0) for (i = listeners.length - 1; i >= 0; i--) this.removeListener(type, listeners[i]);
return this;
};
function _listeners(target, type, unwrap) {
var events = target._events;
if (events === void 0) return [];
var evlistener = events[type];
if (evlistener === void 0) return [];
if (typeof evlistener === "function") return unwrap ? [evlistener.listener || evlistener] : [evlistener];
return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
}
EventEmitter.prototype.listeners = function listeners(type) {
return _listeners(this, type, true);
};
EventEmitter.prototype.rawListeners = function rawListeners(type) {
return _listeners(this, type, false);
};
EventEmitter.listenerCount = function(emitter, type) {
if (typeof emitter.listenerCount === "function") return emitter.listenerCount(type);
else return listenerCount.call(emitter, type);
};
EventEmitter.prototype.listenerCount = listenerCount;
function listenerCount(type) {
var events = this._events;
if (events !== void 0) {
var evlistener = events[type];
if (typeof evlistener === "function") return 1;
else if (evlistener !== void 0) return evlistener.length;
}
return 0;
}
EventEmitter.prototype.eventNames = function eventNames() {
return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
};
function arrayClone(arr, n) {
var copy = new Array(n);
for (var i = 0; i < n; ++i) copy[i] = arr[i];
return copy;
}
function spliceOne(list, index) {
for (; index + 1 < list.length; index++) list[index] = list[index + 1];
list.pop();
}
function unwrapListeners(arr) {
var ret = new Array(arr.length);
for (var i = 0; i < ret.length; ++i) ret[i] = arr[i].listener || arr[i];
return ret;
}
function once(emitter, name) {
return new Promise(function(resolve, reject) {
function errorListener(err) {
emitter.removeListener(name, resolver);
reject(err);
}
function resolver() {
if (typeof emitter.removeListener === "function") emitter.removeListener("error", errorListener);
resolve([].slice.call(arguments));
}
eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
if (name !== "error") addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
});
}
function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
if (typeof emitter.on === "function") eventTargetAgnosticAddListener(emitter, "error", handler, flags);
}
function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
if (typeof emitter.on === "function") if (flags.once) emitter.once(name, listener);
else emitter.on(name, listener);
else if (typeof emitter.addEventListener === "function") emitter.addEventListener(name, function wrapListener(arg) {
if (flags.once) emitter.removeEventListener(name, wrapListener);
listener(arg);
});
else throw new TypeError("The \"emitter\" argument must be of type EventEmitter. Received type " + typeof emitter);
}
}));
//#endregion
//#region ../../node_modules/postgres-array/index.js
var require_postgres_array = /* @__PURE__ */ __commonJSMin(((exports) => {
exports.parse = function(source, transform) {
return new ArrayParser(source, transform).parse();
};
var ArrayParser = class ArrayParser {
constructor(source, transform) {
this.source = source;
this.transform = transform || identity;
this.position = 0;
this.entries = [];
this.recorded = [];
this.dimension = 0;
}
isEof() {
return this.position >= this.source.length;
}
nextCharacter() {
var character = this.source[this.position++];
if (character === "\\") return {
value: this.source[this.position++],
escaped: true
};
return {
value: character,
escaped: false
};
}
record(character) {
this.recorded.push(character);
}
newEntry(includeEmpty) {
var entry;
if (this.recorded.length > 0 || includeEmpty) {
entry = this.recorded.join("");
if (entry === "NULL" && !includeEmpty) entry = null;
if (entry !== null) entry = this.transform(entry);
this.entries.push(entry);
this.recorded = [];
}
}
consumeDimensions() {
if (this.source[0] === "[") {
while (!this.isEof()) if (this.nextCharacter().value === "=") break;
}
}
parse(nested) {
var character, parser, quote;
this.consumeDimensions();
while (!this.isEof()) {
character = this.nextCharacter();
if (character.value === "{" && !quote) {
this.dimension++;
if (this.dimension > 1) {
parser = new ArrayParser(this.source.substr(this.position - 1), this.transform);
this.entries.push(parser.parse(true));
this.position += parser.position - 2;
}
} else if (character.value === "}" && !quote) {
this.dimension--;
if (!this.dimension) {
this.newEntry();
if (nested) return this.entries;
}
} else if (character.value === "\"" && !character.escaped) {
if (quote) this.newEntry(true);
quote = !quote;
} else if (character.value === "," && !quote) this.newEntry();
else this.record(character.value);
}
if (this.dimension !== 0) throw new Error("array dimension not balanced");
return this.entries;
}
};
function identity(value) {
return value;
}
}));
//#endregion
//#region ../../node_modules/pg-types/lib/arrayParser.js
var require_arrayParser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var array = require_postgres_array();
module.exports = { create: function(source, transform) {
return { parse: function() {
return array.parse(source, transform);
} };
} };
}));
//#endregion
//#region ../../node_modules/postgres-date/index.js
var require_postgres_date = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var DATE_TIME = /(\d{1,})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(\.\d{1,})?.*?( BC)?$/;
var DATE = /^(\d{1,})-(\d{2})-(\d{2})( BC)?$/;
var TIME_ZONE = /([Z+-])(\d{2})?:?(\d{2})?:?(\d{2})?/;
var INFINITY = /^-?infinity$/;
module.exports = function parseDate(isoDate) {
if (INFINITY.test(isoDate)) return Number(isoDate.replace("i", "I"));
var matches = DATE_TIME.exec(isoDate);
if (!matches) return getDate(isoDate) || null;
var isBC = !!matches[8];
var year = parseInt(matches[1], 10);
if (isBC) year = bcYearToNegativeYear(year);
var month = parseInt(matches[2], 10) - 1;
var day = matches[3];
var hour = parseInt(matches[4], 10);
var minute = parseInt(matches[5], 10);
var second = parseInt(matches[6], 10);
var ms = matches[7];
ms = ms ? 1e3 * parseFloat(ms) : 0;
var date;
var offset = timeZoneOffset(isoDate);
if (offset != null) {
date = new Date(Date.UTC(year, month, day, hour, minute, second, ms));
if (is0To99(year)) date.setUTCFullYear(year);
if (offset !== 0) date.setTime(date.getTime() - offset);
} else {
date = new Date(year, month, day, hour, minute, second, ms);
if (is0To99(year)) date.setFullYear(year);
}
return date;
};
function getDate(isoDate) {
var matches = DATE.exec(isoDate);
if (!matches) return;
var year = parseInt(matches[1], 10);
if (!!matches[4]) year = bcYearToNegativeYear(year);
var month = parseInt(matches[2], 10) - 1;
var day = matches[3];
var date = new Date(year, month, day);
if (is0To99(year)) date.setFullYear(year);
return date;
}
function timeZoneOffset(isoDate) {
if (isoDate.endsWith("+00")) return 0;
var zone = TIME_ZONE.exec(isoDate.split(" ")[1]);
if (!zone) return;
var type = zone[1];
if (type === "Z") return 0;
var sign = type === "-" ? -1 : 1;
return (parseInt(zone[2], 10) * 3600 + parseInt(zone[3] || 0, 10) * 60 + parseInt(zone[4] || 0, 10)) * sign * 1e3;
}
function bcYearToNegativeYear(year) {
return -(year - 1);
}
function is0To99(num) {
return num >= 0 && num < 100;
}
}));
//#endregion
//#region ../../node_modules/xtend/mutable.js
var require_mutable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = extend;
var hasOwnProperty = Object.prototype.hasOwnProperty;
function extend(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) if (hasOwnProperty.call(source, key)) target[key] = source[key];
}
return target;
}
}));
//#endregion
//#region ../../node_modules/postgres-interval/index.js
var require_postgres_interval = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var extend = require_mutable();
module.exports = PostgresInterval;
function PostgresInterval(raw) {
if (!(this instanceof PostgresInterval)) return new PostgresInterval(raw);
extend(this, parse(raw));
}
var properties = [
"seconds",
"minutes",
"hours",
"days",
"months",
"years"
];
PostgresInterval.prototype.toPostgres = function() {
var filtered = properties.filter(this.hasOwnProperty, this);
if (this.milliseconds && filtered.indexOf("seconds") < 0) filtered.push("seconds");
if (filtered.length === 0) return "0";
return filtered.map(function(property) {
var value = this[property] || 0;
if (property === "seconds" && this.milliseconds) value = (value + this.milliseconds / 1e3).toFixed(6).replace(/\.?0+$/, "");
return value + " " + property;
}, this).join(" ");
};
var propertiesISOEquivalent = {
years: "Y",
months: "M",
days: "D",
hours: "H",
minutes: "M",
seconds: "S"
};
var dateProperties = [
"years",
"months",
"days"
];
var timeProperties = [
"hours",
"minutes",
"seconds"
];
PostgresInterval.prototype.toISOString = PostgresInterval.prototype.toISO = function() {
var datePart = dateProperties.map(buildProperty, this).join("");
var timePart = timeProperties.map(buildProperty, this).join("");
return "P" + datePart + "T" + timePart;
function buildProperty(property) {
var value = this[property] || 0;
if (property === "seconds" && this.milliseconds) value = (value + this.milliseconds / 1e3).toFixed(6).replace(/0+$/, "");
return value + propertiesISOEquivalent[property];
}
};
var NUMBER = "([+-]?\\d+)";
var YEAR = NUMBER + "\\s+years?";
var MONTH = NUMBER + "\\s+mons?";
var DAY = NUMBER + "\\s+days?";
var INTERVAL = new RegExp([
YEAR,
MONTH,
DAY,
"([+-])?([\\d]*):(\\d\\d):(\\d\\d)\\.?(\\d{1,6})?"
].map(function(regexString) {
return "(" + regexString + ")?";
}).join("\\s*"));
var positions = {
years: 2,
months: 4,
days: 6,
hours: 9,
minutes: 10,
seconds: 11,
milliseconds: 12
};
var negatives = [
"hours",
"minutes",
"seconds",
"milliseconds"
];
function parseMilliseconds(fraction) {
var microseconds = fraction + "000000".slice(fraction.length);
return parseInt(microseconds, 10) / 1e3;
}
function parse(interval) {
if (!interval) return {};
var matches = INTERVAL.exec(interval);
var isNegative = matches[8] === "-";
return Object.keys(positions).reduce(function(parsed, property) {
var value = matches[positions[property]];
if (!value) return parsed;
value = property === "milliseconds" ? parseMilliseconds(value) : parseInt(value, 10);
if (!value) return parsed;
if (isNegative && ~negatives.indexOf(property)) value *= -1;
parsed[property] = value;
return parsed;
}, {});
}
}));
//#endregion
//#region ../../node_modules/postgres-bytea/index.js
var require_postgres_bytea = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = function parseBytea(input) {
if (/^\\x/.test(input)) return new Buffer(input.substr(2), "hex");
var output = "";
var i = 0;
while (i < input.length) if (input[i] !== "\\") {
output += input[i];
++i;
} else if (/[0-7]{3}/.test(input.substr(i + 1, 3))) {
output += String.fromCharCode(parseInt(input.substr(i + 1, 3), 8));
i += 4;
} else {
var backslashes = 1;
while (i + backslashes < input.length && input[i + backslashes] === "\\") backslashes++;
for (var k = 0; k < Math.floor(backslashes / 2); ++k) output += "\\";
i += Math.floor(backslashes / 2) * 2;
}
return new Buffer(output, "binary");
};
}));
//#endregion
//#region ../../node_modules/pg-types/lib/textParsers.js
var require_textParsers = /* @__PURE__ */ __commonJSMin(((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
//#region ../../node_modules/pg-int8/index.js
var require_pg_int8 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var BASE = 1e6;
function readInt8(buffer) {
var high = buffer.readInt32BE(0);
var low = buffer.readUInt32BE(4);
var sign = "";
if (high < 0) {
high = ~high + (low === 0);
low = ~low + 1 >>> 0;
sign = "-";
}
var result = "";
var carry;
var t;
var digits;
var pad;
var l;
var i;
carry = high % BASE;
high = high / BASE >>> 0;
t = 4294967296 * carry + low;
low = t / BASE >>> 0;
digits = "" + (t - BASE * low);
if (low === 0 && high === 0) return sign + digits + result;
pad = "";
l = 6 - digits.length;
for (i = 0; i < l; i++) pad += "0";
result = pad + digits + result;
carry = high % BASE;
high = high / BASE >>> 0;
t = 4294967296 * carry + low;
low = t / BASE >>> 0;
digits = "" + (t - BASE * low);
if (low === 0 && high === 0) return sign + digits + result;
pad = "";
l = 6 - digits.length;
for (i = 0; i < l; i++) pad += "0";
result = pad + digits + result;
carry = high % BASE;
high = high / BASE >>> 0;
t = 4294967296 * carry + low;
low = t / BASE >>> 0;
digits = "" + (t - BASE * low);
if (low === 0 && high === 0) return sign + digits + result;
pad = "";
l = 6 - digits.length;
for (i = 0; i < l; i++) pad += "0";
result = pad + digits + result;
carry = high % BASE;
t = 4294967296 * carry + low;
digits = "" + t % BASE;
return sign + digits + result;
}
module.exports = readInt8;
}));
//#endregion
//#region ../../node_modules/pg-types/lib/binaryParsers.js
var require_binaryParsers = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var parseInt64 = require_pg_int8();
var parseBits = function(data, bits, offset, invert, callback) {
offset = offset || 0;
invert = invert || false;
callback = callback || function(lastValue, newValue, bits) {
return lastValue * Math.pow(2, bits) + newValue;
};
var offsetBytes = offset >> 3;
var inv = function(value) {
if (invert) return ~value & 255;
return value;
};
var mask = 255;
var firstBits = 8 - offset % 8;
if (bits < firstBits) {
mask = 255 << 8 - bits & 255;
firstBits = bits;
}
if (offset) mask = mask >> offset % 8;
var result = 0;
if (offset % 8 + bits >= 8) result = callback(0, inv(data[offsetBytes]) & mask, firstBits);
var bytes = bits + offset >> 3;
for (var i = offsetBytes + 1; i < bytes; i++) result = callback(result, inv(data[i]), 8);
var lastBits = (bits + offset) % 8;
if (lastBits > 0) result = callback(result, inv(data[bytes]) >> 8 - lastBits, lastBits);
return result;
};
var parseFloatFromBits = function(data, precisionBits, exponentBits) {
var bias = Math.pow(2, exponentBits - 1) - 1;
var sign = parseBits(data, 1);
var exponent = parseBits(data, exponentBits, 1);
if (exponent === 0) return 0;
var precisionBitsCounter = 1;
var parsePrecisionBits = function(lastValue, newValue, bits) {
if (lastValue === 0) lastValue = 1;
for (var i = 1; i <= bits; i++) {
precisionBitsCounter /= 2;
if ((newValue & 1 << bits - i) > 0) lastValue += precisionBitsCounter;
}
return lastValue;
};
var mantissa = parseBits(data, precisionBits, exponentBits + 1, false, parsePrecisionBits);
if (exponent == Math.pow(2, exponentBits + 1) - 1) {
if (mantissa === 0) return sign === 0 ? Infinity : -Infinity;
return NaN;
}
return (sign === 0 ? 1 : -1) * Math.pow(2, exponent - bias) * mantissa;
};
var parseInt16 = function(value) {
if (parseBits(value, 1) == 1) return -1 * (parseBits(value, 15, 1, true) + 1);
return parseBits(value, 15, 1);
};
var parseInt32 = function(value) {
if (parseBits(value, 1) == 1) return -1 * (parseBits(value, 31, 1, true) + 1);
return parseBits(value, 31, 1);
};
var parseFloat32 = function(value) {
return parseFloatFromBits(value, 23, 8);
};
var parseFloat64 = function(value) {
return parseFloatFromBits(value, 52, 11);
};
var parseNumeric = function(value) {
var sign = parseBits(value, 16, 32);
if (sign == 49152) return NaN;
var weight = Math.pow(1e4, parseBits(value, 16, 16));
var result = 0;
var ndigits = parseBits(value, 16);
for (var i = 0; i < ndigits; i++) {
result += parseBits(value, 16, 64 + 16 * i) * weight;
weight /= 1e4;
}
var scale = Math.pow(10, parseBits(value, 16, 48));
return (sign === 0 ? 1 : -1) * Math.round(result * scale) / scale;
};
var parseDate = function(isUTC, value) {
var sign = parseBits(value, 1);
var rawValue = parseBits(value, 63, 1);
var result = /* @__PURE__ */ new Date((sign === 0 ? 1 : -1) * rawValue / 1e3 + 9466848e5);
if (!isUTC) result.setTime(result.getTime() + result.getTimezoneOffset() * 6e4);
result.usec = rawValue % 1e3;
result.getMicroSeconds = function() {
return this.usec;
};
result.setMicroSeconds = function(value) {
this.usec = value;
};
result.getUTCMicroSeconds = function() {
return this.usec;
};
return result;
};
var parseArray = function(value) {
var dim = parseBits(value, 32);
parseBits(value, 32, 32);
var elementType = parseBits(value, 32, 64);
var offset = 96;
var dims = [];
for (var i = 0; i < dim; i++) {
dims[i] = parseBits(value, 32, offset);
offset += 32;
offset += 32;
}
var parseElement = function(elementType) {
var length = parseBits(value, 32, offset);
offset += 32;
if (length == 4294967295) return null;
var result;
if (elementType == 23 || elementType == 20) {
result = parseBits(value, length * 8, offset);
offset += length * 8;
return result;
} else if (elementType == 25) {
result = value.toString(this.encoding, offset >> 3, (offset += length << 3) >> 3);
return result;
} else console.log("ERROR: ElementType not implemented: " + elementType);
};
var parse = function(dimension, elementType) {
var array = [];
var i;
if (dimension.length > 1) {
var count = dimension.shift();
for (i = 0; i < count; i++) array[i] = parse(dimension, elementType);
dimension.unshift(count);
} else for (i = 0; i < dimension[0]; i++) array[i] = parseElement(elementType);
return array;
};
return parse(dims, elementType);
};
var parseText = function(value) {
return value.toString("utf8");
};
var parseBool = function(value) {
if (value === null) return null;
return parseBits(value, 8) > 0;
};
var init = function(register) {
register(20, parseInt64);
register(21, parseInt16);
register(23, parseInt32);
register(26, parseInt32);
register(1700, parseNumeric);
register(700, parseFloat32);
register(701, parseFloat64);
register(16, parseBool);
register(1114, parseDate.bind(null, false));
register(1184, parseDate.bind(null, true));
register(1e3, parseArray);
register(1007, parseArray);
register(1016, parseArray);
register(1008, parseArray);
register(1009, parseArray);
register(25, parseText);
};
module.exports = { init };
}));
//#endregion
//#region ../../node_modules/pg-types/lib/builtins.js
var require_builtins = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/**
* Following query was used to generate this file:
SELECT json_object_agg(UPPER(PT.typname), PT.oid::int4 ORDER BY pt.oid)
FROM pg_type PT
WHERE typnamespace = (SELECT pgn.oid FROM pg_namespace pgn WHERE nspname = 'pg_catalog') -- Take only builting Postgres types with stable OID (extension types are not guaranted to be stable)
AND typtype = 'b' -- Only basic types
AND typelem = 0 -- Ignore aliases
AND typisdefined -- Ignore undefined types
*/
module.exports = {
BOOL: 16,
BYTEA: 17,
CHAR: 18,
INT8: 20,
INT2: 21,
INT4: 23,
REGPROC: 24,
TEXT: 25,
OID: 26,
TID: 27,
XID: 28,
CID: 29,
JSON: 114,
XML: 142,
PG_NODE_TREE: 194,
SMGR: 210,
PATH: 602,
POLYGON: 604,
CIDR: 650,
FLOAT4: 700,
FLOAT8: 701,
ABSTIME: 702,
RELTIME: 703,
TINTERVAL: 704,
CIRCLE: 718,
MACADDR8: 774,
MONEY: 790,
MACADDR: 829,
INET: 869,
ACLITEM: 1033,
BPCHAR: 1042,
VARCHAR: 1043,
DATE: 1082,
TIME: 1083,
TIMESTAMP: 1114,
TIMESTAMPTZ: 1184,
INTERVAL: 1186,
TIMETZ: 1266,
BIT: 1560,
VARBIT: 1562,
NUMERIC: 1700,
REFCURSOR: 1790,
REGPROCEDURE: 2202,
REGOPER: 2203,
REGOPERATOR: 2204,
REGCLASS: 2205,
REGTYPE: 2206,
UUID: 2950,
TXID_SNAPSHOT: 2970,
PG_LSN: 3220,
PG_NDISTINCT: 3361,
PG_DEPENDENCIES: 3402,
TSVECTOR: 3614,
TSQUERY: 3615,
GTSVECTOR: 3642,
REGCONFIG: 3734,
REGDICTIONARY: 3769,
JSONB: 3802,
REGNAMESPACE: 4089,
REGROLE: 4096
};
}));
//#endregion
//#region ../../node_modules/pg-types/index.js
var require_pg_types = /* @__PURE__ */ __commonJSMin(((exports) => {
var textParsers = require_textParsers();
var binaryParsers = require_binaryParsers();
var arrayParser = require_arrayParser();
var builtinTypes = require_builtins();
exports.getTypeParser = getTypeParser;
exports.setTypeParser = setTypeParser;
exports.arrayParser = arrayParser;
exports.builtins = builtinTypes;
var typeParsers = {
text: {},
binary: {}
};
function noParse(val) {
return String(val);
}
function getTypeParser(oid, format) {
format = format || "text";
if (!typeParsers[format]) return noParse;
return typeParsers[format][oid] || noParse;
}
function setTypeParser(oid, format, parseFn) {
if (typeof format == "function") {
parseFn = format;
format = "text";
}
typeParsers[format][oid] = parseFn;
}
textParsers.init(function(oid, converter) {
typeParsers.text[oid] = converter;
});
binaryParsers.init(function(oid, converter) {
typeParsers.binary[oid] = converter;
});
}));
//#endregion
//#region ../../node_modules/pg/lib/defaults.js
var require_defaults = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = {
host: "localhost",
user: process.platform === "win32" ? process.env.USERNAME : process.env.USER,
database: void 0,
password: null,
connectionString: void 0,
port: 5432,
rows: 0,
binary: false,
max: 10,
idleTimeoutMillis: 3e4,
client_encoding: "",
ssl: false,
application_name: void 0,
fallback_application_name: void 0,
options: void 0,
parseInputDatesAsUTC: false,
statement_timeout: false,
lock_timeout: false,
idle_in_transaction_session_timeout: false,
query_timeout: false,
connect_timeout: 0,
keepalives: 1,
keepalives_idle: 0
};
var pgTypes = require_pg_types();
var parseBigInteger = pgTypes.getTypeParser(20, "text");
var parseBigIntegerArray = pgTypes.getTypeParser(1016, "text");
module.exports.__defineSetter__("parseInt8", function(val) {
pgTypes.setTypeParser(20, "text", val ? pgTypes.getTypeParser(23, "text") : parseBigInteger);
pgTypes.setTypeParser(1016, "text", val ? pgTypes.getTypeParser(1007, "text") : parseBigIntegerArray);
});
}));
//#endregion
//#region ../../node_modules/pg/lib/utils.js
var require_utils$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var defaults = require_defaults();
var util = require_browser_external_util();
var { isDate } = util.types || util;
function escapeElement(elementRepresentation) {
return "\"" + elementRepresentation.replace(/\\/g, "\\\\").replace(/"/g, "\\\"") + "\"";
}
function arrayString(val) {
let result = "{";
for (let i = 0; i < val.length; i++) {
if (i > 0) result = result + ",";
if (val[i] === null || typeof val[i] === "undefined") result = result + "NULL";
else if (Array.isArray(val[i])) result = result + arrayString(val[i]);
else if (ArrayBuffer.isView(val[i])) {
let item = val[i];
if (!(item instanceof Buffer)) {
const buf = Buffer.from(item.buffer, item.byteOffset, item.byteLength);
if (buf.length === item.byteLength) item = buf;
else item = buf.slice(item.byteOffset, item.byteOffset + item.byteLength);
}
result += "\\\\x" + item.toString("hex");
} else result += escapeElement(prepareValue(val[i]));
}
result = result + "}";
return result;
}
var prepareValue = function(val, seen) {
if (val == null) return null;
if (typeof val === "object") {
if (val instanceof Buffer) return val;
if (ArrayBuffer.isView(val)) {
const buf = Buffer.from(val.buffer, val.byteOffset, val.byteLength);
if (buf.length === val.byteLength) return buf;
return buf.slice(val.byteOffset, val.byteOffset + val.byteLength);
}
if (isDate(val)) if (defaults.parseInputDatesAsUTC) return dateToStringUTC(val);
else return dateToString(val);
if (Array.isArray(val)) return arrayString(val);
return prepareObject(val, seen);
}
return val.toString();
};
function prepareObject(val, seen) {
if (val && typeof val.toPostgres === "function") {
seen = seen || [];
if (seen.indexOf(val) !== -1) throw new Error("circular reference detected while preparing \"" + val + "\" for query");
seen.push(val);
return prepareValue(val.toPostgres(prepareValue), seen);
}
return JSON.stringify(val);
}
function dateToString(date) {
let offset = -date.getTimezoneOffset();
let year = date.getFullYear();
const isBCYear = year < 1;
if (isBCYear) year = Math.abs(year) + 1;
let ret = String(year).padStart(4, "0") + "-" + String(date.getMonth() + 1).padStart(2, "0") + "-" + String(date.getDate()).padStart(2, "0") + "T" + String(date.getHours()).padStart(2, "0") + ":" + String(date.getMinutes()).padStart(2, "0") + ":" + String(date.getSeconds()).padStart(2, "0") + "." + String(date.getMilliseconds()).padStart(3, "0");
if (offset < 0) {
ret += "-";
offset *= -1;
} else ret += "+";
ret += String(Math.floor(offset / 60)).padStart(2, "0") + ":" + String(offset % 60).padStart(2, "0");
if (isBCYear) ret += " BC";
return ret;
}
function dateToStringUTC(date) {
let year = date.getUTCFullYear();
const isBCYear = year < 1;
if (isBCYear) year = Math.abs(year) + 1;
let ret = String(year).padStart(4, "0") + "-" + String(date.getUTCMonth() + 1).padStart(2, "0") + "-" + String(date.getUTCDate()).padStart(2, "0") + "T" + String(date.getUTCHours()).padStart(2, "0") + ":" + String(date.getUTCMinutes()).padStart(2, "0") + ":" + String(date.getUTCSeconds()).padStart(2, "0") + "." + String(date.getUTCMilliseconds()).padStart(3, "0");
ret += "+00:00";
if (isBCYear) ret += " BC";
return ret;
}
function normalizeQueryConfig(config, values, callback) {
config = typeof config === "string" ? { text: config } : config;
if (values) if (typeof values === "function") config.callback = values;
else config.values = values;
if (callback) config.callback = callback;
return config;
}
var escapeIdentifier = function(str) {
return "\"" + str.replace(/"/g, "\"\"") + "\"";
};
var escapeLiteral = function(str) {
let hasBackslash = false;
let escaped = "'";
if (str == null) return "''";
if (typeof str !== "string") return "''";
for (let i = 0; i < str.length; i++) {
const c = str[i];
if (c === "'") escaped += c + c;
else if (c === "\\") {
escaped += c + c;
hasBackslash = true;
} else escaped += c;
}
escaped += "'";
if (hasBackslash === true) escaped = " E" + escaped;
return escaped;
};
module.exports = {
prepareValue: function prepareValueWrapper(value) {
return prepareValue(value);
},
normalizeQueryConfig,
escapeIdentifier,
escapeLiteral
};
}));
//#endregion
//#region browser-external:crypto
var require_browser_external_crypto = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = Object.create(new Proxy({}, { get(_, key) {
if (key !== "__esModule" && key !== "__proto__" && key !== "constructor" && key !== "splice") console.warn(`Module "crypto" has been externalized for browser compatibility. Cannot access "crypto.${key}" in client code. See https://vite.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.`);
} }));
}));
//#endregion
//#region ../../node_modules/pg/lib/crypto/utils-legacy.js
var require_utils_legacy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var nodeCrypto = require_browser_external_crypto();
function md5(string) {
return nodeCrypto.createHash("md5").update(string, "utf-8").digest("hex");
}
function postgresMd5PasswordHash(user, password, salt) {
const inner = md5(password + user);
return "md5" + md5(Buffer.concat([Buffer.from(inner), salt]));
}
function sha256(text) {
return nodeCrypto.createHash("sha256").update(text).digest();
}
function hashByName(hashName, text) {
hashName = hashName.replace(/(\D)-/, "$1");
return nodeCrypto.createHash(hashName).update(text).digest();
}
function hmacSha256(key, msg) {
return nodeCrypto.createHmac("sha256", key).update(msg).digest();
}
async function deriveKey(password, salt, iterations) {
return nodeCrypto.pbkdf2Sync(password, salt, iterations, 32, "sha256");
}
module.exports = {
postgresMd5PasswordHash,
randomBytes: nodeCrypto.randomBytes,
deriveKey,
sha256,
hashByName,
hmacSha256,
md5
};
}));
//#endregion
//#region ../../node_modules/pg/lib/crypto/utils-webcrypto.js
var require_utils_webcrypto = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var nodeCrypto = require_browser_external_crypto();
module.exports = {
postgresMd5PasswordHash,
randomBytes,
deriveKey,
sha256,
hashByName,
hmacSha256,
md5
};
/**
* The Web Crypto API - grabbed from the Node.js library or the global
* @type Crypto
*/
var webCrypto = nodeCrypto.webcrypto || globalThis.crypto;
/**
* The SubtleCrypto API for low level crypto operations.
* @type SubtleCrypto
*/
var subtleCrypto = webCrypto.subtle;
var textEncoder = new TextEncoder();
/**
*
* @param {*} length
* @returns
*/
function randomBytes(length) {
return webCrypto.getRandomValues(Buffer.alloc(length));
}
async function md5(string) {
try {
return nodeCrypto.createHash("md5").update(string, "utf-8").digest("hex");
} catch (e) {
const data = typeof string === "string" ? textEncoder.encode(string) : string;
const hash = await subtleCrypto.digest("MD5", data);
return Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join("");
}
}
async function postgresMd5PasswordHash(user, password, salt) {
const inner = await md5(password + user);
return "md5" + await md5(Buffer.concat([Buffer.from(inner), salt]));
}
/**
* Create a SHA-256 digest of the given data
* @param {Buffer} data
*/
async function sha256(text) {
return await subtleCrypto.digest("SHA-256", text);
}
async function hashByName(hashName, text) {
return await subtleCrypto.digest(hashName, text);
}
/**
* Sign the message with the given key
* @param {ArrayBuffer} keyBuffer
* @param {string} msg
*/
async function hmacSha256(keyBuffer, msg) {
const key = await subtleCrypto.importKey("raw", keyBuffer, {
name: "HMAC",
hash: "SHA-256"
}, false, ["sign"]);
return await subtleCrypto.sign("HMAC", key, textEncoder.encode(msg));
}
/**
* Derive a key from the password and salt
* @param {string} password
* @param {Uint8Array} salt
* @param {number} iterations
*/
async function deriveKey(password, salt, iterations) {
const key = await subtleCrypto.importKey("raw", textEncoder.encode(password), "PBKDF2", false, ["deriveBits"]);
const params = {
name: "PBKDF2",
hash: "SHA-256",
salt,
iterations
};
return await subtleCrypto.deriveBits(params, key, 256, ["deriveBits"]);
}
}));
//#endregion
//#region ../../node_modules/pg/lib/crypto/utils.js
var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
if (parseInt(process.versions && process.versions.node && process.versions.node.split(".")[0]) < 15) module.exports = require_utils_legacy();
else module.exports = require_utils_webcrypto();
}));
//#endregion
//#region ../../node_modules/pg/lib/crypto/cert-signatures.js
var require_cert_signatures = /* @__PURE__ */ __commonJSMin(((exports, module) => {
function x509Error(msg, cert) {
return /* @__PURE__ */ new Error("SASL channel binding: " + msg + " when parsing public certificate " + cert.toString("base64"));
}
function readASN1Length(data, index) {
let length = data[index++];
if (length < 128) return {
length,
index
};
const lengthBytes = length & 127;
if (lengthBytes > 4) throw x509Error("bad length", data);
length = 0;
for (let i = 0; i < lengthBytes; i++) length = length << 8 | data[index++];
return {
length,
index
};
}
function readASN1OID(data, index) {
if (data[index++] !== 6) throw x509Error("non-OID data", data);
const { length: OIDLength, index: indexAfterOIDLength } = readASN1Length(data, index);
index = indexAfterOIDLength;
const lastIndex = index + OIDLength;
const byte1 = data[index++];
let oid = (byte1 / 40 >> 0) + "." + byte1 % 40;
while (index < lastIndex) {
let value = 0;
while (index < lastIndex) {
const nextByte = data[index++];
value = value << 7 | nextByte & 127;
if (nextByte < 128) break;
}
oid += "." + value;
}
return {
oid,
index
};
}
function expectASN1Seq(data, index) {
if (data[index++] !== 48) throw x509Error("non-sequence data", data);
return readASN1Length(data, index);
}
function signatureAlgorithmHashFromCertificate(data, index) {
if (index === void 0) index = 0;
index = expectASN1Seq(data, index).index;
const { length: certInfoLength, index: indexAfterCertInfoLength } = expectASN1Seq(data, index);
index = indexAfterCertInfoLength + certInfoLength;
index = expectASN1Seq(data, index).index;
const { oid, index: indexAfterOID } = readASN1OID(data, index);
switch (oid) {
case "1.2.840.113549.1.1.4": return "MD5";
case "1.2.840.113549.1.1.5": return "SHA-1";
case "1.2.840.113549.1.1.11": return "SHA-256";
case "1.2.840.113549.1.1.12": return "SHA-384";
case "1.2.840.113549.1.1.13": return "SHA-512";
case "1.2.840.113549.1.1.14": return "SHA-224";
case "1.2.840.113549.1.1.15": return "SHA512-224";
case "1.2.840.113549.1.1.16": return "SHA512-256";
case "1.2.840.10045.4.1": return "SHA-1";
case "1.2.840.10045.4.3.1": return "SHA-224";
case "1.2.840.10045.4.3.2": return "SHA-256";
case "1.2.840.10045.4.3.3": return "SHA-384";
case "1.2.840.10045.4.3.4": return "SHA-512";
case "1.2.840.113549.1.1.10": {
index = indexAfterOID;
index = expectASN1Seq(data, index).index;
if (data[index++] !== 160) throw x509Error("non-tag data", data);
index = readASN1Length(data, index).index;
index = expectASN1Seq(data, index).index;
const { oid: hashOID } = readASN1OID(data, index);
switch (hashOID) {
case "1.2.840.113549.2.5": return "MD5";
case "1.3.14.3.2.26": return "SHA-1";
case "2.16.840.1.101.3.4.2.1": return "SHA-256";
case "2.16.840.1.101.3.4.2.2": return "SHA-384";
case "2.16.840.1.101.3.4.2.3": return "SHA-512";
}
throw x509Error("unknown hash OID " + hashOID, data);
}
case "1.3.101.110":
case "1.3.101.112": return "SHA-512";
case "1.3.101.111":
case "1.3.101.113": throw x509Error("Ed448 certificate channel binding is not currently supported by Postgres");
}
throw x509Error("unknown OID " + oid, data);
}
module.exports = { signatureAlgorithmHashFromCertificate };
}));
//#endregion
//#region ../../node_modules/pg/lib/crypto/sasl.js
var require_sasl = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var crypto = require_utils();
var { signatureAlgorithmHashFromCertificate } = require_cert_signatures();
function startSession(mechanisms, stream) {
const candidates = ["SCRAM-SHA-256"];
if (stream) candidates.unshift("SCRAM-SHA-256-PLUS");
const mechanism = candidates.find((candidate) => mechanisms.includes(candidate));
if (!mechanism) throw new Error("SASL: Only mechanism(s) " + candidates.join(" and ") + " are supported");
if (mechanism === "SCRAM-SHA-256-PLUS" && typeof stream.getPeerCertificate !== "function") throw new Error("SASL: Mechanism SCRAM-SHA-256-PLUS requires a certificate");
const clientNonce = crypto.randomBytes(18).toString("base64");
return {
mechanism,
clientNonce,
response: (mechanism === "SCRAM-SHA-256-PLUS" ? "p=tls-server-end-point" : stream ? "y" : "n") + ",,n=*,r=" + clientNonce,
message: "SASLInitialResponse"
};
}
async function continueSession(session, password, serverData, stream) {
if (session.message !== "SASLInitialResponse") throw new Error("SASL: Last message was not SASLInitialResponse");
if (typeof password !== "string") throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: client password must be a string");
if (password === "") throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: client password must be a non-empty string");
if (typeof serverData !== "string") throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: serverData must be a string");
const sv = parseServerFirstMessage(serverData);
if (!sv.nonce.startsWith(session.clientNonce)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce does not start with client nonce");
else if (sv.nonce.length === session.clientNonce.length) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce is too short");
const clientFirstMessageBare = "n=*,r=" + session.clientNonce;
const serverFirstMessage = "r=" + sv.nonce + ",s=" + sv.salt + ",i=" + sv.iteration;
let channelBinding = stream ? "eSws" : "biws";
if (session.mechanism === "SCRAM-SHA-256-PLUS") {
const peerCert = stream.getPeerCertificate().raw;
let hashName = signatureAlgorithmHashFromCertificate(peerCert);
if (hashName === "MD5" || hashName === "SHA-1") hashName = "SHA-256";
const certHash = await crypto.hashByName(hashName, peerCert);
channelBinding = Buffer.concat([Buffer.from("p=tls-server-end-point,,"), Buffer.from(certHash)]).toString("base64");
}
const clientFinalMessageWithoutProof = "c=" + channelBinding + ",r=" + sv.nonce;
const authMessage = clientFirstMessageBare + "," + serverFirstMessage + "," + clientFinalMessageWithoutProof;
const saltBytes = Buffer.from(sv.salt, "base64");
const saltedPassword = await crypto.deriveKey(password, saltBytes, sv.iteration);
const clientKey = await crypto.hmacSha256(saltedPassword, "Client Key");
const storedKey = await crypto.sha256(clientKey);
const clientSignature = await crypto.hmacSha256(storedKey, authMessage);
const clientProof = xorBuffers(Buffer.from(clientKey), Buffer.from(clientSignature)).toString("base64");
const serverKey = await crypto.hmacSha256(saltedPassword, "Server Key");
const serverSignatureBytes = await crypto.hmacSha256(serverKey, authMessage);
session.message = "SASLResponse";
session.serverSignature = Buffer.from(serverSignatureBytes).toString("base64");
session.response = clientFinalMessageWithoutProof + ",p=" + clientProof;
}
function finalizeSession(session, serverData) {
if (session.message !== "SASLResponse") throw new Error("SASL: Last message was not SASLResponse");
if (typeof serverData !== "string") throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: serverData must be a string");
const { serverSignature } = parseServerFinalMessage(serverData);
if (serverSignature !== session.serverSignature) throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature does not match");
}
/**
* printable = %x21-2B / %x2D-7E
* ;; Printable ASCII except ",".
* ;; Note that any "printable" is also
* ;; a valid "value".
*/
function isPrintableChars(text) {
if (typeof text !== "string") throw new TypeError("SASL: text must be a string");
return text.split("").map((_, i) => text.charCodeAt(i)).every((c) => c >= 33 && c <= 43 || c >= 45 && c <= 126);
}
/**
* base64-char = ALPHA / DIGIT / "/" / "+"
*
* base64-4 = 4base64-char
*
* base64-3 = 3base64-char "="
*
* base64-2 = 2base64-char "=="
*
* base64 = *base64-4 [base64-3 / base64-2]
*/
function isBase64(text) {
return /^(?:[a-zA-Z0-9+/]{4})*(?:[a-zA-Z0-9+/]{2}==|[a-zA-Z0-9+/]{3}=)?$/.test(text);
}
function parseAttributePairs(text) {
if (typeof text !== "string") throw new TypeError("SASL: attribute pairs text must be a string");
return new Map(text.split(",").map((attrValue) => {
if (!/^.=/.test(attrValue)) throw new Error("SASL: Invalid attribute pair entry");
return [attrValue[0], attrValue.substring(2)];
}));
}
function parseServerFirstMessage(data) {
const attrPairs = parseAttributePairs(data);
const nonce = attrPairs.get("r");
if (!nonce) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce missing");
else if (!isPrintableChars(nonce)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce must only contain printable characters");
const salt = attrPairs.get("s");
if (!salt) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: salt missing");
else if (!isBase64(salt)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: salt must be base64");
const iterationText = attrPairs.get("i");
if (!iterationText) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: iteration missing");
else if (!/^[1-9][0-9]*$/.test(iterationText)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: invalid iteration count");
return {
nonce,
salt,
iteration: parseInt(iterationText, 10)
};
}
function parseServerFinalMessage(serverData) {
const serverSignature = parseAttributePairs(serverData).get("v");
if (!serverSignature) throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature is missing");
else if (!isBase64(serverSignature)) throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature must be base64");
return { serverSignature };
}
function xorBuffers(a, b) {
if (!Buffer.isBuffer(a)) throw new TypeError("first argument must be a Buffer");
if (!Buffer.isBuffer(b)) throw new TypeError("second argument must be a Buffer");
if (a.length !== b.length) throw new Error("Buffer lengths must match");
if (a.length === 0) throw new Error("Buffers cannot be empty");
return Buffer.from(a.map((_, i) => a[i] ^ b[i]));
}
module.exports = {
startSession,
continueSession,
finalizeSession
};
}));
//#endregion
//#region ../../node_modules/pg/lib/type-overrides.js
var require_type_overrides = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var types = require_pg_types();
function TypeOverrides(userTypes) {
this._types = userTypes || types;
this.text = {};
this.binary = {};
}
TypeOverrides.prototype.getOverrides = function(format) {
switch (format) {
case "text": return this.text;
case "binary": return this.binary;
default: return {};
}
};
TypeOverrides.prototype.setTypeParser = function(oid, format, parseFn) {
if (typeof format === "function") {
parseFn = format;
format = "text";
}
this.getOverrides(format)[oid] = parseFn;
};
TypeOverrides.prototype.getTypeParser = function(oid, format) {
format = format || "text";
return this.getOverrides(format)[oid] || this._types.getTypeParser(oid, format);
};
module.exports = TypeOverrides;
}));
//#endregion
//#region browser-external:dns
var require_browser_external_dns = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = Object.create(new Proxy({}, { get(_, key) {
if (key !== "__esModule" && key !== "__proto__" && key !== "constructor" && key !== "splice") console.warn(`Module "dns" has been externalized for browser compatibility. Cannot access "dns.${key}" in client code. See https://vite.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.`);
} }));
}));
//#endregion
//#region ../../node_modules/pg-connection-string/index.js
var require_pg_connection_string = /* @__PURE__ */ __commonJSMin(((exports, module) => {
function parse(str, options = {}) {
if (str.charAt(0) === "/") {
const config = str.split(" ");
return {
host: config[0],
database: config[1]
};
}
const config = {};
let result;
let dummyHost = false;
if (/ |%[^a-f0-9]|%[a-f0-9][^a-f0-9]/i.test(str)) str = encodeURI(str).replace(/%25(\d\d)/g, "%$1");
try {
try {
result = new URL(str, "postgres://base");
} catch (e) {
result = new URL(str.replace("@/", "@___DUMMY___/"), "postgres://base");
dummyHost = true;
}
} catch (err) {
err.input && (err.input = "*****REDACTED*****");
}
for (const entry of result.searchParams.entries()) config[entry[0]] = entry[1];
config.user = config.user || decodeURIComponent(result.username);
config.password = config.password || decodeURIComponent(result.password);
if (result.protocol == "socket:") {
config.host = decodeURI(result.pathname);
config.database = result.searchParams.get("db");
config.client_encoding = result.searchParams.get("encoding");
return config;
}
const hostname = dummyHost ? "" : result.hostname;
if (!config.host) config.host = decodeURIComponent(hostname);
else if (hostname && /^%2f/i.test(hostname)) result.pathname = hostname + result.pathname;
if (!config.port) config.port = result.port;
const pathname = result.pathname.slice(1) || null;
config.database = pathname ? decodeURI(pathname) : null;
if (config.ssl === "true" || config.ssl === "1") config.ssl = true;
if (config.ssl === "0") config.ssl = false;
if (config.sslcert || config.sslkey || config.sslrootcert || config.sslmode) config.ssl = {};
const fs = config.sslcert || config.sslkey || config.sslrootcert ? require_browser_external_fs() : null;
if (config.sslcert) config.ssl.cert = fs.readFileSync(config.sslcert).toString();
if (config.sslkey) config.ssl.key = fs.readFileSync(config.sslkey).toString();
if (config.sslrootcert) config.ssl.ca = fs.readFileSync(config.sslrootcert).toString();
if (options.useLibpqCompat && config.uselibpqcompat) throw new Error("Both useLibpqCompat and uselibpqcompat are set. Please use only one of them.");
if (config.uselibpqcompat === "true" || options.useLibpqCompat) switch (config.sslmode) {
case "disable":
config.ssl = false;
break;
case "prefer":
config.ssl.rejectUnauthorized = false;
break;
case "require":
if (config.sslrootcert) config.ssl.checkServerIdentity = function() {};
else config.ssl.rejectUnauthorized = false;
break;
case "verify-ca":
if (!config.ssl.ca) throw new Error("SECURITY WARNING: Using sslmode=verify-ca requires specifying a CA with sslrootcert. If a public CA is used, verify-ca allows connections to a server that somebody else may have registered with the CA, making you vulnerable to Man-in-the-Middle attacks. Either specify a custom CA certificate with sslrootcert parameter or use sslmode=verify-full for proper security.");
config.ssl.checkServerIdentity = function() {};
break;
case "verify-full": break;
}
else switch (config.sslmode) {
case "disable":
config.ssl = false;
break;
case "prefer":
case "require":
case "verify-ca":
case "verify-full": break;
case "no-verify":
config.ssl.rejectUnauthorized = false;
break;
}
return config;
}
function toConnectionOptions(sslConfig) {
return Object.entries(sslConfig).reduce((c, [key, value]) => {
if (value !== void 0 && value !== null) c[key] = value;
return c;
}, {});
}
function toClientConfig(config) {
return Object.entries(config).reduce((c, [key, value]) => {
if (key === "ssl") {
const sslConfig = value;
if (typeof sslConfig === "boolean") c[key] = sslConfig;
if (typeof sslConfig === "object") c[key] = toConnectionOptions(sslConfig);
} else if (value !== void 0 && value !== null) if (key === "port") {
if (value !== "") {
const v = parseInt(value, 10);
if (isNaN(v)) throw new Error(`Invalid ${key}: ${value}`);
c[key] = v;
}
} else c[key] = value;
return c;
}, {});
}
function parseIntoClientConfig(str) {
return toClientConfig(parse(str));
}
module.exports = parse;
parse.parse = parse;
parse.toClientConfig = toClientConfig;
parse.parseIntoClientConfig = parseIntoClientConfig;
}));
//#endregion
//#region ../../node_modules/pg/lib/connection-parameters.js
var require_connection_parameters = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var dns = require_browser_external_dns();
var defaults = require_defaults();
var parse = require_pg_connection_string().parse;
var val = function(key, config, envVar) {
if (envVar === void 0) envVar = process.env["PG" + key.toUpperCase()];
else if (envVar === false) {} else envVar = process.env[envVar];
return config[key] || envVar || defaults[key];
};
var readSSLConfigFromEnvironment = function() {
switch (process.env.PGSSLMODE) {
case "disable": return false;
case "prefer":
case "require":
case "verify-ca":
case "verify-full": return true;
case "no-verify": return { rejectUnauthorized: false };
}
return defaults.ssl;
};
var quoteParamValue = function(value) {
return "'" + ("" + value).replace(/\\/g, "\\\\").replace(/'/g, "\\'") + "'";
};
var add = function(params, config, paramName) {
const value = config[paramName];
if (value !== void 0 && value !== null) params.push(paramName + "=" + quoteParamValue(value));
};
var ConnectionParameters = class {
constructor(config) {
config = typeof config === "string" ? parse(config) : config || {};
if (config.connectionString) config = Object.assign({}, config, parse(config.connectionString));
this.user = val("user", config);
this.database = val("database", config);
if (this.database === void 0) this.database = this.user;
this.port = parseInt(val("port", config), 10);
this.host = val("host", config);
Object.defineProperty(this, "password", {
configurable: true,
enumerable: false,
writable: true,
value: val("password", config)
});
this.binary = val("binary", config);
this.options = val("options", config);
this.ssl = typeof config.ssl === "undefined" ? readSSLConfigFromEnvironment() : config.ssl;
if (typeof this.ssl === "string") {
if (this.ssl === "true") this.ssl = true;
}
if (this.ssl === "no-verify") this.ssl = { rejectUnauthorized: false };
if (this.ssl && this.ssl.key) Object.defineProperty(this.ssl, "key", { enumerable: false });
this.client_encoding = val("client_encoding", config);
this.replication = val("replication", config);
this.isDomainSocket = !(this.host || "").indexOf("/");
this.application_name = val("application_name", config, "PGAPPNAME");
this.fallback_application_name = val("fallback_application_name", config, false);
this.statement_timeout = val("statement_timeout", config, false);
this.lock_timeout = val("lock_timeout", config, false);
this.idle_in_transaction_session_timeout = val("idle_in_transaction_session_timeout", config, false);
this.query_timeout = val("query_timeout", config, false);
if (config.connectionTimeoutMillis === void 0) this.connect_timeout = process.env.PGCONNECT_TIMEOUT || 0;
else this.connect_timeout = Math.floor(config.connectionTimeoutMillis / 1e3);
if (config.keepAlive === false) this.keepalives = 0;
else if (config.keepAlive === true) this.keepalives = 1;
if (typeof config.keepAliveInitialDelayMillis === "number") this.keepalives_idle = Math.floor(config.keepAliveInitialDelayMillis / 1e3);
}
getLibpqConnectionString(cb) {
const params = [];
add(params, this, "user");
add(params, this, "password");
add(params, this, "port");
add(params, this, "application_name");
add(params, this, "fallback_application_name");
add(params, this, "connect_timeout");
add(params, this, "options");
const ssl = typeof this.ssl === "object" ? this.ssl : this.ssl ? { sslmode: this.ssl } : {};
add(params, ssl, "sslmode");
add(params, ssl, "sslca");
add(params, ssl, "sslkey");
add(params, ssl, "sslcert");
add(params, ssl, "sslrootcert");
if (this.database) params.push("dbname=" + quoteParamValue(this.database));
if (this.replication) params.push("replication=" + quoteParamValue(this.replication));
if (this.host) params.push("host=" + quoteParamValue(this.host));
if (this.isDomainSocket) return cb(null, params.join(" "));
if (this.client_encoding) params.push("client_encoding=" + quoteParamValue(this.client_encoding));
dns.lookup(this.host, function(err, address) {
if (err) return cb(err, null);
params.push("hostaddr=" + quoteParamValue(address));
return cb(null, params.join(" "));
});
}
};
module.exports = ConnectionParameters;
}));
//#endregion
//#region ../../node_modules/pg/lib/result.js
var require_result = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var types = require_pg_types();
var matchRegexp = /^([A-Za-z]+)(?: (\d+))?(?: (\d+))?/;
var Result = class {
constructor(rowMode, types) {
this.command = null;
this.rowCount = null;
this.oid = null;
this.rows = [];
this.fields = [];
this._parsers = void 0;
this._types = types;
this.RowCtor = null;
this.rowAsArray = rowMode === "array";
if (this.rowAsArray) this.parseRow = this._parseRowAsArray;
this._prebuiltEmptyResultObject = null;
}
addCommandComplete(msg) {
let match;
if (msg.text) match = matchRegexp.exec(msg.text);
else match = matchRegexp.exec(msg.command);
if (match) {
this.command = match[1];
if (match[3]) {
this.oid = parseInt(match[2], 10);
this.rowCount = parseInt(match[3], 10);
} else if (match[2]) this.rowCount = parseInt(match[2], 10);
}
}
_parseRowAsArray(rowData) {
const row = new Array(rowData.length);
for (let i = 0, len = rowData.length; i < len; i++) {
const rawValue = rowData[i];
if (rawValue !== null) row[i] = this._parsers[i](rawValue);
else row[i] = null;
}
return row;
}
parseRow(rowData) {
const row = { ...this._prebuiltEmptyResultObject };
for (let i = 0, len = rowData.length; i < len; i++) {
const rawValue = rowData[i];
const field = this.fields[i].name;
if (rawValue !== null) {
const v = this.fields[i].format === "binary" ? Buffer.from(rawValue) : rawValue;
row[field] = this._parsers[i](v);
} else row[field] = null;
}
return row;
}
addRow(row) {
this.rows.push(row);
}
addFields(fieldDescriptions) {
this.fields = fieldDescriptions;
if (this.fields.length) this._parsers = new Array(fieldDescriptions.length);
const row = {};
for (let i = 0; i < fieldDescriptions.length; i++) {
const desc = fieldDescriptions[i];
row[desc.name] = null;
if (this._types) this._parsers[i] = this._types.getTypeParser(desc.dataTypeID, desc.format || "text");
else this._parsers[i] = types.getTypeParser(desc.dataTypeID, desc.format || "text");
}
this._prebuiltEmptyResultObject = { ...row };
}
};
module.exports = Result;
}));
//#endregion
//#region ../../node_modules/pg/lib/query.js
var require_query$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var { EventEmitter } = require_events();
var Result = require_result();
var utils = require_utils$1();
var Query = class extends EventEmitter {
constructor(config, values, callback) {
super();
config = utils.normalizeQueryConfig(config, values, callback);
this.text = config.text;
this.values = config.values;
this.rows = config.rows;
this.types = config.types;
this.name = config.name;
this.queryMode = config.queryMode;
this.binary = config.binary;
this.portal = config.portal || "";
this.callback = config.callback;
this._rowMode = config.rowMode;
if (process.domain && config.callback) this.callback = process.domain.bind(config.callback);
this._result = new Result(this._rowMode, this.types);
this._results = this._result;
this._canceledDueToError = false;
}
requiresPreparation() {
if (this.queryMode === "extended") return true;
if (this.name) return true;
if (this.rows) return true;
if (!this.text) return false;
if (!this.values) return false;
return this.values.length > 0;
}
_checkForMultirow() {
if (this._result.command) {
if (!Array.isArray(this._results)) this._results = [this._result];
this._result = new Result(this._rowMode, this._result._types);
this._results.push(this._result);
}
}
handleRowDescription(msg) {
this._checkForMultirow();
this._result.addFields(msg.fields);
this._accumulateRows = this.callback || !this.listeners("row").length;
}
handleDataRow(msg) {
let row;
if (this._canceledDueToError) return;
try {
row = this._result.parseRow(msg.fields);
} catch (err) {
this._canceledDueToError = err;
return;
}
this.emit("row", row, this._result);
if (this._accumulateRows) this._result.addRow(row);
}
handleCommandComplete(msg, connection) {
this._checkForMultirow();
this._result.addCommandComplete(msg);
if (this.rows) connection.sync();
}
handleEmptyQuery(connection) {
if (this.rows) connection.sync();
}
handleError(err, connection) {
if (this._canceledDueToError) {
err = this._canceledDueToError;
this._canceledDueToError = false;
}
if (this.callback) return this.callback(err);
this.emit("error", err);
}
handleReadyForQuery(con) {
if (this._canceledDueToError) return this.handleError(this._canceledDueToError, con);
if (this.callback) try {
this.callback(null, this._results);
} catch (err) {
process.nextTick(() => {
throw err;
});
}
this.emit("end", this._results);
}
submit(connection) {
if (typeof this.text !== "string" && typeof this.name !== "string") return /* @__PURE__ */ new Error("A query must have either text or a name. Supplying neither is unsupported.");
const previous = connection.parsedStatements[this.name];
if (this.text && previous && this.text !== previous) return /* @__PURE__ */ new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`);
if (this.values && !Array.isArray(this.values)) return /* @__PURE__ */ new Error("Query values must be an array");
if (this.requiresPreparation()) {
connection.stream.cork && connection.stream.cork();
try {
this.prepare(connection);
} finally {
connection.stream.uncork && connection.stream.uncork();
}
} else connection.query(this.text);
return null;
}
hasBeenParsed(connection) {
return this.name && connection.parsedStatements[this.name];
}
handlePortalSuspended(connection) {
this._getRows(connection, this.rows);
}
_getRows(connection, rows) {
connection.execute({
portal: this.portal,
rows
});
if (!rows) connection.sync();
else connection.flush();
}
prepare(connection) {
if (!this.hasBeenParsed(connection)) connection.parse({
text: this.text,
name: this.name,
types: this.types
});
try {
connection.bind({
portal: this.portal,
statement: this.name,
values: this.values,
binary: this.binary,
valueMapper: utils.prepareValue
});
} catch (err) {
this.handleError(err, connection);
return;
}
connection.describe({
type: "P",
name: this.portal || ""
});
this._getRows(connection, this.rows);
}
handleCopyInResponse(connection) {
connection.sendCopyFail("No source stream defined");
}
handleCopyData(msg, connection) {}
};
module.exports = Query;
}));
//#endregion
//#region ../../node_modules/pg-protocol/dist/messages.js
var require_messages = /* @__PURE__ */ __commonJSMin(((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.NoticeMessage = exports.DataRowMessage = exports.CommandCompleteMessage = exports.ReadyForQueryMessage = exports.NotificationResponseMessage = exports.BackendKeyDataMessage = exports.AuthenticationMD5Password = exports.ParameterStatusMessage = exports.ParameterDescriptionMessage = exports.RowDescriptionMessage = exports.Field = exports.CopyResponse = exports.CopyDataMessage = exports.DatabaseError = exports.copyDone = exports.emptyQuery = exports.replicationStart = exports.portalSuspended = exports.noData = exports.closeComplete = exports.bindComplete = exports.parseComplete = void 0;
exports.parseComplete = {
name: "parseComplete",
length: 5
};
exports.bindComplete = {
name: "bindComplete",
length: 5
};
exports.closeComplete = {
name: "closeComplete",
length: 5
};
exports.noData = {
name: "noData",
length: 5
};
exports.portalSuspended = {
name: "portalSuspended",
length: 5
};
exports.replicationStart = {
name: "replicationStart",
length: 4
};
exports.emptyQuery = {
name: "emptyQuery",
length: 4
};
exports.copyDone = {
name: "copyDone",
length: 4
};
var DatabaseError = class extends Error {
constructor(message, length, name) {
super(message);
this.length = length;
this.name = name;
}
};
exports.DatabaseError = DatabaseError;
var CopyDataMessage = class {
constructor(length, chunk) {
this.length = length;
this.chunk = chunk;
this.name = "copyData";
}
};
exports.CopyDataMessage = CopyDataMessage;
var CopyResponse = class {
constructor(length, name, binary, columnCount) {
this.length = length;
this.name = name;
this.binary = binary;
this.columnTypes = new Array(columnCount);
}
};
exports.CopyResponse = CopyResponse;
var Field = class {
constructor(name, tableID, columnID, dataTypeID, dataTypeSize, dataTypeModifier, format) {
this.name = name;
this.tableID = tableID;
this.columnID = columnID;
this.dataTypeID = dataTypeID;
this.dataTypeSize = dataTypeSize;
this.dataTypeModifier = dataTypeModifier;
this.format = format;
}
};
exports.Field = Field;
var RowDescriptionMessage = class {
constructor(length, fieldCount) {
this.length = length;
this.fieldCount = fieldCount;
this.name = "rowDescription";
this.fields = new Array(this.fieldCount);
}
};
exports.RowDescriptionMessage = RowDescriptionMessage;
var ParameterDescriptionMessage = class {
constructor(length, parameterCount) {
this.length = length;
this.parameterCount = parameterCount;
this.name = "parameterDescription";
this.dataTypeIDs = new Array(this.parameterCount);
}
};
exports.ParameterDescriptionMessage = ParameterDescriptionMessage;
var ParameterStatusMessage = class {
constructor(length, parameterName, parameterValue) {
this.length = length;
this.parameterName = parameterName;
this.parameterValue = parameterValue;
this.name = "parameterStatus";
}
};
exports.ParameterStatusMessage = ParameterStatusMessage;
var AuthenticationMD5Password = class {
constructor(length, salt) {
this.length = length;
this.salt = salt;
this.name = "authenticationMD5Password";
}
};
exports.AuthenticationMD5Password = AuthenticationMD5Password;
var BackendKeyDataMessage = class {
constructor(length, processID, secretKey) {
this.length = length;
this.processID = processID;
this.secretKey = secretKey;
this.name = "backendKeyData";
}
};
exports.BackendKeyDataMessage = BackendKeyDataMessage;
var NotificationResponseMessage = class {
constructor(length, processId, channel, payload) {
this.length = length;
this.processId = processId;
this.channel = channel;
this.payload = payload;
this.name = "notification";
}
};
exports.NotificationResponseMessage = NotificationResponseMessage;
var ReadyForQueryMessage = class {
constructor(length, status) {
this.length = length;
this.status = status;
this.name = "readyForQuery";
}
};
exports.ReadyForQueryMessage = ReadyForQueryMessage;
var CommandCompleteMessage = class {
constructor(length, text) {
this.length = length;
this.text = text;
this.name = "commandComplete";
}
};
exports.CommandCompleteMessage = CommandCompleteMessage;
var DataRowMessage = class {
constructor(length, fields) {
this.length = length;
this.fields = fields;
this.name = "dataRow";
this.fieldCount = fields.length;
}
};
exports.DataRowMessage = DataRowMessage;
var NoticeMessage = class {
constructor(length, message) {
this.length = length;
this.message = message;
this.name = "notice";
}
};
exports.NoticeMessage = NoticeMessage;
}));
//#endregion
//#region ../../node_modules/pg-protocol/dist/buffer-writer.js
var require_buffer_writer = /* @__PURE__ */ __commonJSMin(((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.Writer = void 0;
var Writer = class {
constructor(size = 256) {
this.size = size;
this.offset = 5;
this.headerPosition = 0;
this.buffer = Buffer.allocUnsafe(size);
}
ensure(size) {
if (this.buffer.length - this.offset < size) {
const oldBuffer = this.buffer;
const newSize = oldBuffer.length + (oldBuffer.length >> 1) + size;
this.buffer = Buffer.allocUnsafe(newSize);
oldBuffer.copy(this.buffer);
}
}
addInt32(num) {
this.ensure(4);
this.buffer[this.offset++] = num >>> 24 & 255;
this.buffer[this.offset++] = num >>> 16 & 255;
this.buffer[this.offset++] = num >>> 8 & 255;
this.buffer[this.offset++] = num >>> 0 & 255;
return this;
}
addInt16(num) {
this.ensure(2);
this.buffer[this.offset++] = num >>> 8 & 255;
this.buffer[this.offset++] = num >>> 0 & 255;
return this;
}
addCString(string) {
if (!string) this.ensure(1);
else {
const len = Buffer.byteLength(string);
this.ensure(len + 1);
this.buffer.write(string, this.offset, "utf-8");
this.offset += len;
}
this.buffer[this.offset++] = 0;
return this;
}
addString(string = "") {
const len = Buffer.byteLength(string);
this.ensure(len);
this.buffer.write(string, this.offset);
this.offset += len;
return this;
}
add(otherBuffer) {
this.ensure(otherBuffer.length);
otherBuffer.copy(this.buffer, this.offset);
this.offset += otherBuffer.length;
return this;
}
join(code) {
if (code) {
this.buffer[this.headerPosition] = code;
const length = this.offset - (this.headerPosition + 1);
this.buffer.writeInt32BE(length, this.headerPosition + 1);
}
return this.buffer.slice(code ? 0 : 5, this.offset);
}
flush(code) {
const result = this.join(code);
this.offset = 5;
this.headerPosition = 0;
this.buffer = Buffer.allocUnsafe(this.size);
return result;
}
};
exports.Writer = Writer;
}));
//#endregion
//#region ../../node_modules/pg-protocol/dist/serializer.js
var require_serializer = /* @__PURE__ */ __commonJSMin(((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.serialize = void 0;
var buffer_writer_1 = require_buffer_writer();
var writer = new buffer_writer_1.Writer();
var startup = (opts) => {
writer.addInt16(3).addInt16(0);
for (const key of Object.keys(opts)) writer.addCString(key).addCString(opts[key]);
writer.addCString("client_encoding").addCString("UTF8");
const bodyBuffer = writer.addCString("").flush();
const length = bodyBuffer.length + 4;
return new buffer_writer_1.Writer().addInt32(length).add(bodyBuffer).flush();
};
var requestSsl = () => {
const response = Buffer.allocUnsafe(8);
response.writeInt32BE(8, 0);
response.writeInt32BE(80877103, 4);
return response;
};
var password = (password) => {
return writer.addCString(password).flush(112);
};
var sendSASLInitialResponseMessage = function(mechanism, initialResponse) {
writer.addCString(mechanism).addInt32(Buffer.byteLength(initialResponse)).addString(initialResponse);
return writer.flush(112);
};
var sendSCRAMClientFinalMessage = function(additionalData) {
return writer.addString(additionalData).flush(112);
};
var query = (text) => {
return writer.addCString(text).flush(81);
};
var emptyArray = [];
var parse = (query) => {
const name = query.name || "";
if (name.length > 63) {
console.error("Warning! Postgres only supports 63 characters for query names.");
console.error("You supplied %s (%s)", name, name.length);
console.error("This can cause conflicts and silent errors executing queries");
}
const types = query.types || emptyArray;
const len = types.length;
const buffer = writer.addCString(name).addCString(query.text).addInt16(len);
for (let i = 0; i < len; i++) buffer.addInt32(types[i]);
return writer.flush(80);
};
var paramWriter = new buffer_writer_1.Writer();
var writeValues = function(values, valueMapper) {
for (let i = 0; i < values.length; i++) {
const mappedVal = valueMapper ? valueMapper(values[i], i) : values[i];
if (mappedVal == null) {
writer.addInt16(0);
paramWriter.addInt32(-1);
} else if (mappedVal instanceof Buffer) {
writer.addInt16(1);
paramWriter.addInt32(mappedVal.length);
paramWriter.add(mappedVal);
} else {
writer.addInt16(0);
paramWriter.addInt32(Buffer.byteLength(mappedVal));
paramWriter.addString(mappedVal);
}
}
};
var bind = (config = {}) => {
const portal = config.portal || "";
const statement = config.statement || "";
const binary = config.binary || false;
const values = config.values || emptyArray;
const len = values.length;
writer.addCString(portal).addCString(statement);
writer.addInt16(len);
writeValues(values, config.valueMapper);
writer.addInt16(len);
writer.add(paramWriter.flush());
writer.addInt16(1);
writer.addInt16(binary ? 1 : 0);
return writer.flush(66);
};
var emptyExecute = Buffer.from([
69,
0,
0,
0,
9,
0,
0,
0,
0,
0
]);
var execute = (config) => {
if (!config || !config.portal && !config.rows) return emptyExecute;
const portal = config.portal || "";
const rows = config.rows || 0;
const portalLength = Buffer.byteLength(portal);
const len = 4 + portalLength + 1 + 4;
const buff = Buffer.allocUnsafe(1 + len);
buff[0] = 69;
buff.writeInt32BE(len, 1);
buff.write(portal, 5, "utf-8");
buff[portalLength + 5] = 0;
buff.writeUInt32BE(rows, buff.length - 4);
return buff;
};
var cancel = (processID, secretKey) => {
const buffer = Buffer.allocUnsafe(16);
buffer.writeInt32BE(16, 0);
buffer.writeInt16BE(1234, 4);
buffer.writeInt16BE(5678, 6);
buffer.writeInt32BE(processID, 8);
buffer.writeInt32BE(secretKey, 12);
return buffer;
};
var cstringMessage = (code, string) => {
const len = 4 + Buffer.byteLength(string) + 1;
const buffer = Buffer.allocUnsafe(1 + len);
buffer[0] = code;
buffer.writeInt32BE(len, 1);
buffer.write(string, 5, "utf-8");
buffer[len] = 0;
return buffer;
};
var emptyDescribePortal = writer.addCString("P").flush(68);
var emptyDescribeStatement = writer.addCString("S").flush(68);
var describe = (msg) => {
return msg.name ? cstringMessage(68, `${msg.type}${msg.name || ""}`) : msg.type === "P" ? emptyDescribePortal : emptyDescribeStatement;
};
var close = (msg) => {
return cstringMessage(67, `${msg.type}${msg.name || ""}`);
};
var copyData = (chunk) => {
return writer.add(chunk).flush(100);
};
var copyFail = (message) => {
return cstringMessage(102, message);
};
var codeOnlyBuffer = (code) => Buffer.from([
code,
0,
0,
0,
4
]);
var flushBuffer = codeOnlyBuffer(72);
var syncBuffer = codeOnlyBuffer(83);
var endBuffer = codeOnlyBuffer(88);
var copyDoneBuffer = codeOnlyBuffer(99);
exports.serialize = {
startup,
password,
requestSsl,
sendSASLInitialResponseMessage,
sendSCRAMClientFinalMessage,
query,
parse,
bind,
execute,
describe,
close,
flush: () => flushBuffer,
sync: () => syncBuffer,
end: () => endBuffer,
copyData,
copyDone: () => copyDoneBuffer,
copyFail,
cancel
};
}));
//#endregion
//#region ../../node_modules/pg-protocol/dist/buffer-reader.js
var require_buffer_reader = /* @__PURE__ */ __commonJSMin(((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.BufferReader = void 0;
var emptyBuffer = Buffer.allocUnsafe(0);
var BufferReader = class {
constructor(offset = 0) {
this.offset = offset;
this.buffer = emptyBuffer;
this.encoding = "utf-8";
}
setBuffer(offset, buffer) {
this.offset = offset;
this.buffer = buffer;
}
int16() {
const result = this.buffer.readInt16BE(this.offset);
this.offset += 2;
return result;
}
byte() {
const result = this.buffer[this.offset];
this.offset++;
return result;
}
int32() {
const result = this.buffer.readInt32BE(this.offset);
this.offset += 4;
return result;
}
uint32() {
const result = this.buffer.readUInt32BE(this.offset);
this.offset += 4;
return result;
}
string(length) {
const result = this.buffer.toString(this.encoding, this.offset, this.offset + length);
this.offset += length;
return result;
}
cstring() {
const start = this.offset;
let end = start;
while (this.buffer[end++] !== 0);
this.offset = end;
return this.buffer.toString(this.encoding, start, end - 1);
}
bytes(length) {
const result = this.buffer.slice(this.offset, this.offset + length);
this.offset += length;
return result;
}
};
exports.BufferReader = BufferReader;
}));
//#endregion
//#region ../../node_modules/pg-protocol/dist/parser.js
var require_parser = /* @__PURE__ */ __commonJSMin(((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.Parser = void 0;
var messages_1 = require_messages();
var buffer_reader_1 = require_buffer_reader();
var CODE_LENGTH = 1;
var HEADER_LENGTH = 5;
var emptyBuffer = Buffer.allocUnsafe(0);
var Parser = class {
constructor(opts) {
this.buffer = emptyBuffer;
this.bufferLength = 0;
this.bufferOffset = 0;
this.reader = new buffer_reader_1.BufferReader();
if ((opts === null || opts === void 0 ? void 0 : opts.mode) === "binary") throw new Error("Binary mode not supported yet");
this.mode = (opts === null || opts === void 0 ? void 0 : opts.mode) || "text";
}
parse(buffer, callback) {
this.mergeBuffer(buffer);
const bufferFullLength = this.bufferOffset + this.bufferLength;
let offset = this.bufferOffset;
while (offset + HEADER_LENGTH <= bufferFullLength) {
const code = this.buffer[offset];
const length = this.buffer.readUInt32BE(offset + CODE_LENGTH);
const fullMessageLength = CODE_LENGTH + length;
if (fullMessageLength + offset <= bufferFullLength) {
callback(this.handlePacket(offset + HEADER_LENGTH, code, length, this.buffer));
offset += fullMessageLength;
} else break;
}
if (offset === bufferFullLength) {
this.buffer = emptyBuffer;
this.bufferLength = 0;
this.bufferOffset = 0;
} else {
this.bufferLength = bufferFullLength - offset;
this.bufferOffset = offset;
}
}
mergeBuffer(buffer) {
if (this.bufferLength > 0) {
const newLength = this.bufferLength + buffer.byteLength;
if (newLength + this.bufferOffset > this.buffer.byteLength) {
let newBuffer;
if (newLength <= this.buffer.byteLength && this.bufferOffset >= this.bufferLength) newBuffer = this.buffer;
else {
let newBufferLength = this.buffer.byteLength * 2;
while (newLength >= newBufferLength) newBufferLength *= 2;
newBuffer = Buffer.allocUnsafe(newBufferLength);
}
this.buffer.copy(newBuffer, 0, this.bufferOffset, this.bufferOffset + this.bufferLength);
this.buffer = newBuffer;
this.bufferOffset = 0;
}
buffer.copy(this.buffer, this.bufferOffset + this.bufferLength);
this.bufferLength = newLength;
} else {
this.buffer = buffer;
this.bufferOffset = 0;
this.bufferLength = buffer.byteLength;
}
}
handlePacket(offset, code, length, bytes) {
switch (code) {
case 50: return messages_1.bindComplete;
case 49: return messages_1.parseComplete;
case 51: return messages_1.closeComplete;
case 110: return messages_1.noData;
case 115: return messages_1.portalSuspended;
case 99: return messages_1.copyDone;
case 87: return messages_1.replicationStart;
case 73: return messages_1.emptyQuery;
case 68: return this.parseDataRowMessage(offset, length, bytes);
case 67: return this.parseCommandCompleteMessage(offset, length, bytes);
case 90: return this.parseReadyForQueryMessage(offset, length, bytes);
case 65: return this.parseNotificationMessage(offset, length, bytes);
case 82: return this.parseAuthenticationResponse(offset, length, bytes);
case 83: return this.parseParameterStatusMessage(offset, length, bytes);
case 75: return this.parseBackendKeyData(offset, length, bytes);
case 69: return this.parseErrorMessage(offset, length, bytes, "error");
case 78: return this.parseErrorMessage(offset, length, bytes, "notice");
case 84: return this.parseRowDescriptionMessage(offset, length, bytes);
case 116: return this.parseParameterDescriptionMessage(offset, length, bytes);
case 71: return this.parseCopyInMessage(offset, length, bytes);
case 72: return this.parseCopyOutMessage(offset, length, bytes);
case 100: return this.parseCopyData(offset, length, bytes);
default: return new messages_1.DatabaseError("received invalid response: " + code.toString(16), length, "error");
}
}
parseReadyForQueryMessage(offset, length, bytes) {
this.reader.setBuffer(offset, bytes);
const status = this.reader.string(1);
return new messages_1.ReadyForQueryMessage(length, status);
}
parseCommandCompleteMessage(offset, length, bytes) {
this.reader.setBuffer(offset, bytes);
const text = this.reader.cstring();
return new messages_1.CommandCompleteMessage(length, text);
}
parseCopyData(offset, length, bytes) {
const chunk = bytes.slice(offset, offset + (length - 4));
return new messages_1.CopyDataMessage(length, chunk);
}
parseCopyInMessage(offset, length, bytes) {
return this.parseCopyMessage(offset, length, bytes, "copyInResponse");
}
parseCopyOutMessage(offset, length, bytes) {
return this.parseCopyMessage(offset, length, bytes, "copyOutResponse");
}
parseCopyMessage(offset, length, bytes, messageName) {
this.reader.setBuffer(offset, bytes);
const isBinary = this.reader.byte() !== 0;
const columnCount = this.reader.int16();
const message = new messages_1.CopyResponse(length, messageName, isBinary, columnCount);
for (let i = 0; i < columnCount; i++) message.columnTypes[i] = this.reader.int16();
return message;
}
parseNotificationMessage(offset, length, bytes) {
this.reader.setBuffer(offset, bytes);
const processId = this.reader.int32();
const channel = this.reader.cstring();
const payload = this.reader.cstring();
return new messages_1.NotificationResponseMessage(length, processId, channel, payload);
}
parseRowDescriptionMessage(offset, length, bytes) {
this.reader.setBuffer(offset, bytes);
const fieldCount = this.reader.int16();
const message = new messages_1.RowDescriptionMessage(length, fieldCount);
for (let i = 0; i < fieldCount; i++) message.fields[i] = this.parseField();
return message;
}
parseField() {
const name = this.reader.cstring();
const tableID = this.reader.uint32();
const columnID = this.reader.int16();
const dataTypeID = this.reader.uint32();
const dataTypeSize = this.reader.int16();
const dataTypeModifier = this.reader.int32();
const mode = this.reader.int16() === 0 ? "text" : "binary";
return new messages_1.Field(name, tableID, columnID, dataTypeID, dataTypeSize, dataTypeModifier, mode);
}
parseParameterDescriptionMessage(offset, length, bytes) {
this.reader.setBuffer(offset, bytes);
const parameterCount = this.reader.int16();
const message = new messages_1.ParameterDescriptionMessage(length, parameterCount);
for (let i = 0; i < parameterCount; i++) message.dataTypeIDs[i] = this.reader.int32();
return message;
}
parseDataRowMessage(offset, length, bytes) {
this.reader.setBuffer(offset, bytes);
const fieldCount = this.reader.int16();
const fields = new Array(fieldCount);
for (let i = 0; i < fieldCount; i++) {
const len = this.reader.int32();
fields[i] = len === -1 ? null : this.reader.string(len);
}
return new messages_1.DataRowMessage(length, fields);
}
parseParameterStatusMessage(offset, length, bytes) {
this.reader.setBuffer(offset, bytes);
const name = this.reader.cstring();
const value = this.reader.cstring();
return new messages_1.ParameterStatusMessage(length, name, value);
}
parseBackendKeyData(offset, length, bytes) {
this.reader.setBuffer(offset, bytes);
const processID = this.reader.int32();
const secretKey = this.reader.int32();
return new messages_1.BackendKeyDataMessage(length, processID, secretKey);
}
parseAuthenticationResponse(offset, length, bytes) {
this.reader.setBuffer(offset, bytes);
const code = this.reader.int32();
const message = {
name: "authenticationOk",
length
};
switch (code) {
case 0: break;
case 3:
if (message.length === 8) message.name = "authenticationCleartextPassword";
break;
case 5:
if (message.length === 12) {
message.name = "authenticationMD5Password";
const salt = this.reader.bytes(4);
return new messages_1.AuthenticationMD5Password(length, salt);
}
break;
case 10:
{
message.name = "authenticationSASL";
message.mechanisms = [];
let mechanism;
do {
mechanism = this.reader.cstring();
if (mechanism) message.mechanisms.push(mechanism);
} while (mechanism);
}
break;
case 11:
message.name = "authenticationSASLContinue";
message.data = this.reader.string(length - 8);
break;
case 12:
message.name = "authenticationSASLFinal";
message.data = this.reader.string(length - 8);
break;
default: throw new Error("Unknown authenticationOk message type " + code);
}
return message;
}
parseErrorMessage(offset, length, bytes, name) {
this.reader.setBuffer(offset, bytes);
const fields = {};
let fieldType = this.reader.string(1);
while (fieldType !== "\0") {
fields[fieldType] = this.reader.cstring();
fieldType = this.reader.string(1);
}
const messageValue = fields.M;
const message = name === "notice" ? new messages_1.NoticeMessage(length, messageValue) : new messages_1.DatabaseError(messageValue, length, name);
message.severity = fields.S;
message.code = fields.C;
message.detail = fields.D;
message.hint = fields.H;
message.position = fields.P;
message.internalPosition = fields.p;
message.internalQuery = fields.q;
message.where = fields.W;
message.schema = fields.s;
message.table = fields.t;
message.column = fields.c;
message.dataType = fields.d;
message.constraint = fields.n;
message.file = fields.F;
message.line = fields.L;
message.routine = fields.R;
return message;
}
};
exports.Parser = Parser;
}));
//#endregion
//#region ../../node_modules/pg-protocol/dist/index.js
var require_dist = /* @__PURE__ */ __commonJSMin(((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.DatabaseError = exports.serialize = exports.parse = void 0;
var messages_1 = require_messages();
Object.defineProperty(exports, "DatabaseError", {
enumerable: true,
get: function() {
return messages_1.DatabaseError;
}
});
var serializer_1 = require_serializer();
Object.defineProperty(exports, "serialize", {
enumerable: true,
get: function() {
return serializer_1.serialize;
}
});
var parser_1 = require_parser();
function parse(stream, callback) {
const parser = new parser_1.Parser();
stream.on("data", (buffer) => parser.parse(buffer, callback));
return new Promise((resolve) => stream.on("end", () => resolve()));
}
exports.parse = parse;
}));
//#endregion
//#region browser-external:net
var require_browser_external_net = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = Object.create(new Proxy({}, { get(_, key) {
if (key !== "__esModule" && key !== "__proto__" && key !== "constructor" && key !== "splice") console.warn(`Module "net" has been externalized for browser compatibility. Cannot access "net.${key}" in client code. See https://vite.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.`);
} }));
}));
//#endregion
//#region browser-external:tls
var require_browser_external_tls = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = Object.create(new Proxy({}, { get(_, key) {
if (key !== "__esModule" && key !== "__proto__" && key !== "constructor" && key !== "splice") console.warn(`Module "tls" has been externalized for browser compatibility. Cannot access "tls.${key}" in client code. See https://vite.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.`);
} }));
}));
//#endregion
//#region ../../node_modules/pg-cloudflare/dist/empty.js
var require_empty = /* @__PURE__ */ __commonJSMin(((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = {};
}));
//#endregion
//#region ../../node_modules/pg/lib/stream.js
var require_stream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var { getStream, getSecureStream } = getStreamFuncs();
module.exports = {
/**
* Get a socket stream compatible with the current runtime environment.
* @returns {Duplex}
*/
getStream,
/**
* Get a TLS secured socket, compatible with the current environment,
* using the socket and other settings given in `options`.
* @returns {Duplex}
*/
getSecureStream
};
/**
* The stream functions that work in Node.js
*/
function getNodejsStreamFuncs() {
function getStream(ssl) {
return new (require_browser_external_net()).Socket();
}
function getSecureStream(options) {
return require_browser_external_tls().connect(options);
}
return {
getStream,
getSecureStream
};
}
/**
* The stream functions that work in Cloudflare Workers
*/
function getCloudflareStreamFuncs() {
function getStream(ssl) {
const { CloudflareSocket } = require_empty();
return new CloudflareSocket(ssl);
}
function getSecureStream(options) {
options.socket.startTls(options);
return options.socket;
}
return {
getStream,
getSecureStream
};
}
/**
* Are we running in a Cloudflare Worker?
*
* @returns true if the code is currently running inside a Cloudflare Worker.
*/
function isCloudflareRuntime() {
if (typeof navigator === "object" && navigator !== null && typeof navigator.userAgent === "string") return navigator.userAgent === "Cloudflare-Workers";
if (typeof Response === "function") {
const resp = new Response(null, { cf: { thing: true } });
if (typeof resp.cf === "object" && resp.cf !== null && resp.cf.thing) return true;
}
return false;
}
function getStreamFuncs() {
if (isCloudflareRuntime()) return getCloudflareStreamFuncs();
return getNodejsStreamFuncs();
}
}));
//#endregion
//#region ../../node_modules/pg/lib/connection.js
var require_connection = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var EventEmitter = require_events().EventEmitter;
var { parse, serialize } = require_dist();
var { getStream, getSecureStream } = require_stream();
var flushBuffer = serialize.flush();
var syncBuffer = serialize.sync();
var endBuffer = serialize.end();
var Connection = class extends EventEmitter {
constructor(config) {
super();
config = config || {};
this.stream = config.stream || getStream(config.ssl);
if (typeof this.stream === "function") this.stream = this.stream(config);
this._keepAlive = config.keepAlive;
this._keepAliveInitialDelayMillis = config.keepAliveInitialDelayMillis;
this.lastBuffer = false;
this.parsedStatements = {};
this.ssl = config.ssl || false;
this._ending = false;
this._emitMessage = false;
const self = this;
this.on("newListener", function(eventName) {
if (eventName === "message") self._emitMessage = true;
});
}
connect(port, host) {
const self = this;
this._connecting = true;
this.stream.setNoDelay(true);
this.stream.connect(port, host);
this.stream.once("connect", function() {
if (self._keepAlive) self.stream.setKeepAlive(true, self._keepAliveInitialDelayMillis);
self.emit("connect");
});
const reportStreamError = function(error) {
if (self._ending && (error.code === "ECONNRESET" || error.code === "EPIPE")) return;
self.emit("error", error);
};
this.stream.on("error", reportStreamError);
this.stream.on("close", function() {
self.emit("end");
});
if (!this.ssl) return this.attachListeners(this.stream);
this.stream.once("data", function(buffer) {
switch (buffer.toString("utf8")) {
case "S": break;
case "N":
self.stream.end();
return self.emit("error", /* @__PURE__ */ new Error("The server does not support SSL connections"));
default:
self.stream.end();
return self.emit("error", /* @__PURE__ */ new Error("There was an error establishing an SSL connection"));
}
const options = { socket: self.stream };
if (self.ssl !== true) {
Object.assign(options, self.ssl);
if ("key" in self.ssl) options.key = self.ssl.key;
}
const net = require_browser_external_net();
if (net.isIP && net.isIP(host) === 0) options.servername = host;
try {
self.stream = getSecureStream(options);
} catch (err) {
return self.emit("error", err);
}
self.attachListeners(self.stream);
self.stream.on("error", reportStreamError);
self.emit("sslconnect");
});
}
attachListeners(stream) {
parse(stream, (msg) => {
const eventName = msg.name === "error" ? "errorMessage" : msg.name;
if (this._emitMessage) this.emit("message", msg);
this.emit(eventName, msg);
});
}
requestSsl() {
this.stream.write(serialize.requestSsl());
}
startup(config) {
this.stream.write(serialize.startup(config));
}
cancel(processID, secretKey) {
this._send(serialize.cancel(processID, secretKey));
}
password(password) {
this._send(serialize.password(password));
}
sendSASLInitialResponseMessage(mechanism, initialResponse) {
this._send(serialize.sendSASLInitialResponseMessage(mechanism, initialResponse));
}
sendSCRAMClientFinalMessage(additionalData) {
this._send(serialize.sendSCRAMClientFinalMessage(additionalData));
}
_send(buffer) {
if (!this.stream.writable) return false;
return this.stream.write(buffer);
}
query(text) {
this._send(serialize.query(text));
}
parse(query) {
this._send(serialize.parse(query));
}
bind(config) {
this._send(serialize.bind(config));
}
execute(config) {
this._send(serialize.execute(config));
}
flush() {
if (this.stream.writable) this.stream.write(flushBuffer);
}
sync() {
this._ending = true;
this._send(syncBuffer);
}
ref() {
this.stream.ref();
}
unref() {
this.stream.unref();
}
end() {
this._ending = true;
if (!this._connecting || !this.stream.writable) {
this.stream.end();
return;
}
return this.stream.write(endBuffer, () => {
this.stream.end();
});
}
close(msg) {
this._send(serialize.close(msg));
}
describe(msg) {
this._send(serialize.describe(msg));
}
sendCopyFromChunk(chunk) {
this._send(serialize.copyData(chunk));
}
endCopyFrom() {
this._send(serialize.copyDone());
}
sendCopyFail(msg) {
this._send(serialize.copyFail(msg));
}
};
module.exports = Connection;
}));
//#endregion
//#region ../../node_modules/base64-js/index.js
var require_base64_js = /* @__PURE__ */ __commonJSMin(((exports) => {
exports.byteLength = byteLength;
exports.toByteArray = toByteArray;
exports.fromByteArray = fromByteArray;
var lookup = [];
var revLookup = [];
var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
for (var i = 0, len = code.length; i < len; ++i) {
lookup[i] = code[i];
revLookup[code.charCodeAt(i)] = i;
}
revLookup["-".charCodeAt(0)] = 62;
revLookup["_".charCodeAt(0)] = 63;
function getLens(b64) {
var len = b64.length;
if (len % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
var validLen = b64.indexOf("=");
if (validLen === -1) validLen = len;
var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
return [validLen, placeHoldersLen];
}
function byteLength(b64) {
var lens = getLens(b64);
var validLen = lens[0];
var placeHoldersLen = lens[1];
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
}
function _byteLength(b64, validLen, placeHoldersLen) {
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
}
function toByteArray(b64) {
var tmp;
var lens = getLens(b64);
var validLen = lens[0];
var placeHoldersLen = lens[1];
var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
var curByte = 0;
var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
var i;
for (i = 0; i < len; i += 4) {
tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
arr[curByte++] = tmp >> 16 & 255;
arr[curByte++] = tmp >> 8 & 255;
arr[curByte++] = tmp & 255;
}
if (placeHoldersLen === 2) {
tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
arr[curByte++] = tmp & 255;
}
if (placeHoldersLen === 1) {
tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;
arr[curByte++] = tmp >> 8 & 255;
arr[curByte++] = tmp & 255;
}
return arr;
}
function tripletToBase64(num) {
return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
}
function encodeChunk(uint8, start, end) {
var tmp;
var output = [];
for (var i = start; i < end; i += 3) {
tmp = (uint8[i] << 16 & 16711680) + (uint8[i + 1] << 8 & 65280) + (uint8[i + 2] & 255);
output.push(tripletToBase64(tmp));
}
return output.join("");
}
function fromByteArray(uint8) {
var tmp;
var len = uint8.length;
var extraBytes = len % 3;
var parts = [];
var maxChunkLength = 16383;
for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
if (extraBytes === 1) {
tmp = uint8[len - 1];
parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
} else if (extraBytes === 2) {
tmp = (uint8[len - 2] << 8) + uint8[len - 1];
parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
}
return parts.join("");
}
}));
//#endregion
//#region ../../node_modules/ieee754/index.js
var require_ieee754 = /* @__PURE__ */ __commonJSMin(((exports) => {
/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
exports.read = function(buffer, offset, isLE, mLen, nBytes) {
var e, m;
var eLen = nBytes * 8 - mLen - 1;
var eMax = (1 << eLen) - 1;
var eBias = eMax >> 1;
var nBits = -7;
var i = isLE ? nBytes - 1 : 0;
var d = isLE ? -1 : 1;
var s = buffer[offset + i];
i += d;
e = s & (1 << -nBits) - 1;
s >>= -nBits;
nBits += eLen;
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
m = e & (1 << -nBits) - 1;
e >>= -nBits;
nBits += mLen;
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
if (e === 0) e = 1 - eBias;
else if (e === eMax) return m ? NaN : (s ? -1 : 1) * Infinity;
else {
m = m + Math.pow(2, mLen);
e = e - eBias;
}
return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
};
exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
var e, m, c;
var eLen = nBytes * 8 - mLen - 1;
var eMax = (1 << eLen) - 1;
var eBias = eMax >> 1;
var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
var i = isLE ? 0 : nBytes - 1;
var d = isLE ? 1 : -1;
var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
value = Math.abs(value);
if (isNaN(value) || value === Infinity) {
m = isNaN(value) ? 1 : 0;
e = eMax;
} else {
e = Math.floor(Math.log(value) / Math.LN2);
if (value * (c = Math.pow(2, -e)) < 1) {
e--;
c *= 2;
}
if (e + eBias >= 1) value += rt / c;
else value += rt * Math.pow(2, 1 - eBias);
if (value * c >= 2) {
e++;
c /= 2;
}
if (e + eBias >= eMax) {
m = 0;
e = eMax;
} else if (e + eBias >= 1) {
m = (value * c - 1) * Math.pow(2, mLen);
e = e + eBias;
} else {
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
e = 0;
}
}
for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8);
e = e << mLen | m;
eLen += mLen;
for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8);
buffer[offset + i - d] |= s * 128;
};
}));
//#endregion
//#region ../../node_modules/buffer/index.js
/*!
* The buffer module from node.js, for the browser.
*
* @author Feross Aboukhadijeh <https://feross.org>
* @license MIT
*/
var require_buffer = /* @__PURE__ */ __commonJSMin(((exports) => {
var base64 = require_base64_js();
var ieee754 = require_ieee754();
var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
exports.Buffer = Buffer;
exports.SlowBuffer = SlowBuffer;
exports.INSPECT_MAX_BYTES = 50;
var K_MAX_LENGTH = 2147483647;
exports.kMaxLength = K_MAX_LENGTH;
/**
* If `Buffer.TYPED_ARRAY_SUPPORT`:
* === true Use Uint8Array implementation (fastest)
* === false Print warning and recommend using `buffer` v4.x which has an Object
* implementation (most compatible, even IE6)
*
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
* Opera 11.6+, iOS 4.2+.
*
* We report that the browser does not support typed arrays if the are not subclassable
* using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
* (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
* for __proto__ and has a buggy typed array implementation.
*/
Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport();
if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
function typedArraySupport() {
try {
var arr = new Uint8Array(1);
var proto = { foo: function() {
return 42;
} };
Object.setPrototypeOf(proto, Uint8Array.prototype);
Object.setPrototypeOf(arr, proto);
return arr.foo() === 42;
} catch (e) {
return false;
}
}
Object.defineProperty(Buffer.prototype, "parent", {
enumerable: true,
get: function() {
if (!Buffer.isBuffer(this)) return void 0;
return this.buffer;
}
});
Object.defineProperty(Buffer.prototype, "offset", {
enumerable: true,
get: function() {
if (!Buffer.isBuffer(this)) return void 0;
return this.byteOffset;
}
});
function createBuffer(length) {
if (length > K_MAX_LENGTH) throw new RangeError("The value \"" + length + "\" is invalid for option \"size\"");
var buf = new Uint8Array(length);
Object.setPrototypeOf(buf, Buffer.prototype);
return buf;
}
/**
* The Buffer constructor returns instances of `Uint8Array` that have their
* prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
* `Uint8Array`, so the returned instances will have all the node `Buffer` methods
* and the `Uint8Array` methods. Square bracket notation works as expected -- it
* returns a single octet.
*
* The `Uint8Array` prototype remains unmodified.
*/
function Buffer(arg, encodingOrOffset, length) {
if (typeof arg === "number") {
if (typeof encodingOrOffset === "string") throw new TypeError("The \"string\" argument must be of type string. Received type number");
return allocUnsafe(arg);
}
return from(arg, encodingOrOffset, length);
}
Buffer.poolSize = 8192;
function from(value, encodingOrOffset, length) {
if (typeof value === "string") return fromString(value, encodingOrOffset);
if (ArrayBuffer.isView(value)) return fromArrayView(value);
if (value == null) throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) return fromArrayBuffer(value, encodingOrOffset, length);
if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) return fromArrayBuffer(value, encodingOrOffset, length);
if (typeof value === "number") throw new TypeError("The \"value\" argument must not be of type number. Received type number");
var valueOf = value.valueOf && value.valueOf();
if (valueOf != null && valueOf !== value) return Buffer.from(valueOf, encodingOrOffset, length);
var b = fromObject(value);
if (b) return b;
if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") return Buffer.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
}
/**
* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
* if value is a number.
* Buffer.from(str[, encoding])
* Buffer.from(array)
* Buffer.from(buffer)
* Buffer.from(arrayBuffer[, byteOffset[, length]])
**/
Buffer.from = function(value, encodingOrOffset, length) {
return from(value, encodingOrOffset, length);
};
Object.setPrototypeOf(Buffer.prototype, Uint8Array.prototype);
Object.setPrototypeOf(Buffer, Uint8Array);
function assertSize(size) {
if (typeof size !== "number") throw new TypeError("\"size\" argument must be of type number");
else if (size < 0) throw new RangeError("The value \"" + size + "\" is invalid for option \"size\"");
}
function alloc(size, fill, encoding) {
assertSize(size);
if (size <= 0) return createBuffer(size);
if (fill !== void 0) return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
return createBuffer(size);
}
/**
* Creates a new filled Buffer instance.
* alloc(size[, fill[, encoding]])
**/
Buffer.alloc = function(size, fill, encoding) {
return alloc(size, fill, encoding);
};
function allocUnsafe(size) {
assertSize(size);
return createBuffer(size < 0 ? 0 : checked(size) | 0);
}
/**
* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
* */
Buffer.allocUnsafe = function(size) {
return allocUnsafe(size);
};
/**
* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
*/
Buffer.allocUnsafeSlow = function(size) {
return allocUnsafe(size);
};
function fromString(string, encoding) {
if (typeof encoding !== "string" || encoding === "") encoding = "utf8";
if (!Buffer.isEncoding(encoding)) throw new TypeError("Unknown encoding: " + encoding);
var length = byteLength(string, encoding) | 0;
var buf = createBuffer(length);
var actual = buf.write(string, encoding);
if (actual !== length) buf = buf.slice(0, actual);
return buf;
}
function fromArrayLike(array) {
var length = array.length < 0 ? 0 : checked(array.length) | 0;
var buf = createBuffer(length);
for (var i = 0; i < length; i += 1) buf[i] = array[i] & 255;
return buf;
}
function fromArrayView(arrayView) {
if (isInstance(arrayView, Uint8Array)) {
var copy = new Uint8Array(arrayView);
return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
}
return fromArrayLike(arrayView);
}
function fromArrayBuffer(array, byteOffset, length) {
if (byteOffset < 0 || array.byteLength < byteOffset) throw new RangeError("\"offset\" is outside of buffer bounds");
if (array.byteLength < byteOffset + (length || 0)) throw new RangeError("\"length\" is outside of buffer bounds");
var buf;
if (byteOffset === void 0 && length === void 0) buf = new Uint8Array(array);
else if (length === void 0) buf = new Uint8Array(array, byteOffset);
else buf = new Uint8Array(array, byteOffset, length);
Object.setPrototypeOf(buf, Buffer.prototype);
return buf;
}
function fromObject(obj) {
if (Buffer.isBuffer(obj)) {
var len = checked(obj.length) | 0;
var buf = createBuffer(len);
if (buf.length === 0) return buf;
obj.copy(buf, 0, 0, len);
return buf;
}
if (obj.length !== void 0) {
if (typeof obj.length !== "number" || numberIsNaN(obj.length)) return createBuffer(0);
return fromArrayLike(obj);
}
if (obj.type === "Buffer" && Array.isArray(obj.data)) return fromArrayLike(obj.data);
}
function checked(length) {
if (length >= K_MAX_LENGTH) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
return length | 0;
}
function SlowBuffer(length) {
if (+length != length) length = 0;
return Buffer.alloc(+length);
}
Buffer.isBuffer = function isBuffer(b) {
return b != null && b._isBuffer === true && b !== Buffer.prototype;
};
Buffer.compare = function compare(a, b) {
if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength);
if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength);
if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) throw new TypeError("The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array");
if (a === b) return 0;
var x = a.length;
var y = b.length;
for (var i = 0, len = Math.min(x, y); i < len; ++i) if (a[i] !== b[i]) {
x = a[i];
y = b[i];
break;
}
if (x < y) return -1;
if (y < x) return 1;
return 0;
};
Buffer.isEncoding = function isEncoding(encoding) {
switch (String(encoding).toLowerCase()) {
case "hex":
case "utf8":
case "utf-8":
case "ascii":
case "latin1":
case "binary":
case "base64":
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le": return true;
default: return false;
}
};
Buffer.concat = function concat(list, length) {
if (!Array.isArray(list)) throw new TypeError("\"list\" argument must be an Array of Buffers");
if (list.length === 0) return Buffer.alloc(0);
var i;
if (length === void 0) {
length = 0;
for (i = 0; i < list.length; ++i) length += list[i].length;
}
var buffer = Buffer.allocUnsafe(length);
var pos = 0;
for (i = 0; i < list.length; ++i) {
var buf = list[i];
if (isInstance(buf, Uint8Array)) if (pos + buf.length > buffer.length) Buffer.from(buf).copy(buffer, pos);
else Uint8Array.prototype.set.call(buffer, buf, pos);
else if (!Buffer.isBuffer(buf)) throw new TypeError("\"list\" argument must be an Array of Buffers");
else buf.copy(buffer, pos);
pos += buf.length;
}
return buffer;
};
function byteLength(string, encoding) {
if (Buffer.isBuffer(string)) return string.length;
if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) return string.byteLength;
if (typeof string !== "string") throw new TypeError("The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. Received type " + typeof string);
var len = string.length;
var mustMatch = arguments.length > 2 && arguments[2] === true;
if (!mustMatch && len === 0) return 0;
var loweredCase = false;
for (;;) switch (encoding) {
case "ascii":
case "latin1":
case "binary": return len;
case "utf8":
case "utf-8": return utf8ToBytes(string).length;
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le": return len * 2;
case "hex": return len >>> 1;
case "base64": return base64ToBytes(string).length;
default:
if (loweredCase) return mustMatch ? -1 : utf8ToBytes(string).length;
encoding = ("" + encoding).toLowerCase();
loweredCase = true;
}
}
Buffer.byteLength = byteLength;
function slowToString(encoding, start, end) {
var loweredCase = false;
if (start === void 0 || start < 0) start = 0;
if (start > this.length) return "";
if (end === void 0 || end > this.length) end = this.length;
if (end <= 0) return "";
end >>>= 0;
start >>>= 0;
if (end <= start) return "";
if (!encoding) encoding = "utf8";
while (true) switch (encoding) {
case "hex": return hexSlice(this, start, end);
case "utf8":
case "utf-8": return utf8Slice(this, start, end);
case "ascii": return asciiSlice(this, start, end);
case "latin1":
case "binary": return latin1Slice(this, start, end);
case "base64": return base64Slice(this, start, end);
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le": return utf16leSlice(this, start, end);
default:
if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
encoding = (encoding + "").toLowerCase();
loweredCase = true;
}
}
Buffer.prototype._isBuffer = true;
function swap(b, n, m) {
var i = b[n];
b[n] = b[m];
b[m] = i;
}
Buffer.prototype.swap16 = function swap16() {
var len = this.length;
if (len % 2 !== 0) throw new RangeError("Buffer size must be a multiple of 16-bits");
for (var i = 0; i < len; i += 2) swap(this, i, i + 1);
return this;
};
Buffer.prototype.swap32 = function swap32() {
var len = this.length;
if (len % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
for (var i = 0; i < len; i += 4) {
swap(this, i, i + 3);
swap(this, i + 1, i + 2);
}
return this;
};
Buffer.prototype.swap64 = function swap64() {
var len = this.length;
if (len % 8 !== 0) throw new RangeError("Buffer size must be a multiple of 64-bits");
for (var i = 0; i < len; i += 8) {
swap(this, i, i + 7);
swap(this, i + 1, i + 6);
swap(this, i + 2, i + 5);
swap(this, i + 3, i + 4);
}
return this;
};
Buffer.prototype.toString = function toString() {
var length = this.length;
if (length === 0) return "";
if (arguments.length === 0) return utf8Slice(this, 0, length);
return slowToString.apply(this, arguments);
};
Buffer.prototype.toLocaleString = Buffer.prototype.toString;
Buffer.prototype.equals = function equals(b) {
if (!Buffer.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
if (this === b) return true;
return Buffer.compare(this, b) === 0;
};
Buffer.prototype.inspect = function inspect() {
var str = "";
var max = exports.INSPECT_MAX_BYTES;
str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
if (this.length > max) str += " ... ";
return "<Buffer " + str + ">";
};
if (customInspectSymbol) Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect;
Buffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
if (isInstance(target, Uint8Array)) target = Buffer.from(target, target.offset, target.byteLength);
if (!Buffer.isBuffer(target)) throw new TypeError("The \"target\" argument must be one of type Buffer or Uint8Array. Received type " + typeof target);
if (start === void 0) start = 0;
if (end === void 0) end = target ? target.length : 0;
if (thisStart === void 0) thisStart = 0;
if (thisEnd === void 0) thisEnd = this.length;
if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) throw new RangeError("out of range index");
if (thisStart >= thisEnd && start >= end) return 0;
if (thisStart >= thisEnd) return -1;
if (start >= end) return 1;
start >>>= 0;
end >>>= 0;
thisStart >>>= 0;
thisEnd >>>= 0;
if (this === target) return 0;
var x = thisEnd - thisStart;
var y = end - start;
var len = Math.min(x, y);
var thisCopy = this.slice(thisStart, thisEnd);
var targetCopy = target.slice(start, end);
for (var i = 0; i < len; ++i) if (thisCopy[i] !== targetCopy[i]) {
x = thisCopy[i];
y = targetCopy[i];
break;
}
if (x < y) return -1;
if (y < x) return 1;
return 0;
};
function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
if (buffer.length === 0) return -1;
if (typeof byteOffset === "string") {
encoding = byteOffset;
byteOffset = 0;
} else if (byteOffset > 2147483647) byteOffset = 2147483647;
else if (byteOffset < -2147483648) byteOffset = -2147483648;
byteOffset = +byteOffset;
if (numberIsNaN(byteOffset)) byteOffset = dir ? 0 : buffer.length - 1;
if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
if (byteOffset >= buffer.length) if (dir) return -1;
else byteOffset = buffer.length - 1;
else if (byteOffset < 0) if (dir) byteOffset = 0;
else return -1;
if (typeof val === "string") val = Buffer.from(val, encoding);
if (Buffer.isBuffer(val)) {
if (val.length === 0) return -1;
return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
} else if (typeof val === "number") {
val = val & 255;
if (typeof Uint8Array.prototype.indexOf === "function") if (dir) return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
else return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
}
throw new TypeError("val must be string, number or Buffer");
}
function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
var indexSize = 1;
var arrLength = arr.length;
var valLength = val.length;
if (encoding !== void 0) {
encoding = String(encoding).toLowerCase();
if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
if (arr.length < 2 || val.length < 2) return -1;
indexSize = 2;
arrLength /= 2;
valLength /= 2;
byteOffset /= 2;
}
}
function read(buf, i) {
if (indexSize === 1) return buf[i];
else return buf.readUInt16BE(i * indexSize);
}
var i;
if (dir) {
var foundIndex = -1;
for (i = byteOffset; i < arrLength; i++) if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
if (foundIndex === -1) foundIndex = i;
if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;
} else {
if (foundIndex !== -1) i -= i - foundIndex;
foundIndex = -1;
}
} else {
if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
for (i = byteOffset; i >= 0; i--) {
var found = true;
for (var j = 0; j < valLength; j++) if (read(arr, i + j) !== read(val, j)) {
found = false;
break;
}
if (found) return i;
}
}
return -1;
}
Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
return this.indexOf(val, byteOffset, encoding) !== -1;
};
Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
};
Buffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
};
function hexWrite(buf, string, offset, length) {
offset = Number(offset) || 0;
var remaining = buf.length - offset;
if (!length) length = remaining;
else {
length = Number(length);
if (length > remaining) length = remaining;
}
var strLen = string.length;
if (length > strLen / 2) length = strLen / 2;
for (var i = 0; i < length; ++i) {
var parsed = parseInt(string.substr(i * 2, 2), 16);
if (numberIsNaN(parsed)) return i;
buf[offset + i] = parsed;
}
return i;
}
function utf8Write(buf, string, offset, length) {
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
}
function asciiWrite(buf, string, offset, length) {
return blitBuffer(asciiToBytes(string), buf, offset, length);
}
function base64Write(buf, string, offset, length) {
return blitBuffer(base64ToBytes(string), buf, offset, length);
}
function ucs2Write(buf, string, offset, length) {
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
}
Buffer.prototype.write = function write(string, offset, length, encoding) {
if (offset === void 0) {
encoding = "utf8";
length = this.length;
offset = 0;
} else if (length === void 0 && typeof offset === "string") {
encoding = offset;
length = this.length;
offset = 0;
} else if (isFinite(offset)) {
offset = offset >>> 0;
if (isFinite(length)) {
length = length >>> 0;
if (encoding === void 0) encoding = "utf8";
} else {
encoding = length;
length = void 0;
}
} else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
var remaining = this.length - offset;
if (length === void 0 || length > remaining) length = remaining;
if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) throw new RangeError("Attempt to write outside buffer bounds");
if (!encoding) encoding = "utf8";
var loweredCase = false;
for (;;) switch (encoding) {
case "hex": return hexWrite(this, string, offset, length);
case "utf8":
case "utf-8": return utf8Write(this, string, offset, length);
case "ascii":
case "latin1":
case "binary": return asciiWrite(this, string, offset, length);
case "base64": return base64Write(this, string, offset, length);
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le": return ucs2Write(this, string, offset, length);
default:
if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
encoding = ("" + encoding).toLowerCase();
loweredCase = true;
}
};
Buffer.prototype.toJSON = function toJSON() {
return {
type: "Buffer",
data: Array.prototype.slice.call(this._arr || this, 0)
};
};
function base64Slice(buf, start, end) {
if (start === 0 && end === buf.length) return base64.fromByteArray(buf);
else return base64.fromByteArray(buf.slice(start, end));
}
function utf8Slice(buf, start, end) {
end = Math.min(buf.length, end);
var res = [];
var i = start;
while (i < end) {
var firstByte = buf[i];
var codePoint = null;
var bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
if (i + bytesPerSequence <= end) {
var secondByte, thirdByte, fourthByte, tempCodePoint;
switch (bytesPerSequence) {
case 1:
if (firstByte < 128) codePoint = firstByte;
break;
case 2:
secondByte = buf[i + 1];
if ((secondByte & 192) === 128) {
tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
if (tempCodePoint > 127) codePoint = tempCodePoint;
}
break;
case 3:
secondByte = buf[i + 1];
thirdByte = buf[i + 2];
if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) codePoint = tempCodePoint;
}
break;
case 4:
secondByte = buf[i + 1];
thirdByte = buf[i + 2];
fourthByte = buf[i + 3];
if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
if (tempCodePoint > 65535 && tempCodePoint < 1114112) codePoint = tempCodePoint;
}
}
}
if (codePoint === null) {
codePoint = 65533;
bytesPerSequence = 1;
} else if (codePoint > 65535) {
codePoint -= 65536;
res.push(codePoint >>> 10 & 1023 | 55296);
codePoint = 56320 | codePoint & 1023;
}
res.push(codePoint);
i += bytesPerSequence;
}
return decodeCodePointsArray(res);
}
var MAX_ARGUMENTS_LENGTH = 4096;
function decodeCodePointsArray(codePoints) {
var len = codePoints.length;
if (len <= MAX_ARGUMENTS_LENGTH) return String.fromCharCode.apply(String, codePoints);
var res = "";
var i = 0;
while (i < len) res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
return res;
}
function asciiSlice(buf, start, end) {
var ret = "";
end = Math.min(buf.length, end);
for (var i = start; i < end; ++i) ret += String.fromCharCode(buf[i] & 127);
return ret;
}
function latin1Slice(buf, start, end) {
var ret = "";
end = Math.min(buf.length, end);
for (var i = start; i < end; ++i) ret += String.fromCharCode(buf[i]);
return ret;
}
function hexSlice(buf, start, end) {
var len = buf.length;
if (!start || start < 0) start = 0;
if (!end || end < 0 || end > len) end = len;
var out = "";
for (var i = start; i < end; ++i) out += hexSliceLookupTable[buf[i]];
return out;
}
function utf16leSlice(buf, start, end) {
var bytes = buf.slice(start, end);
var res = "";
for (var i = 0; i < bytes.length - 1; i += 2) res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
return res;
}
Buffer.prototype.slice = function slice(start, end) {
var len = this.length;
start = ~~start;
end = end === void 0 ? len : ~~end;
if (start < 0) {
start += len;
if (start < 0) start = 0;
} else if (start > len) start = len;
if (end < 0) {
end += len;
if (end < 0) end = 0;
} else if (end > len) end = len;
if (end < start) end = start;
var newBuf = this.subarray(start, end);
Object.setPrototypeOf(newBuf, Buffer.prototype);
return newBuf;
};
function checkOffset(offset, ext, length) {
if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
if (offset + ext > length) throw new RangeError("Trying to access beyond buffer length");
}
Buffer.prototype.readUintLE = Buffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) checkOffset(offset, byteLength, this.length);
var val = this[offset];
var mul = 1;
var i = 0;
while (++i < byteLength && (mul *= 256)) val += this[offset + i] * mul;
return val;
};
Buffer.prototype.readUintBE = Buffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) checkOffset(offset, byteLength, this.length);
var val = this[offset + --byteLength];
var mul = 1;
while (byteLength > 0 && (mul *= 256)) val += this[offset + --byteLength] * mul;
return val;
};
Buffer.prototype.readUint8 = Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 1, this.length);
return this[offset];
};
Buffer.prototype.readUint16LE = Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 2, this.length);
return this[offset] | this[offset + 1] << 8;
};
Buffer.prototype.readUint16BE = Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 2, this.length);
return this[offset] << 8 | this[offset + 1];
};
Buffer.prototype.readUint32LE = Buffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 4, this.length);
return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
};
Buffer.prototype.readUint32BE = Buffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 4, this.length);
return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
};
Buffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) checkOffset(offset, byteLength, this.length);
var val = this[offset];
var mul = 1;
var i = 0;
while (++i < byteLength && (mul *= 256)) val += this[offset + i] * mul;
mul *= 128;
if (val >= mul) val -= Math.pow(2, 8 * byteLength);
return val;
};
Buffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) checkOffset(offset, byteLength, this.length);
var i = byteLength;
var mul = 1;
var val = this[offset + --i];
while (i > 0 && (mul *= 256)) val += this[offset + --i] * mul;
mul *= 128;
if (val >= mul) val -= Math.pow(2, 8 * byteLength);
return val;
};
Buffer.prototype.readInt8 = function readInt8(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 1, this.length);
if (!(this[offset] & 128)) return this[offset];
return (255 - this[offset] + 1) * -1;
};
Buffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 2, this.length);
var val = this[offset] | this[offset + 1] << 8;
return val & 32768 ? val | 4294901760 : val;
};
Buffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 2, this.length);
var val = this[offset + 1] | this[offset] << 8;
return val & 32768 ? val | 4294901760 : val;
};
Buffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 4, this.length);
return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
};
Buffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 4, this.length);
return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
};
Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 4, this.length);
return ieee754.read(this, offset, true, 23, 4);
};
Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 4, this.length);
return ieee754.read(this, offset, false, 23, 4);
};
Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 8, this.length);
return ieee754.read(this, offset, true, 52, 8);
};
Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 8, this.length);
return ieee754.read(this, offset, false, 52, 8);
};
function checkInt(buf, value, offset, ext, max, min) {
if (!Buffer.isBuffer(buf)) throw new TypeError("\"buffer\" argument must be a Buffer instance");
if (value > max || value < min) throw new RangeError("\"value\" argument is out of bounds");
if (offset + ext > buf.length) throw new RangeError("Index out of range");
}
Buffer.prototype.writeUintLE = Buffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {
value = +value;
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) {
var maxBytes = Math.pow(2, 8 * byteLength) - 1;
checkInt(this, value, offset, byteLength, maxBytes, 0);
}
var mul = 1;
var i = 0;
this[offset] = value & 255;
while (++i < byteLength && (mul *= 256)) this[offset + i] = value / mul & 255;
return offset + byteLength;
};
Buffer.prototype.writeUintBE = Buffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {
value = +value;
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) {
var maxBytes = Math.pow(2, 8 * byteLength) - 1;
checkInt(this, value, offset, byteLength, maxBytes, 0);
}
var i = byteLength - 1;
var mul = 1;
this[offset + i] = value & 255;
while (--i >= 0 && (mul *= 256)) this[offset + i] = value / mul & 255;
return offset + byteLength;
};
Buffer.prototype.writeUint8 = Buffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
this[offset] = value & 255;
return offset + 1;
};
Buffer.prototype.writeUint16LE = Buffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
this[offset] = value & 255;
this[offset + 1] = value >>> 8;
return offset + 2;
};
Buffer.prototype.writeUint16BE = Buffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
this[offset] = value >>> 8;
this[offset + 1] = value & 255;
return offset + 2;
};
Buffer.prototype.writeUint32LE = Buffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
this[offset + 3] = value >>> 24;
this[offset + 2] = value >>> 16;
this[offset + 1] = value >>> 8;
this[offset] = value & 255;
return offset + 4;
};
Buffer.prototype.writeUint32BE = Buffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
this[offset] = value >>> 24;
this[offset + 1] = value >>> 16;
this[offset + 2] = value >>> 8;
this[offset + 3] = value & 255;
return offset + 4;
};
Buffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) {
var limit = Math.pow(2, 8 * byteLength - 1);
checkInt(this, value, offset, byteLength, limit - 1, -limit);
}
var i = 0;
var mul = 1;
var sub = 0;
this[offset] = value & 255;
while (++i < byteLength && (mul *= 256)) {
if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) sub = 1;
this[offset + i] = (value / mul >> 0) - sub & 255;
}
return offset + byteLength;
};
Buffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) {
var limit = Math.pow(2, 8 * byteLength - 1);
checkInt(this, value, offset, byteLength, limit - 1, -limit);
}
var i = byteLength - 1;
var mul = 1;
var sub = 0;
this[offset + i] = value & 255;
while (--i >= 0 && (mul *= 256)) {
if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) sub = 1;
this[offset + i] = (value / mul >> 0) - sub & 255;
}
return offset + byteLength;
};
Buffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 1, 127, -128);
if (value < 0) value = 255 + value + 1;
this[offset] = value & 255;
return offset + 1;
};
Buffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
this[offset] = value & 255;
this[offset + 1] = value >>> 8;
return offset + 2;
};
Buffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
this[offset] = value >>> 8;
this[offset + 1] = value & 255;
return offset + 2;
};
Buffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
this[offset] = value & 255;
this[offset + 1] = value >>> 8;
this[offset + 2] = value >>> 16;
this[offset + 3] = value >>> 24;
return offset + 4;
};
Buffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
if (value < 0) value = 4294967295 + value + 1;
this[offset] = value >>> 24;
this[offset + 1] = value >>> 16;
this[offset + 2] = value >>> 8;
this[offset + 3] = value & 255;
return offset + 4;
};
function checkIEEE754(buf, value, offset, ext, max, min) {
if (offset + ext > buf.length) throw new RangeError("Index out of range");
if (offset < 0) throw new RangeError("Index out of range");
}
function writeFloat(buf, value, offset, littleEndian, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkIEEE754(buf, value, offset, 4, 34028234663852886e22, -34028234663852886e22);
ieee754.write(buf, value, offset, littleEndian, 23, 4);
return offset + 4;
}
Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
return writeFloat(this, value, offset, true, noAssert);
};
Buffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
return writeFloat(this, value, offset, false, noAssert);
};
function writeDouble(buf, value, offset, littleEndian, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkIEEE754(buf, value, offset, 8, 17976931348623157e292, -17976931348623157e292);
ieee754.write(buf, value, offset, littleEndian, 52, 8);
return offset + 8;
}
Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
return writeDouble(this, value, offset, true, noAssert);
};
Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
return writeDouble(this, value, offset, false, noAssert);
};
Buffer.prototype.copy = function copy(target, targetStart, start, end) {
if (!Buffer.isBuffer(target)) throw new TypeError("argument should be a Buffer");
if (!start) start = 0;
if (!end && end !== 0) end = this.length;
if (targetStart >= target.length) targetStart = target.length;
if (!targetStart) targetStart = 0;
if (end > 0 && end < start) end = start;
if (end === start) return 0;
if (target.length === 0 || this.length === 0) return 0;
if (targetStart < 0) throw new RangeError("targetStart out of bounds");
if (start < 0 || start >= this.length) throw new RangeError("Index out of range");
if (end < 0) throw new RangeError("sourceEnd out of bounds");
if (end > this.length) end = this.length;
if (target.length - targetStart < end - start) end = target.length - targetStart + start;
var len = end - start;
if (this === target && typeof Uint8Array.prototype.copyWithin === "function") this.copyWithin(targetStart, start, end);
else Uint8Array.prototype.set.call(target, this.subarray(start, end), targetStart);
return len;
};
Buffer.prototype.fill = function fill(val, start, end, encoding) {
if (typeof val === "string") {
if (typeof start === "string") {
encoding = start;
start = 0;
end = this.length;
} else if (typeof end === "string") {
encoding = end;
end = this.length;
}
if (encoding !== void 0 && typeof encoding !== "string") throw new TypeError("encoding must be a string");
if (typeof encoding === "string" && !Buffer.isEncoding(encoding)) throw new TypeError("Unknown encoding: " + encoding);
if (val.length === 1) {
var code = val.charCodeAt(0);
if (encoding === "utf8" && code < 128 || encoding === "latin1") val = code;
}
} else if (typeof val === "number") val = val & 255;
else if (typeof val === "boolean") val = Number(val);
if (start < 0 || this.length < start || this.length < end) throw new RangeError("Out of range index");
if (end <= start) return this;
start = start >>> 0;
end = end === void 0 ? this.length : end >>> 0;
if (!val) val = 0;
var i;
if (typeof val === "number") for (i = start; i < end; ++i) this[i] = val;
else {
var bytes = Buffer.isBuffer(val) ? val : Buffer.from(val, encoding);
var len = bytes.length;
if (len === 0) throw new TypeError("The value \"" + val + "\" is invalid for argument \"value\"");
for (i = 0; i < end - start; ++i) this[i + start] = bytes[i % len];
}
return this;
};
var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
function base64clean(str) {
str = str.split("=")[0];
str = str.trim().replace(INVALID_BASE64_RE, "");
if (str.length < 2) return "";
while (str.length % 4 !== 0) str = str + "=";
return str;
}
function utf8ToBytes(string, units) {
units = units || Infinity;
var codePoint;
var length = string.length;
var leadSurrogate = null;
var bytes = [];
for (var i = 0; i < length; ++i) {
codePoint = string.charCodeAt(i);
if (codePoint > 55295 && codePoint < 57344) {
if (!leadSurrogate) {
if (codePoint > 56319) {
if ((units -= 3) > -1) bytes.push(239, 191, 189);
continue;
} else if (i + 1 === length) {
if ((units -= 3) > -1) bytes.push(239, 191, 189);
continue;
}
leadSurrogate = codePoint;
continue;
}
if (codePoint < 56320) {
if ((units -= 3) > -1) bytes.push(239, 191, 189);
leadSurrogate = codePoint;
continue;
}
codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
} else if (leadSurrogate) {
if ((units -= 3) > -1) bytes.push(239, 191, 189);
}
leadSurrogate = null;
if (codePoint < 128) {
if ((units -= 1) < 0) break;
bytes.push(codePoint);
} else if (codePoint < 2048) {
if ((units -= 2) < 0) break;
bytes.push(codePoint >> 6 | 192, codePoint & 63 | 128);
} else if (codePoint < 65536) {
if ((units -= 3) < 0) break;
bytes.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
} else if (codePoint < 1114112) {
if ((units -= 4) < 0) break;
bytes.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
} else throw new Error("Invalid code point");
}
return bytes;
}
function asciiToBytes(str) {
var byteArray = [];
for (var i = 0; i < str.length; ++i) byteArray.push(str.charCodeAt(i) & 255);
return byteArray;
}
function utf16leToBytes(str, units) {
var c, hi, lo;
var byteArray = [];
for (var i = 0; i < str.length; ++i) {
if ((units -= 2) < 0) break;
c = str.charCodeAt(i);
hi = c >> 8;
lo = c % 256;
byteArray.push(lo);
byteArray.push(hi);
}
return byteArray;
}
function base64ToBytes(str) {
return base64.toByteArray(base64clean(str));
}
function blitBuffer(src, dst, offset, length) {
for (var i = 0; i < length; ++i) {
if (i + offset >= dst.length || i >= src.length) break;
dst[i + offset] = src[i];
}
return i;
}
function isInstance(obj, type) {
return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
}
function numberIsNaN(obj) {
return obj !== obj;
}
var hexSliceLookupTable = (function() {
var alphabet = "0123456789abcdef";
var table = new Array(256);
for (var i = 0; i < 16; ++i) {
var i16 = i * 16;
for (var j = 0; j < 16; ++j) table[i16 + j] = alphabet[i] + alphabet[j];
}
return table;
})();
}));
//#endregion
//#region ../../node_modules/safe-buffer/index.js
var require_safe_buffer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
var buffer = require_buffer();
var Buffer = buffer.Buffer;
function copyProps(src, dst) {
for (var key in src) dst[key] = src[key];
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) module.exports = buffer;
else {
copyProps(buffer, exports);
exports.Buffer = SafeBuffer;
}
function SafeBuffer(arg, encodingOrOffset, length) {
return Buffer(arg, encodingOrOffset, length);
}
SafeBuffer.prototype = Object.create(Buffer.prototype);
copyProps(Buffer, SafeBuffer);
SafeBuffer.from = function(arg, encodingOrOffset, length) {
if (typeof arg === "number") throw new TypeError("Argument must not be a number");
return Buffer(arg, encodingOrOffset, length);
};
SafeBuffer.alloc = function(size, fill, encoding) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
var buf = Buffer(size);
if (fill !== void 0) if (typeof encoding === "string") buf.fill(fill, encoding);
else buf.fill(fill);
else buf.fill(0);
return buf;
};
SafeBuffer.allocUnsafe = function(size) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
return Buffer(size);
};
SafeBuffer.allocUnsafeSlow = function(size) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
return buffer.SlowBuffer(size);
};
}));
//#endregion
//#region ../../node_modules/string_decoder/lib/string_decoder.js
var require_string_decoder = /* @__PURE__ */ __commonJSMin(((exports) => {
var Buffer = require_safe_buffer().Buffer;
var isEncoding = Buffer.isEncoding || function(encoding) {
encoding = "" + encoding;
switch (encoding && encoding.toLowerCase()) {
case "hex":
case "utf8":
case "utf-8":
case "ascii":
case "binary":
case "base64":
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le":
case "raw": return true;
default: return false;
}
};
function _normalizeEncoding(enc) {
if (!enc) return "utf8";
var retried;
while (true) switch (enc) {
case "utf8":
case "utf-8": return "utf8";
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le": return "utf16le";
case "latin1":
case "binary": return "latin1";
case "base64":
case "ascii":
case "hex": return enc;
default:
if (retried) return;
enc = ("" + enc).toLowerCase();
retried = true;
}
}
function normalizeEncoding(enc) {
var nenc = _normalizeEncoding(enc);
if (typeof nenc !== "string" && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
return nenc || enc;
}
exports.StringDecoder = StringDecoder;
function StringDecoder(encoding) {
this.encoding = normalizeEncoding(encoding);
var nb;
switch (this.encoding) {
case "utf16le":
this.text = utf16Text;
this.end = utf16End;
nb = 4;
break;
case "utf8":
this.fillLast = utf8FillLast;
nb = 4;
break;
case "base64":
this.text = base64Text;
this.end = base64End;
nb = 3;
break;
default:
this.write = simpleWrite;
this.end = simpleEnd;
return;
}
this.lastNeed = 0;
this.lastTotal = 0;
this.lastChar = Buffer.allocUnsafe(nb);
}
StringDecoder.prototype.write = function(buf) {
if (buf.length === 0) return "";
var r;
var i;
if (this.lastNeed) {
r = this.fillLast(buf);
if (r === void 0) return "";
i = this.lastNeed;
this.lastNeed = 0;
} else i = 0;
if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
return r || "";
};
StringDecoder.prototype.end = utf8End;
StringDecoder.prototype.text = utf8Text;
StringDecoder.prototype.fillLast = function(buf) {
if (this.lastNeed <= buf.length) {
buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
return this.lastChar.toString(this.encoding, 0, this.lastTotal);
}
buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
this.lastNeed -= buf.length;
};
function utf8CheckByte(byte) {
if (byte <= 127) return 0;
else if (byte >> 5 === 6) return 2;
else if (byte >> 4 === 14) return 3;
else if (byte >> 3 === 30) return 4;
return byte >> 6 === 2 ? -1 : -2;
}
function utf8CheckIncomplete(self, buf, i) {
var j = buf.length - 1;
if (j < i) return 0;
var nb = utf8CheckByte(buf[j]);
if (nb >= 0) {
if (nb > 0) self.lastNeed = nb - 1;
return nb;
}
if (--j < i || nb === -2) return 0;
nb = utf8CheckByte(buf[j]);
if (nb >= 0) {
if (nb > 0) self.lastNeed = nb - 2;
return nb;
}
if (--j < i || nb === -2) return 0;
nb = utf8CheckByte(buf[j]);
if (nb >= 0) {
if (nb > 0) if (nb === 2) nb = 0;
else self.lastNeed = nb - 3;
return nb;
}
return 0;
}
function utf8CheckExtraBytes(self, buf, p) {
if ((buf[0] & 192) !== 128) {
self.lastNeed = 0;
return "�";
}
if (self.lastNeed > 1 && buf.length > 1) {
if ((buf[1] & 192) !== 128) {
self.lastNeed = 1;
return "�";
}
if (self.lastNeed > 2 && buf.length > 2) {
if ((buf[2] & 192) !== 128) {
self.lastNeed = 2;
return "�";
}
}
}
}
function utf8FillLast(buf) {
var p = this.lastTotal - this.lastNeed;
var r = utf8CheckExtraBytes(this, buf, p);
if (r !== void 0) return r;
if (this.lastNeed <= buf.length) {
buf.copy(this.lastChar, p, 0, this.lastNeed);
return this.lastChar.toString(this.encoding, 0, this.lastTotal);
}
buf.copy(this.lastChar, p, 0, buf.length);
this.lastNeed -= buf.length;
}
function utf8Text(buf, i) {
var total = utf8CheckIncomplete(this, buf, i);
if (!this.lastNeed) return buf.toString("utf8", i);
this.lastTotal = total;
var end = buf.length - (total - this.lastNeed);
buf.copy(this.lastChar, 0, end);
return buf.toString("utf8", i, end);
}
function utf8End(buf) {
var r = buf && buf.length ? this.write(buf) : "";
if (this.lastNeed) return r + "�";
return r;
}
function utf16Text(buf, i) {
if ((buf.length - i) % 2 === 0) {
var r = buf.toString("utf16le", i);
if (r) {
var c = r.charCodeAt(r.length - 1);
if (c >= 55296 && c <= 56319) {
this.lastNeed = 2;
this.lastTotal = 4;
this.lastChar[0] = buf[buf.length - 2];
this.lastChar[1] = buf[buf.length - 1];
return r.slice(0, -1);
}
}
return r;
}
this.lastNeed = 1;
this.lastTotal = 2;
this.lastChar[0] = buf[buf.length - 1];
return buf.toString("utf16le", i, buf.length - 1);
}
function utf16End(buf) {
var r = buf && buf.length ? this.write(buf) : "";
if (this.lastNeed) {
var end = this.lastTotal - this.lastNeed;
return r + this.lastChar.toString("utf16le", 0, end);
}
return r;
}
function base64Text(buf, i) {
var n = (buf.length - i) % 3;
if (n === 0) return buf.toString("base64", i);
this.lastNeed = 3 - n;
this.lastTotal = 3;
if (n === 1) this.lastChar[0] = buf[buf.length - 1];
else {
this.lastChar[0] = buf[buf.length - 2];
this.lastChar[1] = buf[buf.length - 1];
}
return buf.toString("base64", i, buf.length - n);
}
function base64End(buf) {
var r = buf && buf.length ? this.write(buf) : "";
if (this.lastNeed) return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
return r;
}
function simpleWrite(buf) {
return buf.toString(this.encoding);
}
function simpleEnd(buf) {
return buf && buf.length ? this.write(buf) : "";
}
}));
//#endregion
//#region ../../node_modules/split2/index.js
var require_split2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var { Transform } = require_browser_external_stream();
var { StringDecoder } = require_string_decoder();
var kLast = Symbol("last");
var kDecoder = Symbol("decoder");
function transform(chunk, enc, cb) {
let list;
if (this.overflow) {
list = this[kDecoder].write(chunk).split(this.matcher);
if (list.length === 1) return cb();
list.shift();
this.overflow = false;
} else {
this[kLast] += this[kDecoder].write(chunk);
list = this[kLast].split(this.matcher);
}
this[kLast] = list.pop();
for (let i = 0; i < list.length; i++) try {
push(this, this.mapper(list[i]));
} catch (error) {
return cb(error);
}
this.overflow = this[kLast].length > this.maxLength;
if (this.overflow && !this.skipOverflow) {
cb(/* @__PURE__ */ new Error("maximum buffer reached"));
return;
}
cb();
}
function flush(cb) {
this[kLast] += this[kDecoder].end();
if (this[kLast]) try {
push(this, this.mapper(this[kLast]));
} catch (error) {
return cb(error);
}
cb();
}
function push(self, val) {
if (val !== void 0) self.push(val);
}
function noop(incoming) {
return incoming;
}
function split(matcher, mapper, options) {
matcher = matcher || /\r?\n/;
mapper = mapper || noop;
options = options || {};
switch (arguments.length) {
case 1:
if (typeof matcher === "function") {
mapper = matcher;
matcher = /\r?\n/;
} else if (typeof matcher === "object" && !(matcher instanceof RegExp) && !matcher[Symbol.split]) {
options = matcher;
matcher = /\r?\n/;
}
break;
case 2: if (typeof matcher === "function") {
options = mapper;
mapper = matcher;
matcher = /\r?\n/;
} else if (typeof mapper === "object") {
options = mapper;
mapper = noop;
}
}
options = Object.assign({}, options);
options.autoDestroy = true;
options.transform = transform;
options.flush = flush;
options.readableObjectMode = true;
const stream = new Transform(options);
stream[kLast] = "";
stream[kDecoder] = new StringDecoder("utf8");
stream.matcher = matcher;
stream.mapper = mapper;
stream.maxLength = options.maxLength;
stream.skipOverflow = options.skipOverflow || false;
stream.overflow = false;
stream._destroy = function(err, cb) {
this._writableState.errorEmitted = false;
cb(err);
};
return stream;
}
module.exports = split;
}));
//#endregion
//#region ../../node_modules/pgpass/lib/helper.js
var require_helper = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var path = require_browser_external_path(), Stream = require_browser_external_stream().Stream, split = require_split2(), util = require_browser_external_util(), defaultPort = 5432, isWin = process.platform === "win32", warnStream = process.stderr;
var S_IRWXG = 56, S_IRWXO = 7, S_IFMT = 61440, S_IFREG = 32768;
function isRegFile(mode) {
return (mode & S_IFMT) == S_IFREG;
}
var fieldNames = [
"host",
"port",
"database",
"user",
"password"
];
var nrOfFields = fieldNames.length;
var passKey = fieldNames[nrOfFields - 1];
function warn() {
if (warnStream instanceof Stream && true === warnStream.writable) {
var args = Array.prototype.slice.call(arguments).concat("\n");
warnStream.write(util.format.apply(util, args));
}
}
Object.defineProperty(module.exports, "isWin", {
get: function() {
return isWin;
},
set: function(val) {
isWin = val;
}
});
module.exports.warnTo = function(stream) {
var old = warnStream;
warnStream = stream;
return old;
};
module.exports.getFileName = function(rawEnv) {
var env = rawEnv || process.env;
return env.PGPASSFILE || (isWin ? path.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path.join(env.HOME || "./", ".pgpass"));
};
module.exports.usePgPass = function(stats, fname) {
if (Object.prototype.hasOwnProperty.call(process.env, "PGPASSWORD")) return false;
if (isWin) return true;
fname = fname || "<unkn>";
if (!isRegFile(stats.mode)) {
warn("WARNING: password file \"%s\" is not a plain file", fname);
return false;
}
if (stats.mode & (S_IRWXG | S_IRWXO)) {
warn("WARNING: password file \"%s\" has group or world access; permissions should be u=rw (0600) or less", fname);
return false;
}
return true;
};
var matcher = module.exports.match = function(connInfo, entry) {
return fieldNames.slice(0, -1).reduce(function(prev, field, idx) {
if (idx == 1) {
if (Number(connInfo[field] || defaultPort) === Number(entry[field])) return prev && true;
}
return prev && (entry[field] === "*" || entry[field] === connInfo[field]);
}, true);
};
module.exports.getPassword = function(connInfo, stream, cb) {
var pass;
var lineStream = stream.pipe(split());
function onLine(line) {
var entry = parseLine(line);
if (entry && isValidEntry(entry) && matcher(connInfo, entry)) {
pass = entry[passKey];
lineStream.end();
}
}
var onEnd = function() {
stream.destroy();
cb(pass);
};
var onErr = function(err) {
stream.destroy();
warn("WARNING: error on reading file: %s", err);
cb(void 0);
};
stream.on("error", onErr);
lineStream.on("data", onLine).on("end", onEnd).on("error", onErr);
};
var parseLine = module.exports.parseLine = function(line) {
if (line.length < 11 || line.match(/^\s+#/)) return null;
var curChar = "";
var prevChar = "";
var fieldIdx = 0;
var startIdx = 0;
var obj = {};
var isLastField = false;
var addToObj = function(idx, i0, i1) {
var field = line.substring(i0, i1);
if (!Object.hasOwnProperty.call(process.env, "PGPASS_NO_DEESCAPE")) field = field.replace(/\\([:\\])/g, "$1");
obj[fieldNames[idx]] = field;
};
for (var i = 0; i < line.length - 1; i += 1) {
curChar = line.charAt(i + 1);
prevChar = line.charAt(i);
isLastField = fieldIdx == nrOfFields - 1;
if (isLastField) {
addToObj(fieldIdx, startIdx);
break;
}
if (i >= 0 && curChar == ":" && prevChar !== "\\") {
addToObj(fieldIdx, startIdx, i + 1);
startIdx = i + 2;
fieldIdx += 1;
}
}
obj = Object.keys(obj).length === nrOfFields ? obj : null;
return obj;
};
var isValidEntry = module.exports.isValidEntry = function(entry) {
var rules = {
0: function(x) {
return x.length > 0;
},
1: function(x) {
if (x === "*") return true;
x = Number(x);
return isFinite(x) && x > 0 && x < 9007199254740992 && Math.floor(x) === x;
},
2: function(x) {
return x.length > 0;
},
3: function(x) {
return x.length > 0;
},
4: function(x) {
return x.length > 0;
}
};
for (var idx = 0; idx < fieldNames.length; idx += 1) {
var rule = rules[idx];
if (!rule(entry[fieldNames[idx]] || "")) return false;
}
return true;
};
}));
//#endregion
//#region ../../node_modules/pgpass/lib/index.js
var require_lib$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
require_browser_external_path();
var fs = require_browser_external_fs(), helper = require_helper();
module.exports = function(connInfo, cb) {
var file = helper.getFileName();
fs.stat(file, function(err, stat) {
if (err || !helper.usePgPass(stat, file)) return cb(void 0);
var st = fs.createReadStream(file);
helper.getPassword(connInfo, st, cb);
});
};
module.exports.warnTo = helper.warnTo;
}));
//#endregion
//#region ../../node_modules/pg/lib/client.js
var require_client$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var EventEmitter = require_events().EventEmitter;
var utils = require_utils$1();
var sasl = require_sasl();
var TypeOverrides = require_type_overrides();
var ConnectionParameters = require_connection_parameters();
var Query = require_query$1();
var defaults = require_defaults();
var Connection = require_connection();
var crypto = require_utils();
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 || {};
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.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;
}
_errorAllQueries(err) {
const enqueueError = (query) => {
process.nextTick(() => {
query.handleError(err, this.connection);
});
};
if (this.activeQuery) {
enqueueError(this.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();
});
});
}
_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));
}
_checkPgPass(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$1()(this.connectionParameters, (pass) => {
if (void 0 !== pass) this.connectionParameters.password = this.password = pass;
cb();
});
} catch (e) {
this.emit("error", e);
}
}
_handleAuthCleartextPassword(msg) {
this._checkPgPass(() => {
this.connection.password(this.password);
});
}
_handleAuthMD5Password(msg) {
this._checkPgPass(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._checkPgPass(() => {
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;
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.activeQuery;
if (!activeQuery) {
this._handleErrorEvent(msg);
return;
}
this.activeQuery = null;
activeQuery.handleError(msg, this.connection);
}
_handleRowDescription(msg) {
this.activeQuery.handleRowDescription(msg);
}
_handleDataRow(msg) {
this.activeQuery.handleDataRow(msg);
}
_handlePortalSuspended(msg) {
this.activeQuery.handlePortalSuspended(this.connection);
}
_handleEmptyQuery(msg) {
this.activeQuery.handleEmptyQuery(this.connection);
}
_handleCommandComplete(msg) {
if (this.activeQuery == null) {
const error = /* @__PURE__ */ new Error("Received unexpected commandComplete message from backend.");
this._handleErrorEvent(error);
return;
}
this.activeQuery.handleCommandComplete(msg, this.connection);
}
_handleParseComplete() {
if (this.activeQuery == null) {
const error = /* @__PURE__ */ new Error("Received unexpected parseComplete message from backend.");
this._handleErrorEvent(error);
return;
}
if (this.activeQuery.name) this.connection.parsedStatements[this.activeQuery.name] = this.activeQuery.text;
}
_handleCopyInResponse(msg) {
this.activeQuery.handleCopyInResponse(this.connection);
}
_handleCopyData(msg) {
this.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();
if (this.activeQuery) {
this.readyForQuery = false;
this.hasExecuted = true;
const queryError = this.activeQuery.submit(this.connection);
if (queryError) process.nextTick(() => {
this.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.activeQuery || !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);
});
}
};
Client.Query = Query;
module.exports = Client;
}));
//#endregion
//#region ../../node_modules/pg-pool/index.js
var require_pg_pool = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var EventEmitter = require_events().EventEmitter;
var NOOP = function() {};
var removeWhere = (list, predicate) => {
const i = list.findIndex(predicate);
return i === -1 ? void 0 : list.splice(i, 1)[0];
};
var IdleItem = class {
constructor(client, idleListener, timeoutId) {
this.client = client;
this.idleListener = idleListener;
this.timeoutId = timeoutId;
}
};
var PendingItem = class {
constructor(callback) {
this.callback = callback;
}
};
function throwOnDoubleRelease() {
throw new Error("Release called on client which has already been released to the pool.");
}
function promisify(Promise, callback) {
if (callback) return {
callback,
result: void 0
};
let rej;
let res;
const cb = function(err, client) {
err ? rej(err) : res(client);
};
return {
callback: cb,
result: new Promise(function(resolve, reject) {
res = resolve;
rej = reject;
}).catch((err) => {
Error.captureStackTrace(err);
throw err;
})
};
}
function makeIdleListener(pool, client) {
return function idleListener(err) {
err.client = client;
client.removeListener("error", idleListener);
client.on("error", () => {
pool.log("additional client error after disconnection due to error", err);
});
pool._remove(client);
pool.emit("error", err, client);
};
}
var Pool = class extends EventEmitter {
constructor(options, Client) {
super();
this.options = Object.assign({}, options);
if (options != null && "password" in options) Object.defineProperty(this.options, "password", {
configurable: true,
enumerable: false,
writable: true,
value: options.password
});
if (options != null && options.ssl && options.ssl.key) Object.defineProperty(this.options.ssl, "key", { enumerable: false });
this.options.max = this.options.max || this.options.poolSize || 10;
this.options.min = this.options.min || 0;
this.options.maxUses = this.options.maxUses || Infinity;
this.options.allowExitOnIdle = this.options.allowExitOnIdle || false;
this.options.maxLifetimeSeconds = this.options.maxLifetimeSeconds || 0;
this.log = this.options.log || function() {};
this.Client = this.options.Client || Client || require_lib().Client;
this.Promise = this.options.Promise || global.Promise;
if (typeof this.options.idleTimeoutMillis === "undefined") this.options.idleTimeoutMillis = 1e4;
this._clients = [];
this._idle = [];
this._expired = /* @__PURE__ */ new WeakSet();
this._pendingQueue = [];
this._endCallback = void 0;
this.ending = false;
this.ended = false;
}
_isFull() {
return this._clients.length >= this.options.max;
}
_isAboveMin() {
return this._clients.length > this.options.min;
}
_pulseQueue() {
this.log("pulse queue");
if (this.ended) {
this.log("pulse queue ended");
return;
}
if (this.ending) {
this.log("pulse queue on ending");
if (this._idle.length) this._idle.slice().map((item) => {
this._remove(item.client);
});
if (!this._clients.length) {
this.ended = true;
this._endCallback();
}
return;
}
if (!this._pendingQueue.length) {
this.log("no queued requests");
return;
}
if (!this._idle.length && this._isFull()) return;
const pendingItem = this._pendingQueue.shift();
if (this._idle.length) {
const idleItem = this._idle.pop();
clearTimeout(idleItem.timeoutId);
const client = idleItem.client;
client.ref && client.ref();
const idleListener = idleItem.idleListener;
return this._acquireClient(client, pendingItem, idleListener, false);
}
if (!this._isFull()) return this.newClient(pendingItem);
throw new Error("unexpected condition");
}
_remove(client, callback) {
const removed = removeWhere(this._idle, (item) => item.client === client);
if (removed !== void 0) clearTimeout(removed.timeoutId);
this._clients = this._clients.filter((c) => c !== client);
const context = this;
client.end(() => {
context.emit("remove", client);
if (typeof callback === "function") callback();
});
}
connect(cb) {
if (this.ending) {
const err = /* @__PURE__ */ new Error("Cannot use a pool after calling end on the pool");
return cb ? cb(err) : this.Promise.reject(err);
}
const response = promisify(this.Promise, cb);
const result = response.result;
if (this._isFull() || this._idle.length) {
if (this._idle.length) process.nextTick(() => this._pulseQueue());
if (!this.options.connectionTimeoutMillis) {
this._pendingQueue.push(new PendingItem(response.callback));
return result;
}
const queueCallback = (err, res, done) => {
clearTimeout(tid);
response.callback(err, res, done);
};
const pendingItem = new PendingItem(queueCallback);
const tid = setTimeout(() => {
removeWhere(this._pendingQueue, (i) => i.callback === queueCallback);
pendingItem.timedOut = true;
response.callback(/* @__PURE__ */ new Error("timeout exceeded when trying to connect"));
}, this.options.connectionTimeoutMillis);
if (tid.unref) tid.unref();
this._pendingQueue.push(pendingItem);
return result;
}
this.newClient(new PendingItem(response.callback));
return result;
}
newClient(pendingItem) {
const client = new this.Client(this.options);
this._clients.push(client);
const idleListener = makeIdleListener(this, client);
this.log("checking client timeout");
let tid;
let timeoutHit = false;
if (this.options.connectionTimeoutMillis) tid = setTimeout(() => {
this.log("ending client due to timeout");
timeoutHit = true;
client.connection ? client.connection.stream.destroy() : client.end();
}, this.options.connectionTimeoutMillis);
this.log("connecting new client");
client.connect((err) => {
if (tid) clearTimeout(tid);
client.on("error", idleListener);
if (err) {
this.log("client failed to connect", err);
this._clients = this._clients.filter((c) => c !== client);
if (timeoutHit) err = new Error("Connection terminated due to connection timeout", { cause: err });
this._pulseQueue();
if (!pendingItem.timedOut) pendingItem.callback(err, void 0, NOOP);
} else {
this.log("new client connected");
if (this.options.maxLifetimeSeconds !== 0) {
const maxLifetimeTimeout = setTimeout(() => {
this.log("ending client due to expired lifetime");
this._expired.add(client);
if (this._idle.findIndex((idleItem) => idleItem.client === client) !== -1) this._acquireClient(client, new PendingItem((err, client, clientRelease) => clientRelease()), idleListener, false);
}, this.options.maxLifetimeSeconds * 1e3);
maxLifetimeTimeout.unref();
client.once("end", () => clearTimeout(maxLifetimeTimeout));
}
return this._acquireClient(client, pendingItem, idleListener, true);
}
});
}
_acquireClient(client, pendingItem, idleListener, isNew) {
if (isNew) this.emit("connect", client);
this.emit("acquire", client);
client.release = this._releaseOnce(client, idleListener);
client.removeListener("error", idleListener);
if (!pendingItem.timedOut) if (isNew && this.options.verify) this.options.verify(client, (err) => {
if (err) {
client.release(err);
return pendingItem.callback(err, void 0, NOOP);
}
pendingItem.callback(void 0, client, client.release);
});
else pendingItem.callback(void 0, client, client.release);
else if (isNew && this.options.verify) this.options.verify(client, client.release);
else client.release();
}
_releaseOnce(client, idleListener) {
let released = false;
return (err) => {
if (released) throwOnDoubleRelease();
released = true;
this._release(client, idleListener, err);
};
}
_release(client, idleListener, err) {
client.on("error", idleListener);
client._poolUseCount = (client._poolUseCount || 0) + 1;
this.emit("release", err, client);
if (err || this.ending || !client._queryable || client._ending || client._poolUseCount >= this.options.maxUses) {
if (client._poolUseCount >= this.options.maxUses) this.log("remove expended client");
return this._remove(client, this._pulseQueue.bind(this));
}
if (this._expired.has(client)) {
this.log("remove expired client");
this._expired.delete(client);
return this._remove(client, this._pulseQueue.bind(this));
}
let tid;
if (this.options.idleTimeoutMillis && this._isAboveMin()) {
tid = setTimeout(() => {
this.log("remove idle client");
this._remove(client, this._pulseQueue.bind(this));
}, this.options.idleTimeoutMillis);
if (this.options.allowExitOnIdle) tid.unref();
}
if (this.options.allowExitOnIdle) client.unref();
this._idle.push(new IdleItem(client, idleListener, tid));
this._pulseQueue();
}
query(text, values, cb) {
if (typeof text === "function") {
const response = promisify(this.Promise, text);
setImmediate(function() {
return response.callback(/* @__PURE__ */ new Error("Passing a function as the first parameter to pool.query is not supported"));
});
return response.result;
}
if (typeof values === "function") {
cb = values;
values = void 0;
}
const response = promisify(this.Promise, cb);
cb = response.callback;
this.connect((err, client) => {
if (err) return cb(err);
let clientReleased = false;
const onError = (err) => {
if (clientReleased) return;
clientReleased = true;
client.release(err);
cb(err);
};
client.once("error", onError);
this.log("dispatching query");
try {
client.query(text, values, (err, res) => {
this.log("query dispatched");
client.removeListener("error", onError);
if (clientReleased) return;
clientReleased = true;
client.release(err);
if (err) return cb(err);
return cb(void 0, res);
});
} catch (err) {
client.release(err);
return cb(err);
}
});
return response.result;
}
end(cb) {
this.log("ending");
if (this.ending) {
const err = /* @__PURE__ */ new Error("Called end on pool more than once");
return cb ? cb(err) : this.Promise.reject(err);
}
this.ending = true;
const promised = promisify(this.Promise, cb);
this._endCallback = promised.callback;
this._pulseQueue();
return promised.result;
}
get waitingCount() {
return this._pendingQueue.length;
}
get idleCount() {
return this._idle.length;
}
get expiredCount() {
return this._clients.reduce((acc, client) => acc + (this._expired.has(client) ? 1 : 0), 0);
}
get totalCount() {
return this._clients.length;
}
};
module.exports = Pool;
}));
//#endregion
//#region optional-peer-dep:__vite-optional-peer-dep:pg-native:pg
var require_optional_peer_dep___vite_optional_peer_dep_pg_native_pg = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = {};
throw new Error(`Could not resolve "pg-native" imported by "pg". Is it installed?`);
}));
//#endregion
//#region ../../node_modules/pg/lib/native/query.js
var require_query = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var EventEmitter = require_events().EventEmitter;
var util = require_browser_external_util();
var utils = require_utils$1();
var NativeQuery = module.exports = function(config, values, callback) {
EventEmitter.call(this);
config = utils.normalizeQueryConfig(config, values, callback);
this.text = config.text;
this.values = config.values;
this.name = config.name;
this.queryMode = config.queryMode;
this.callback = config.callback;
this.state = "new";
this._arrayMode = config.rowMode === "array";
this._emitRowEvents = false;
this.on("newListener", function(event) {
if (event === "row") this._emitRowEvents = true;
}.bind(this));
};
util.inherits(NativeQuery, EventEmitter);
var errorFieldMap = {
sqlState: "code",
statementPosition: "position",
messagePrimary: "message",
context: "where",
schemaName: "schema",
tableName: "table",
columnName: "column",
dataTypeName: "dataType",
constraintName: "constraint",
sourceFile: "file",
sourceLine: "line",
sourceFunction: "routine"
};
NativeQuery.prototype.handleError = function(err) {
const fields = this.native.pq.resultErrorFields();
if (fields) for (const key in fields) {
const normalizedFieldName = errorFieldMap[key] || key;
err[normalizedFieldName] = fields[key];
}
if (this.callback) this.callback(err);
else this.emit("error", err);
this.state = "error";
};
NativeQuery.prototype.then = function(onSuccess, onFailure) {
return this._getPromise().then(onSuccess, onFailure);
};
NativeQuery.prototype.catch = function(callback) {
return this._getPromise().catch(callback);
};
NativeQuery.prototype._getPromise = function() {
if (this._promise) return this._promise;
this._promise = new Promise(function(resolve, reject) {
this._once("end", resolve);
this._once("error", reject);
}.bind(this));
return this._promise;
};
NativeQuery.prototype.submit = function(client) {
this.state = "running";
const self = this;
this.native = client.native;
client.native.arrayMode = this._arrayMode;
let after = function(err, rows, results) {
client.native.arrayMode = false;
setImmediate(function() {
self.emit("_done");
});
if (err) return self.handleError(err);
if (self._emitRowEvents) if (results.length > 1) rows.forEach((rowOfRows, i) => {
rowOfRows.forEach((row) => {
self.emit("row", row, results[i]);
});
});
else rows.forEach(function(row) {
self.emit("row", row, results);
});
self.state = "end";
self.emit("end", results);
if (self.callback) self.callback(null, results);
};
if (process.domain) after = process.domain.bind(after);
if (this.name) {
if (this.name.length > 63) {
console.error("Warning! Postgres only supports 63 characters for query names.");
console.error("You supplied %s (%s)", this.name, this.name.length);
console.error("This can cause conflicts and silent errors executing queries");
}
const values = (this.values || []).map(utils.prepareValue);
if (client.namedQueries[this.name]) {
if (this.text && client.namedQueries[this.name] !== this.text) {
const err = /* @__PURE__ */ new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`);
return after(err);
}
return client.native.execute(this.name, values, after);
}
return client.native.prepare(this.name, this.text, values.length, function(err) {
if (err) return after(err);
client.namedQueries[self.name] = self.text;
return self.native.execute(self.name, values, after);
});
} else if (this.values) {
if (!Array.isArray(this.values)) return after(/* @__PURE__ */ new Error("Query values must be an array"));
const vals = this.values.map(utils.prepareValue);
client.native.query(this.text, vals, after);
} else if (this.queryMode === "extended") client.native.query(this.text, [], after);
else client.native.query(this.text, after);
};
}));
//#endregion
//#region ../../node_modules/pg/lib/native/client.js
var require_client = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var Native;
try {
Native = require_optional_peer_dep___vite_optional_peer_dep_pg_native_pg();
} catch (e) {
throw e;
}
var TypeOverrides = require_type_overrides();
var EventEmitter = require_events().EventEmitter;
var util = require_browser_external_util();
var ConnectionParameters = require_connection_parameters();
var NativeQuery = require_query();
var Client = module.exports = function(config) {
EventEmitter.call(this);
config = config || {};
this._Promise = config.Promise || global.Promise;
this._types = new TypeOverrides(config.types);
this.native = new Native({ types: this._types });
this._queryQueue = [];
this._ending = false;
this._connecting = false;
this._connected = false;
this._queryable = true;
const cp = this.connectionParameters = new ConnectionParameters(config);
if (config.nativeConnectionString) cp.nativeConnectionString = config.nativeConnectionString;
this.user = cp.user;
Object.defineProperty(this, "password", {
configurable: true,
enumerable: false,
writable: true,
value: cp.password
});
this.database = cp.database;
this.host = cp.host;
this.port = cp.port;
this.namedQueries = {};
};
Client.Query = NativeQuery;
util.inherits(Client, EventEmitter);
Client.prototype._errorAllQueries = function(err) {
const enqueueError = (query) => {
process.nextTick(() => {
query.native = this.native;
query.handleError(err);
});
};
if (this._hasActiveQuery()) {
enqueueError(this._activeQuery);
this._activeQuery = null;
}
this._queryQueue.forEach(enqueueError);
this._queryQueue.length = 0;
};
Client.prototype._connect = function(cb) {
const self = this;
if (this._connecting) {
process.nextTick(() => cb(/* @__PURE__ */ new Error("Client has already been connected. You cannot reuse a client.")));
return;
}
this._connecting = true;
this.connectionParameters.getLibpqConnectionString(function(err, conString) {
if (self.connectionParameters.nativeConnectionString) conString = self.connectionParameters.nativeConnectionString;
if (err) return cb(err);
self.native.connect(conString, function(err) {
if (err) {
self.native.end();
return cb(err);
}
self._connected = true;
self.native.on("error", function(err) {
self._queryable = false;
self._errorAllQueries(err);
self.emit("error", err);
});
self.native.on("notification", function(msg) {
self.emit("notification", {
channel: msg.relname,
payload: msg.extra
});
});
self.emit("connect");
self._pulseQueryQueue(true);
cb();
});
});
};
Client.prototype.connect = function(callback) {
if (callback) {
this._connect(callback);
return;
}
return new this._Promise((resolve, reject) => {
this._connect((error) => {
if (error) reject(error);
else resolve();
});
});
};
Client.prototype.query = function(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") config.callback = values;
} else {
readTimeout = config.query_timeout || this.connectionParameters.query_timeout;
query = new NativeQuery(config, values, callback);
if (!query.callback) {
let resolveOut, rejectOut;
result = new this._Promise((resolve, reject) => {
resolveOut = resolve;
rejectOut = reject;
}).catch((err) => {
Error.captureStackTrace(err);
throw err;
});
query.callback = (err, res) => err ? rejectOut(err) : resolveOut(res);
}
}
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._queryable) {
query.native = this.native;
process.nextTick(() => {
query.handleError(/* @__PURE__ */ new Error("Client has encountered a connection error and is not queryable"));
});
return result;
}
if (this._ending) {
query.native = this.native;
process.nextTick(() => {
query.handleError(/* @__PURE__ */ new Error("Client was closed and is not queryable"));
});
return result;
}
this._queryQueue.push(query);
this._pulseQueryQueue();
return result;
};
Client.prototype.end = function(cb) {
const self = this;
this._ending = true;
if (!this._connected) this.once("connect", this.end.bind(this, cb));
let result;
if (!cb) result = new this._Promise(function(resolve, reject) {
cb = (err) => err ? reject(err) : resolve();
});
this.native.end(function() {
self._errorAllQueries(/* @__PURE__ */ new Error("Connection terminated"));
process.nextTick(() => {
self.emit("end");
if (cb) cb();
});
});
return result;
};
Client.prototype._hasActiveQuery = function() {
return this._activeQuery && this._activeQuery.state !== "error" && this._activeQuery.state !== "end";
};
Client.prototype._pulseQueryQueue = function(initialConnection) {
if (!this._connected) return;
if (this._hasActiveQuery()) return;
const query = this._queryQueue.shift();
if (!query) {
if (!initialConnection) this.emit("drain");
return;
}
this._activeQuery = query;
query.submit(this);
const self = this;
query.once("_done", function() {
self._pulseQueryQueue();
});
};
Client.prototype.cancel = function(query) {
if (this._activeQuery === query) this.native.cancel(function() {});
else if (this._queryQueue.indexOf(query) !== -1) this._queryQueue.splice(this._queryQueue.indexOf(query), 1);
};
Client.prototype.ref = function() {};
Client.prototype.unref = function() {};
Client.prototype.setTypeParser = function(oid, format, parseFn) {
return this._types.setTypeParser(oid, format, parseFn);
};
Client.prototype.getTypeParser = function(oid, format) {
return this._types.getTypeParser(oid, format);
};
}));
//#endregion
//#region ../../node_modules/pg/lib/native/index.js
var require_native = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = require_client();
}));
//#endregion
//#region ../../node_modules/pg/lib/index.js
var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var Client = require_client$1();
var defaults = require_defaults();
var Connection = require_connection();
var Result = require_result();
var utils = require_utils$1();
var Pool = require_pg_pool();
var TypeOverrides = require_type_overrides();
var { DatabaseError } = require_dist();
var { escapeIdentifier, escapeLiteral } = require_utils$1();
var poolFactory = (Client) => {
return class BoundPool extends Pool {
constructor(options) {
super(options, Client);
}
};
};
var PG = function(clientConstructor) {
this.defaults = defaults;
this.Client = clientConstructor;
this.Query = this.Client.Query;
this.Pool = poolFactory(this.Client);
this._pools = [];
this.Connection = Connection;
this.types = require_pg_types();
this.DatabaseError = DatabaseError;
this.TypeOverrides = TypeOverrides;
this.escapeIdentifier = escapeIdentifier;
this.escapeLiteral = escapeLiteral;
this.Result = Result;
this.utils = utils;
};
if (typeof process.env.NODE_PG_FORCE_NATIVE !== "undefined") module.exports = new PG(require_native());
else {
module.exports = new PG(Client);
Object.defineProperty(module.exports, "native", {
configurable: true,
enumerable: false,
get() {
let native = null;
try {
native = new PG(require_native());
} catch (err) {
if (err.code !== "MODULE_NOT_FOUND") throw err;
}
Object.defineProperty(module.exports, "native", { value: native });
return native;
}
});
}
}));
//#endregion
//#region ../../node_modules/pg/esm/index.mjs
var import_lib = /* @__PURE__ */ __toESM(require_lib(), 1);
var Client = import_lib.default.Client;
var Pool = import_lib.default.Pool;
var Connection = import_lib.default.Connection;
var types = import_lib.default.types;
var Query = import_lib.default.Query;
var DatabaseError = import_lib.default.DatabaseError;
var escapeIdentifier = import_lib.default.escapeIdentifier;
var escapeLiteral = import_lib.default.escapeLiteral;
var Result = import_lib.default.Result;
var TypeOverrides = import_lib.default.TypeOverrides;
var defaults = import_lib.default.defaults;
var esm_default = import_lib.default;
//#endregion
export { Client, Connection, DatabaseError, Pool, Query, Result, TypeOverrides, esm_default as default, defaults, escapeIdentifier, escapeLiteral, types };
//# sourceMappingURL=esm-YjqJkrMw.js.map