@bs-plugins/postgresql/dist/plugin.mjs

Bamboo Shell plugin for PostgreSQL

import { BSPlugin } from '@bs-core/shell';
import require$$0$3 from 'events';
import require$$0 from 'crypto';
import require$$0$2 from 'dns';
import require$$0$1 from 'fs';
import require$$0$4 from 'net';
import require$$1 from 'tls';
import require$$0$6 from 'path';
import require$$0$5 from 'stream';
import require$$1$1 from 'string_decoder';
import require$$3 from 'util';

var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

function getAugmentedNamespace(n) {
  if (n.__esModule) return n;
  var f = n.default;
	if (typeof f == "function") {
		var a = function a () {
			if (this instanceof a) {
        return Reflect.construct(f, arguments, this.constructor);
			}
			return f.apply(this, arguments);
		};
		a.prototype = f.prototype;
  } else a = {};
  Object.defineProperty(a, '__esModule', {value: true});
	Object.keys(n).forEach(function (k) {
		var d = Object.getOwnPropertyDescriptor(n, k);
		Object.defineProperty(a, k, d.get ? d : {
			enumerable: true,
			get: function () {
				return n[k];
			}
		});
	});
	return a;
}

var lib$1 = {exports: {}};

var defaults$3 = {exports: {}};

var pgTypes = {};

var postgresArray = {};

var hasRequiredPostgresArray;

function requirePostgresArray () {
	if (hasRequiredPostgresArray) return postgresArray;
	hasRequiredPostgresArray = 1;

	postgresArray.parse = function (source, transform) {
	  return new ArrayParser(source, transform).parse()
	};

	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()) {
	        var char = this.nextCharacter();
	        if (char.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
	}
	return postgresArray;
}

var arrayParser;
var hasRequiredArrayParser;

function requireArrayParser () {
	if (hasRequiredArrayParser) return arrayParser;
	hasRequiredArrayParser = 1;
	var array = requirePostgresArray();

	arrayParser = {
	  create: function (source, transform) {
	    return {
	      parse: function() {
	        return array.parse(source, transform);
	      }
	    };
	  }
	};
	return arrayParser;
}

var postgresDate;
var hasRequiredPostgresDate;

function requirePostgresDate () {
	if (hasRequiredPostgresDate) return postgresDate;
	hasRequiredPostgresDate = 1;

	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$/;

	postgresDate = function parseDate (isoDate) {
	  if (INFINITY.test(isoDate)) {
	    // Capitalize to Infinity before passing to Number
	    return Number(isoDate.replace('i', 'I'))
	  }
	  var matches = DATE_TIME.exec(isoDate);

	  if (!matches) {
	    // Force YYYY-MM-DD dates to be parsed as local time
	    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 ? 1000 * parseFloat(ms) : 0;

	  var date;
	  var offset = timeZoneOffset(isoDate);
	  if (offset != null) {
	    date = new Date(Date.UTC(year, month, day, hour, minute, second, ms));

	    // Account for years from 0 to 99 being interpreted as 1900-1999
	    // by Date.UTC / the multi-argument form of the Date constructor
	    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);
	  var isBC = !!matches[4];
	  if (isBC) {
	    year = bcYearToNegativeYear(year);
	  }

	  var month = parseInt(matches[2], 10) - 1;
	  var day = matches[3];
	  // YYYY-MM-DD will be parsed as local time
	  var date = new Date(year, month, day);

	  if (is0To99(year)) {
	    date.setFullYear(year);
	  }

	  return date
	}

	// match timezones:
	// Z (UTC)
	// -05
	// +06:30
	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;
	  var offset = parseInt(zone[2], 10) * 3600 +
	    parseInt(zone[3] || 0, 10) * 60 +
	    parseInt(zone[4] || 0, 10);

	  return offset * sign * 1000
	}

	function bcYearToNegativeYear (year) {
	  // Account for numerical difference between representations of BC years
	  // See: https://github.com/bendrucker/postgres-date/issues/5
	  return -(year - 1)
	}

	function is0To99 (num) {
	  return num >= 0 && num < 100
	}
	return postgresDate;
}

var mutable;
var hasRequiredMutable;

