relq 1.0.0

package/dist/addons/pg-cursor.js

@@ -0,0 +1,1425 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// node_modules/postgres-array/index.js
+var require_postgres_array = __commonJS((exports) => {
+  exports.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;
+  }
+});
+
+// node_modules/pg-types/lib/arrayParser.js
+var require_arrayParser = __commonJS((exports, module) => {
+  var array = require_postgres_array();
+  module.exports = {
+    create: function(source, transform) {
+      return {
+        parse: function() {
+          return array.parse(source, transform);
+        }
+      };
+    }
+  };
+});
+
+// node_modules/postgres-date/index.js
+var require_postgres_date = __commonJS((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 ? 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));
+      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];
+    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;
+    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) {
+    return -(year - 1);
+  }
+  function is0To99(num) {
+    return num >= 0 && num < 100;
+  }
+});
+
+// node_modules/xtend/mutable.js
+var require_mutable = __commonJS((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;
+  }
+});
+
+// node_modules/postgres-interval/index.js
+var require_postgres_interval = __commonJS((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 / 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"];
+  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 / 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*"));
+  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) / 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];
+      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;
+    }, {});
+  }
+});
+
+// node_modules/postgres-bytea/index.js
+var require_postgres_bytea = __commonJS((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");
+  };
+});
+
+// node_modules/pg-types/lib/textParsers.js
+var require_textParsers = __commonJS((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;
+    }
+    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);
+    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(1000, 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
+  };
+});
+
+// node_modules/pg-int8/index.js
+var require_pg_int8 = __commonJS((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;
+});
+
+// node_modules/pg-types/lib/binaryParsers.js
+var require_binaryParsers = __commonJS((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, bits2) {
+      return lastValue * Math.pow(2, bits2) + 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 digits = [];
+    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 = new Date((sign === 0 ? 1 : -1) * rawValue / 1000 + 946684800000);
+    if (!isUTC) {
+      result.setTime(result.getTime() + result.getTimezoneOffset() * 60000);
+    }
+    result.usec = rawValue % 1000;
+    result.getMicroSeconds = function() {
+      return this.usec;
+    };
+    result.setMicroSeconds = function(value2) {
+      this.usec = value2;
+    };
+    result.getUTCMicroSeconds = function() {
+      return this.usec;
+    };
+    return result;
+  };
+  var parseArray = function(value) {
+    var dim = parseBits(value, 32);
+    var flags = 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(elementType2) {
+      var length = parseBits(value, 32, offset);
+      offset += 32;
+      if (length == 4294967295) {
+        return null;
+      }
+      var result;
+      if (elementType2 == 23 || elementType2 == 20) {
+        result = parseBits(value, length * 8, offset);
+        offset += length * 8;
+        return result;
+      } else if (elementType2 == 25) {
+        result = value.toString(this.encoding, offset >> 3, (offset += length << 3) >> 3);
+        return result;
+      } else {
+        console.log("ERROR: ElementType not implemented: " + elementType2);
+      }
+    };
+    var parse = function(dimension, elementType2) {
+      var array = [];
+      var i2;
+      if (dimension.length > 1) {
+        var count = dimension.shift();
+        for (i2 = 0;i2 < count; i2++) {
+          array[i2] = parse(dimension, elementType2);
+        }
+        dimension.unshift(count);
+      } else {
+        for (i2 = 0;i2 < dimension[0]; i2++) {
+          array[i2] = parseElement(elementType2);
+        }
+      }
+      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);
+  };
+  module.exports = {
+    init
+  };
+});
+
+// node_modules/pg-types/lib/builtins.js
+var require_builtins = __commonJS((exports, module) => {
+  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
+  };
+});
+
+// node_modules/pg-types/index.js
+var require_pg_types = __commonJS((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;
+  });
+});
+
+// node_modules/pg/lib/result.js
+var require_result = __commonJS((exports, module) => {
+  var types = require_pg_types();
+  var matchRegexp = /^([A-Za-z]+)(?: (\d+))?(?: (\d+))?/;
+
+  class Result {
+    constructor(rowMode, types2) {
+      this.command = null;
+      this.rowCount = null;
+      this.oid = null;
+      this.rows = [];
+      this.fields = [];
+      this._parsers = undefined;
+      this._types = types2;
+      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;
+});
+
+// node_modules/pg/lib/defaults.js
+var require_defaults = __commonJS((exports, module) => {
+  module.exports = {
+    host: "localhost",
+    user: process.platform === "win32" ? process.env.USERNAME : process.env.USER,
+    database: undefined,
+    password: null,
+    connectionString: undefined,
+    port: 5432,
+    rows: 0,
+    binary: false,
+    max: 10,
+    idleTimeoutMillis: 30000,
+    client_encoding: "",
+    ssl: false,
+    application_name: undefined,
+    fallback_application_name: undefined,
+    options: undefined,
+    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);
+  });
+});
+
+// node_modules/pg/lib/utils.js
+var require_utils = __commonJS((exports, module) => {
+  var defaults = require_defaults();
+  var util = __require("util");
+  var { isDate } = util.types || util;
+  function escapeElement(elementRepresentation) {
+    const escaped = elementRepresentation.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+    return '"' + escaped + '"';
+  }
+  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
+  };
+});
+
+// node_modules/pg-cursor/index.js
+var require_pg_cursor = __commonJS((exports, module) => {
+  var Result = require_result();
+  var prepare = require_utils().prepareValue;
+  var EventEmitter = __require("events").EventEmitter;
+  var util = __require("util");
+  var nextUniqueID = 1;
+
+  class Cursor extends EventEmitter {
+    constructor(text, values, config) {
+      super();
+      this._conf = config || {};
+      this.text = text;
+      this.values = values ? values.map(prepare) : null;
+      this.connection = null;
+      this._queue = [];
+      this.state = "initialized";
+      this._result = new Result(this._conf.rowMode, this._conf.types);
+      this._Promise = this._conf.Promise || global.Promise;
+      this._cb = null;
+      this._rows = null;
+      this._portal = null;
+      this._ifNoData = this._ifNoData.bind(this);
+      this._rowDescription = this._rowDescription.bind(this);
+    }
+    _ifNoData() {
+      this.state = "idle";
+      this._shiftQueue();
+      if (this.connection) {
+        this.connection.removeListener("rowDescription", this._rowDescription);
+      }
+    }
+    _rowDescription() {
+      if (this.connection) {
+        this.connection.removeListener("noData", this._ifNoData);
+      }
+    }
+    submit(connection) {
+      this.state = "submitted";
+      this.connection = connection;
+      this._portal = "C_" + nextUniqueID++;
+      const con = connection;
+      con.parse({
+        text: this.text
+      }, true);
+      con.bind({
+        portal: this._portal,
+        values: this.values
+      }, true);
+      con.describe({
+        type: "P",
+        name: this._portal
+      }, true);
+      con.flush();
+      if (this._conf.types) {
+        this._result._getTypeParser = this._conf.types.getTypeParser;
+      }
+      con.once("noData", this._ifNoData);
+      con.once("rowDescription", this._rowDescription);
+    }
+    _shiftQueue() {
+      if (this._queue.length) {
+        this._getRows.apply(this, this._queue.shift());
+      }
+    }
+    _closePortal() {
+      if (this.state === "done")
+        return;
+      this.connection.close({ type: "P", name: this._portal });
+      if (this.state !== "error") {
+        this.connection.sync();
+      }
+      this.state = "done";
+    }
+    handleRowDescription(msg) {
+      this._result.addFields(msg.fields);
+      this.state = "idle";
+      this._shiftQueue();
+    }
+    handleDataRow(msg) {
+      const row = this._result.parseRow(msg.fields);
+      this.emit("row", row, this._result);
+      this._rows.push(row);
+    }
+    _sendRows() {
+      this.state = "idle";
+      setImmediate(() => {
+        const cb = this._cb;
+        this._cb = null;
+        if (cb) {
+          this._result.rows = this._rows;
+          cb(null, this._rows, this._result);
+        }
+        this._rows = [];
+      });
+    }
+    handleCommandComplete(msg) {
+      this._result.addCommandComplete(msg);
+      this._closePortal();
+    }
+    handlePortalSuspended() {
+      this._sendRows();
+    }
+    handleReadyForQuery() {
+      this._sendRows();
+      this.state = "done";
+      this.emit("end", this._result);
+    }
+    handleEmptyQuery() {
+      this.connection.sync();
+    }
+    handleError(msg) {
+      if (this.state === "done")
+        return;
+      if (this.state !== "initialized") {
+        this.connection.removeListener("noData", this._ifNoData);
+        this.connection.removeListener("rowDescription", this._rowDescription);
+        this.connection.sync();
+      }
+      this.state = "error";
+      this._error = msg;
+      if (this._cb) {
+        this._cb(msg);
+      }
+      for (let i = 0;i < this._queue.length; i++) {
+        const queuedCallback = this._queue[i][1];
+        queuedCallback.call(this, msg);
+      }
+      this._queue.length = 0;
+      if (this.listenerCount("error") > 0) {
+        this.emit("error", msg);
+      }
+    }
+    _getRows(rows, cb) {
+      this.state = "busy";
+      this._cb = cb;
+      this._rows = [];
+      const msg = {
+        portal: this._portal,
+        rows
+      };
+      this.connection.execute(msg, true);
+      this.connection.flush();
+    }
+    end(cb) {
+      if (this.state !== "initialized") {
+        this.connection.sync();
+      }
+      this.connection.once("end", cb);
+      this.connection.end();
+    }
+    close(cb) {
+      let promise;
+      if (!cb) {
+        promise = new this._Promise((resolve, reject) => {
+          cb = (err) => err ? reject(err) : resolve();
+        });
+      }
+      if (!this.connection || this.state === "done") {
+        setImmediate(cb);
+        return promise;
+      }
+      this._closePortal();
+      this.connection.once("readyForQuery", function() {
+        cb();
+      });
+      return promise;
+    }
+    read(rows, cb) {
+      let promise;
+      if (!cb) {
+        promise = new this._Promise((resolve, reject) => {
+          cb = (err, rows2) => err ? reject(err) : resolve(rows2);
+        });
+      }
+      if (this.state === "idle" || this.state === "submitted") {
+        this._getRows(rows, cb);
+      } else if (this.state === "busy" || this.state === "initialized") {
+        this._queue.push([rows, cb]);
+      } else if (this.state === "error") {
+        setImmediate(() => cb(this._error));
+      } else if (this.state === "done") {
+        setImmediate(() => cb(null, []));
+      } else {
+        throw new Error("Unknown state: " + this.state);
+      }
+      return promise;
+    }
+  }
+  Cursor.prototype.end = util.deprecate(Cursor.prototype.end, "Cursor.end is deprecated. Call end on the client itself to end a connection to the database.");
+  module.exports = Cursor;
+});
+
+// node_modules/pg-cursor/esm/index.mjs
+var import___ = __toESM(require_pg_cursor(), 1);
+var esm_default = import___.default;
+
+// src/addon/pg-cursor/index.ts
+var pg_cursor_default = esm_default;
+export {
+  pg_cursor_default as default
+};