function requireMutable () {
	if (hasRequiredMutable) return mutable;
	hasRequiredMutable = 1;
	mutable = 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
	}
	return mutable;
}

var postgresInterval;
var hasRequiredPostgresInterval;

function requirePostgresInterval () {
	if (hasRequiredPostgresInterval) return postgresInterval;
	hasRequiredPostgresInterval = 1;

	var extend = requireMutable();

	postgresInterval = 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);

	  // In addition to `properties`, we need to account for fractions of seconds.
	  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;

	      // Account for fractional part of seconds,
	      // remove trailing zeroes.
	      if (property === 'seconds' && this.milliseconds) {
	        value = (value + this.milliseconds / 1000).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'];
	// according to ISO 8601
	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;

	    // Account for fractional part of seconds,
	    // remove trailing zeroes.
	    if (property === 'seconds' && this.milliseconds) {
	      value = (value + this.milliseconds / 1000).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 TIME = '([+-])?([\\d]*):(\\d\\d):(\\d\\d)\\.?(\\d{1,6})?';
	var INTERVAL = new RegExp([YEAR, MONTH, DAY, TIME].map(function (regexString) {
	  return '(' + regexString + ')?'
	})
	  .join('\\s*'));

	// Positions of values in regex match
	var positions = {
	  years: 2,
	  months: 4,
	  days: 6,
	  hours: 9,
	  minutes: 10,
	  seconds: 11,
	  milliseconds: 12
	};
	// We can use negative time
	var negatives = ['hours', 'minutes', 'seconds', 'milliseconds'];

	function parseMilliseconds (fraction) {
	  // add omitted zeroes
	  var microseconds = fraction + '000000'.slice(fraction.length);
	  return parseInt(microseconds, 10) / 1000
	}

	function parse (interval) {
	  if (!interval) return {}
	  var matches = INTERVAL.exec(interval);
	  var isNegative = matches[8] === '-';
	  return Object.keys(positions)
	    .reduce(function (parsed, property) {
	      var position = positions[property];
	      var value = matches[position];
	      // no empty string
	      if (!value) return parsed
	      // milliseconds are actually microseconds (up to 6 digits)
	      // with omitted trailing zeroes.
	      value = property === 'milliseconds'
	        ? parseMilliseconds(value)
	        : parseInt(value, 10);
	      // no zeros
	      if (!value) return parsed
	      if (isNegative && ~negatives.indexOf(property)) {
	        value *= -1;
	      }
	      parsed[property] = value;
	      return parsed
	    }, {})
	}
	return postgresInterval;
}

var postgresBytea;
var hasRequiredPostgresBytea;

function requirePostgresBytea () {
	if (hasRequiredPostgresBytea) return postgresBytea;
	hasRequiredPostgresBytea = 1;

	postgresBytea = function parseBytea (input) {
	  if (/^\\x/.test(input)) {
	    // new 'hex' style response (pg >9.0)
	    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')
	};
	return postgresBytea;
}

var textParsers;
var hasRequiredTextParsers;

function requireTextParsers () {
	if (hasRequiredTextParsers) return textParsers;
	hasRequiredTextParsers = 1;
	var array = requirePostgresArray();
	var arrayParser = requireArrayParser();
	var parseDate = requirePostgresDate();
	var parseInterval = requirePostgresInterval();
	var parseByteA = requirePostgresBytea();

	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; }
	  var p = arrayParser.create(value, function(entry) {
	    if(entry !== null) {
	      entry = parsePoint(entry);
	    }
	    return entry;
	  });

	  return p.parse();
	};

	var parseFloatArray = function(value) {
	  if(!value) { return null; }
	  var p = arrayParser.create(value, function(entry) {
	    if(entry !== null) {
	      entry = parseFloat(entry);
	    }
	    return entry;
	  });

	  return p.parse();
	};

	var parseStringArray = function(value) {
	  if(!value) { return null; }

	  var p = arrayParser.create(value);
	  return p.parse();
	};

	var parseDateArray = function(value) {
	  if (!value) { return null; }

	  var p = arrayParser.create(value, function(entry) {
	    if (entry !== null) {
	      entry = parseDate(entry);
	    }
	    return entry;
	  });

	  return p.parse();
	};

	var parseIntervalArray = function(value) {
	  if (!value) { return null; }

	  var p = arrayParser.create(value, function(entry) {
	    if (entry !== null) {
	      entry = parseInterval(entry);
	    }
	    return entry;
	  });

	  return p.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); // int8
	  register(21, parseInteger); // int2
	  register(23, parseInteger); // int4
	  register(26, parseInteger); // oid
	  register(700, parseFloat); // float4/real
	  register(701, parseFloat); // float8/double
	  register(16, parseBool);
	  register(1082, parseDate); // date
	  register(1114, parseDate); // timestamp without timezone
	  register(1184, parseDate); // timestamp
	  register(600, parsePoint); // point
	  register(651, parseStringArray); // cidr[]
	  register(718, parseCircle); // circle
	  register(1000, parseBoolArray);
	  register(1001, parseByteAArray);
	  register(1005, parseIntegerArray); // _int2
	  register(1007, parseIntegerArray); // _int4
	  register(1028, parseIntegerArray); // oid[]
	  register(1016, parseBigIntegerArray); // _int8
	  register(1017, parsePointArray); // point[]
	  register(1021, parseFloatArray); // _float4
	  register(1022, parseFloatArray); // _float8
	  register(1231, parseFloatArray); // _numeric
	  register(1014, parseStringArray); //char
	  register(1015, parseStringArray); //varchar
	  register(1008, parseStringArray);
	  register(1009, parseStringArray);
	  register(1040, parseStringArray); // macaddr[]
	  register(1041, parseStringArray); // inet[]
	  register(1115, parseDateArray); // timestamp without time zone[]
	  register(1182, parseDateArray); // _date
	  register(1185, parseDateArray); // timestamp with time zone[]
	  register(1186, parseInterval);
	  register(1187, parseIntervalArray);
	  register(17, parseByteA);
	  register(114, JSON.parse.bind(JSON)); // json
	  register(3802, JSON.parse.bind(JSON)); // jsonb
	  register(199, parseJsonArray); // json[]
	  register(3807, parseJsonArray); // jsonb[]
	  register(3907, parseStringArray); // numrange[]
	  register(2951, parseStringArray); // uuid[]
	  register(791, parseStringArray); // money[]
	  register(1183, parseStringArray); // time[]
	  register(1270, parseStringArray); // timetz[]
	};

	textParsers = {
	  init: init
	};
	return textParsers;
}

var pgInt8;
var hasRequiredPgInt8;

function requirePgInt8 () {
	if (hasRequiredPgInt8) return pgInt8;
	hasRequiredPgInt8 = 1;

	// selected so (BASE - 1) * 0x100000000 + 0xffffffff is a safe integer
	var BASE = 1000000;

	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 = 0x100000000 * 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 = 0x100000000 * 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 = 0x100000000 * 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 = 0x100000000 * carry + low;
			digits = '' + t % BASE;

			return sign + digits + result;
		}
	}

	pgInt8 = readInt8;
	return pgInt8;
}

var binaryParsers;
var hasRequiredBinaryParsers;

function requireBinaryParsers () {
	if (hasRequiredBinaryParsers) return binaryParsers;
	hasRequiredBinaryParsers = 1;
	var parseInt64 = requirePgInt8();

	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 & 0xff;
	    }

	    return value;
	  };

	  // read first (maybe partial) byte
	  var mask = 0xff;
	  var firstBits = 8 - (offset % 8);
	  if (bits < firstBits) {
	    mask = (0xff << (8 - bits)) & 0xff;
	    firstBits = bits;
	  }

	  if (offset) {
	    mask = mask >> (offset % 8);
	  }

	  var result = 0;
	  if ((offset % 8) + bits >= 8) {
	    result = callback(0, inv(data[offsetBytes]) & mask, firstBits);
	  }

	  // read bytes
	  var bytes = (bits + offset) >> 3;
	  for (var i = offsetBytes + 1; i < bytes; i++) {
	    result = callback(result, inv(data[i]), 8);
	  }

	  // bits to read, that are not a complete byte
	  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;
	  }

	  // parse mantissa
	  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 & (0x1 << (bits - i))) > 0) {
	        lastValue += precisionBitsCounter;
	      }
	    }

	    return lastValue;
	  };

	  var mantissa = parseBits(data, precisionBits, exponentBits + 1, false, parsePrecisionBits);

	  // special cases
	  if (exponent == (Math.pow(2, exponentBits + 1) - 1)) {
	    if (mantissa === 0) {
	      return (sign === 0) ? Infinity : -Infinity;
	    }

	    return NaN;
	  }

	  // normale number
	  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 == 0xc000) {
	    return NaN;
	  }

	  var weight = Math.pow(10000, 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 /= 10000;
	  }

	  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);

	  // discard usecs and shift from 2000 to 1970
	  var result = new Date((((sign === 0) ? 1 : -1) * rawValue / 1000) + 946684800000);

	  if (!isUTC) {
	    result.setTime(result.getTime() + result.getTimezoneOffset() * 60000);
	  }

	  // add microseconds to the date
	  result.usec = rawValue % 1000;
	  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++) {
	    // parse dimension
	    dims[i] = parseBits(value, 32, offset);
	    offset += 32;

	    // ignore lower bounds
	    offset += 32;
	  }

	  var parseElement = function(elementType) {
	    // parse content length
	    var length = parseBits(value, 32, offset);
	    offset += 32;

	    // parse null values
	    if (length == 0xffffffff) {
	      return null;
	    }

	    var result;
	    if ((elementType == 0x17) || (elementType == 0x14)) {
	      // int/bigint
	      result = parseBits(value, length * 8, offset);
	      offset += length * 8;
	      return result;
	    }
	    else if (elementType == 0x19) {
	      // string
	      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(1000, parseArray);
	  register(1007, parseArray);
	  register(1016, parseArray);
	  register(1008, parseArray);
	  register(1009, parseArray);
	  register(25, parseText);
	};

	binaryParsers = {
	  init: init
	};
	return binaryParsers;
}

/**
 * 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
 */

var builtins;
var hasRequiredBuiltins;

function requireBuiltins () {
	if (hasRequiredBuiltins) return builtins;
	hasRequiredBuiltins = 1;
	builtins = {
	    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
	};
	return builtins;
}

var hasRequiredPgTypes;

function requirePgTypes () {
	if (hasRequiredPgTypes) return pgTypes;
	hasRequiredPgTypes = 1;
	var textParsers = requireTextParsers();
	var binaryParsers = requireBinaryParsers();
	var arrayParser = requireArrayParser();
	var builtinTypes = requireBuiltins();

	pgTypes.getTypeParser = getTypeParser;
	pgTypes.setTypeParser = setTypeParser;
	pgTypes.arrayParser = arrayParser;
	pgTypes.builtins = builtinTypes;

	var typeParsers = {
	  text: {},
	  binary: {}
	};

	//the empty parse function
	function noParse (val) {
	  return String(val);
	}
	//returns a function used to convert a specific type (specified by
	//oid) into a result javascript type
	//note: the oid can be obtained via the following sql query:
	//SELECT oid FROM pg_type WHERE typname = 'TYPE_NAME_HERE';
	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;
	});
	return pgTypes;
}

(function (module) {

	module.exports = {
	  // database host. defaults to localhost
	  host: 'localhost',

	  // database user's name
	  user: process.platform === 'win32' ? process.env.USERNAME : process.env.USER,

	  // name of database to connect
	  database: undefined,

	  // database user's password
	  password: null,

	  // a Postgres connection string to be used instead of setting individual connection items
	  // NOTE:  Setting this value will cause it to override any other value (such as database or user) defined
	  // in the defaults object.
	  connectionString: undefined,

	  // database port
	  port: 5432,

	  // number of rows to return at a time from a prepared statement's
	  // portal. 0 will return all rows at once
	  rows: 0,

	  // binary result mode
	  binary: false,

	  // Connection pool options - see https://github.com/brianc/node-pg-pool

	  // number of connections to use in connection pool
	  // 0 will disable connection pooling
	  max: 10,

	  // max milliseconds a client can go unused before it is removed
	  // from the pool and destroyed
	  idleTimeoutMillis: 30000,

	  client_encoding: '',

	  ssl: false,

	  application_name: undefined,

	  fallback_application_name: undefined,

	  options: undefined,

	  parseInputDatesAsUTC: false,

	  // max milliseconds any query using this connection will execute for before timing out in error.
	  // false=unlimited
	  statement_timeout: false,

	  // Abort any statement that waits longer than the specified duration in milliseconds while attempting to acquire a lock.
	  // false=unlimited
	  lock_timeout: false,

	  // Terminate any session with an open transaction that has been idle for longer than the specified duration in milliseconds
	  // false=unlimited
	  idle_in_transaction_session_timeout: false,

	  // max milliseconds to wait for query to complete (client side)
	  query_timeout: false,

	  connect_timeout: 0,

	  keepalives: 1,

	  keepalives_idle: 0,
	};

	var pgTypes = requirePgTypes();
	// save default parsers
	var parseBigInteger = pgTypes.getTypeParser(20, 'text');
	var parseBigIntegerArray = pgTypes.getTypeParser(1016, 'text');

	// parse int8 so you can get your count values as actual numbers
	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);
	}); 
} (defaults$3));

var defaultsExports = defaults$3.exports;

const defaults$2 = defaultsExports;

function escapeElement(elementRepresentation) {
  var escaped = elementRepresentation.replace(/\\/g, '\\\\').replace(/"/g, '\\"');

  return '"' + escaped + '"'
}

// convert a JS array to a postgres array literal
// uses comma separator so won't work for types like box that use
// a different array separator.
function arrayString(val) {
  var result = '{';
  for (var 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])) {
      var item = val[i];
      if (!(item instanceof Buffer)) {
        var 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
}

// converts values from javascript types
// to their 'raw' counterparts for use as a postgres parameter
// note: you can override this function to provide your own conversion mechanism
// for complex types, etc...
var prepareValue = function (val, seen) {
  // null and undefined are both null for postgres
  if (val == null) {
    return null
  }
  if (val instanceof Buffer) {
    return val
  }
  if (ArrayBuffer.isView(val)) {
    var 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) // Node.js v4 does not support those Buffer.from params
  }
  if (val instanceof Date) {
    if (defaults$2.parseInputDatesAsUTC) {
      return dateToStringUTC(val)
    } else {
      return dateToString(val)
    }
  }
  if (Array.isArray(val)) {
    return arrayString(val)
  }
  if (typeof val === 'object') {
    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 pad(number, digits) {
  number = '' + number;
  while (number.length < digits) {
    number = '0' + number;
  }
  return number
}

function dateToString(date) {
  var offset = -date.getTimezoneOffset();

  var year = date.getFullYear();
  var isBCYear = year < 1;
  if (isBCYear) year = Math.abs(year) + 1; // negative years are 1 off their BC representation

  var ret =
    pad(year, 4) +
    '-' +
    pad(date.getMonth() + 1, 2) +
    '-' +
    pad(date.getDate(), 2) +
    'T' +
    pad(date.getHours(), 2) +
    ':' +
    pad(date.getMinutes(), 2) +
    ':' +
    pad(date.getSeconds(), 2) +
    '.' +
    pad(date.getMilliseconds(), 3);

  if (offset < 0) {
    ret += '-';
    offset *= -1;
  } else {
    ret += '+';
  }

  ret += pad(Math.floor(offset / 60), 2) + ':' + pad(offset % 60, 2);
  if (isBCYear) ret += ' BC';
  return ret
}

function dateToStringUTC(date) {
  var year = date.getUTCFullYear();
  var isBCYear = year < 1;
  if (isBCYear) year = Math.abs(year) + 1; // negative years are 1 off their BC representation

  var ret =
    pad(year, 4) +
    '-' +
    pad(date.getUTCMonth() + 1, 2) +
    '-' +
    pad(date.getUTCDate(), 2) +
    'T' +
    pad(date.getUTCHours(), 2) +
    ':' +
    pad(date.getUTCMinutes(), 2) +
    ':' +
    pad(date.getUTCSeconds(), 2) +
    '.' +
    pad(date.getUTCMilliseconds(), 3);

  ret += '+00:00';
  if (isBCYear) ret += ' BC';
  return ret
}

function normalizeQueryConfig(config, values, callback) {
  // can take in strings or config objects
  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
}

// Ported from PostgreSQL 9.2.4 source code in src/interfaces/libpq/fe-exec.c
const escapeIdentifier = function (str) {
  return '"' + str.replace(/"/g, '""') + '"'
};

const escapeLiteral = function (str) {
  var hasBackslash = false;
  var escaped = "'";

  for (var i = 0; i < str.length; i++) {
    var 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
};

var utils$3 = {
  prepareValue: function prepareValueWrapper(value) {
    // this ensures that extra arguments do not get passed into prepareValue
    // by accident, eg: from calling values.map(utils.prepareValue)
    return prepareValue(value)
  },
  normalizeQueryConfig,
  escapeIdentifier,
  escapeLiteral,
};

var utils$2 = {exports: {}};

var utilsLegacy;
var hasRequiredUtilsLegacy;

function requireUtilsLegacy () {
	if (hasRequiredUtilsLegacy) return utilsLegacy;
	hasRequiredUtilsLegacy = 1;
	// This file contains crypto utility functions for versions of Node.js < 15.0.0,
	// which does not support the WebCrypto.subtle API.

	const nodeCrypto = require$$0;

	function md5(string) {
	  return nodeCrypto.createHash('md5').update(string, 'utf-8').digest('hex')
	}

	// See AuthenticationMD5Password at https://www.postgresql.org/docs/current/static/protocol-flow.html
	function postgresMd5PasswordHash(user, password, salt) {
	  var inner = md5(password + user);
	  var outer = md5(Buffer.concat([Buffer.from(inner), salt]));
	  return 'md5' + outer
	}

	function sha256(text) {
	  return nodeCrypto.createHash('sha256').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')
	}

	utilsLegacy = {
	  postgresMd5PasswordHash,
	  randomBytes: nodeCrypto.randomBytes,
	  deriveKey,
	  sha256,
	  hmacSha256,
	  md5,
	};
	return utilsLegacy;
}

var utilsWebcrypto;
var hasRequiredUtilsWebcrypto;

function requireUtilsWebcrypto () {
	if (hasRequiredUtilsWebcrypto) return utilsWebcrypto;
	hasRequiredUtilsWebcrypto = 1;
	const nodeCrypto = require$$0;

	utilsWebcrypto = {
	  postgresMd5PasswordHash,
	  randomBytes,
	  deriveKey,
	  sha256,
	  hmacSha256,
	  md5,
	};

	/**
	 * The Web Crypto API - grabbed from the Node.js library or the global
	 * @type Crypto
	 */
	const webCrypto = nodeCrypto.webcrypto || globalThis.crypto;
	/**
	 * The SubtleCrypto API for low level crypto operations.
	 * @type SubtleCrypto
	 */
	const subtleCrypto = webCrypto.subtle;
	const 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) {
	    // `createHash()` failed so we are probably not in Node.js, use the WebCrypto API instead.
	    // Note that the MD5 algorithm on WebCrypto is not available in Node.js.
	    // This is why we cannot just use WebCrypto in all environments.
	    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('')
	  }
	}

	// See AuthenticationMD5Password at https://www.postgresql.org/docs/current/static/protocol-flow.html
	async function postgresMd5PasswordHash(user, password, salt) {
	  var inner = await md5(password + user);
	  var outer = await md5(Buffer.concat([Buffer.from(inner), salt]));
	  return 'md5' + outer
	}

	/**
	 * Create a SHA-256 digest of the given data
	 * @param {Buffer} data
	 */
	async function sha256(text) {
	  return await subtleCrypto.digest('SHA-256', 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: salt, iterations: iterations };
	  return await subtleCrypto.deriveBits(params, key, 32 * 8, ['deriveBits'])
	}
	return utilsWebcrypto;
}

const useLegacyCrypto = parseInt(process.versions && process.versions.node && process.versions.node.split('.')[0]) < 15;
if (useLegacyCrypto) {
  // We are on an old version of Node.js that requires legacy crypto utilities.
  utils$2.exports = requireUtilsLegacy();
} else {
  utils$2.exports = requireUtilsWebcrypto();
}

var utilsExports = utils$2.exports;

const crypto$1 = utilsExports;

function startSession(mechanisms) {
  if (mechanisms.indexOf('SCRAM-SHA-256') === -1) {
    throw new Error('SASL: Only mechanism SCRAM-SHA-256 is currently supported')
  }

  const clientNonce = crypto$1.randomBytes(18).toString('base64');

  return {
    mechanism: 'SCRAM-SHA-256',
    clientNonce,
    response: 'n,,n=*,r=' + clientNonce,
    message: 'SASLInitialResponse',
  }
}

async function continueSession(session, password, serverData) {
  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')
  }

  var clientFirstMessageBare = 'n=*,r=' + session.clientNonce;
  var serverFirstMessage = 'r=' + sv.nonce + ',s=' + sv.salt + ',i=' + sv.iteration;
  var clientFinalMessageWithoutProof = 'c=biws,r=' + sv.nonce;
  var authMessage = clientFirstMessageBare + ',' + serverFirstMessage + ',' + clientFinalMessageWithoutProof;

  var saltBytes = Buffer.from(sv.salt, 'base64');
  var saltedPassword = await crypto$1.deriveKey(password, saltBytes, sv.iteration);
  var clientKey = await crypto$1.hmacSha256(saltedPassword, 'Client Key');
  var storedKey = await crypto$1.sha256(clientKey);
  var clientSignature = await crypto$1.hmacSha256(storedKey, authMessage);
  var clientProof = xorBuffers(Buffer.from(clientKey), Buffer.from(clientSignature)).toString('base64');
  var serverKey = await crypto$1.hmacSha256(saltedPassword, 'Server Key');
  var serverSignatureBytes = await crypto$1.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 >= 0x21 && c <= 0x2b) || (c >= 0x2d && c <= 0x7e))
}

/**
 * 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')
      }
      const name = attrValue[0];
      const value = attrValue.substring(2);
      return [name, value]
    })
  )
}

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')
  }
  const iteration = parseInt(iterationText, 10);

  return {
    nonce,
    salt,
    iteration,
  }
}

function parseServerFinalMessage(serverData) {
  const attrPairs = parseAttributePairs(serverData);
  const serverSignature = attrPairs.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]))
}

var sasl$1 = {
  startSession,
  continueSession,
  finalizeSession,
};

var types$1 = requirePgTypes();

function TypeOverrides$1(userTypes) {
  this._types = userTypes || types$1;
  this.text = {};
  this.binary = {};
}

TypeOverrides$1.prototype.getOverrides = function (format) {
  switch (format) {
    case 'text':
      return this.text
    case 'binary':
      return this.binary
    default:
      return {}
  }
};

TypeOverrides$1.prototype.setTypeParser = function (oid, format, parseFn) {
  if (typeof format === 'function') {
    parseFn = format;
    format = 'text';
  }
  this.getOverrides(format)[oid] = parseFn;
};

TypeOverrides$1.prototype.getTypeParser = function (oid, format) {
  format = format || 'text';
  return this.getOverrides(format)[oid] || this._types.getTypeParser(oid, format)
};

var typeOverrides = TypeOverrides$1;

//Parse method copied from https://github.com/brianc/node-postgres
//Copyright (c) 2010-2014 Brian Carlson (brian.m.carlson@gmail.com)
//MIT License

//parses a connection string
function parse$3(str) {
  //unix socket
  if (str.charAt(0) === '/') {
    const config = str.split(' ');
    return { host: config[0], database: config[1] }
  }

  // Check for empty host in URL

  const config = {};
  let result;
  let dummyHost = false;
  if (/ |%[^a-f0-9]|%[a-f0-9][^a-f0-9]/i.test(str)) {
    // Ensure spaces are encoded as %20
    str = encodeURI(str).replace(/\%25(\d\d)/g, '%$1');
  }

  try {
    result = new URL(str, 'postgres://base');
  } catch (e) {
    // The URL is invalid so try again with a dummy host
    result = new URL(str.replace('@/', '@___DUMMY___/'), 'postgres://base');
    dummyHost = true;
  }

  // We'd like to use Object.fromEntries() here but Node.js 10 does not support it
  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);
    c