@stacksjs/actions 0.70.0 → 0.70.1

package/dist/{chunk-td8tcbm5.js → chunk-kw5hbw3s.js}

@@ -56836,238 +56836,361 @@ var require_mysql2 = __commonJS((exports) => {
   };
 });
 
-// ../../../../node_modules/pg/node_modules/pg-types/node_modules/postgres-array/index.js
+// ../../../../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
-        };
+  var BACKSLASH = "\\";
+  var DQUOT = '"';
+  var LBRACE = "{";
+  var RBRACE = "}";
+  var LBRACKET = "[";
+  var EQUALS = "=";
+  var COMMA = ",";
+  var NULL_STRING = "NULL";
+  function makeParseArrayWithTransform(transform) {
+    const haveTransform = transform != null;
+    return function parseArray(str) {
+      const rbraceIndex = str.length - 1;
+      if (rbraceIndex === 1) {
+        return [];
       }
-      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 = [];
+      if (str[rbraceIndex] !== RBRACE) {
+        throw new Error("Invalid array text - must end with }");
       }
-    }
-    consumeDimensions() {
-      if (this.source[0] === "[") {
-        while (!this.isEof()) {
-          var char = this.nextCharacter();
-          if (char.value === "=")
-            break;
-        }
+      let position = 0;
+      if (str[position] === LBRACKET) {
+        position = str.indexOf(EQUALS) + 1;
       }
-    }
-    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;
+      if (str[position++] !== LBRACE) {
+        throw new Error("Invalid array text - must start with {");
+      }
+      const output = [];
+      let current = output;
+      const stack = [];
+      let currentStringStart = position;
+      let currentString = "";
+      let expectValue = true;
+      for (;position < rbraceIndex; ++position) {
+        let char = str[position];
+        if (char === DQUOT) {
+          currentStringStart = ++position;
+          let dquot = str.indexOf(DQUOT, currentStringStart);
+          let backSlash = str.indexOf(BACKSLASH, currentStringStart);
+          while (backSlash !== -1 && backSlash < dquot) {
+            position = backSlash;
+            const part2 = str.slice(currentStringStart, position);
+            currentString += part2;
+            currentStringStart = ++position;
+            if (dquot === position++) {
+              dquot = str.indexOf(DQUOT, position);
+            }
+            backSlash = str.indexOf(BACKSLASH, position);
           }
-        } else if (character.value === "}" && !quote) {
-          this.dimension--;
-          if (!this.dimension) {
-            this.newEntry();
-            if (nested)
-              return this.entries;
+          position = dquot;
+          const part = str.slice(currentStringStart, position);
+          currentString += part;
+          current.push(haveTransform ? transform(currentString) : currentString);
+          currentString = "";
+          expectValue = false;
+        } else if (char === LBRACE) {
+          const newArray = [];
+          current.push(newArray);
+          stack.push(current);
+          current = newArray;
+          currentStringStart = position + 1;
+          expectValue = true;
+        } else if (char === COMMA) {
+          expectValue = true;
+        } else if (char === RBRACE) {
+          expectValue = false;
+          const arr = stack.pop();
+          if (arr === undefined) {
+            throw new Error("Invalid array text - too many '}'");
           }
-        } else if (character.value === '"' && !character.escaped) {
-          if (quote)
-            this.newEntry(true);
-          quote = !quote;
-        } else if (character.value === "," && !quote) {
-          this.newEntry();
+          current = arr;
+        } else if (expectValue) {
+          currentStringStart = position;
+          while ((char = str[position]) !== COMMA && char !== RBRACE && position < rbraceIndex) {
+            ++position;
+          }
+          const part = str.slice(currentStringStart, position--);
+          current.push(part === NULL_STRING ? null : haveTransform ? transform(part) : part);
+          expectValue = false;
         } else {
-          this.record(character.value);
+          throw new Error("Was expecting delimeter");
         }
       }
-      if (this.dimension !== 0) {
-        throw new Error("array dimension not balanced");
-      }
-      return this.entries;
-    }
-  }
-  function identity(value) {
-    return value;
+      return output;
+    };
   }
+  var parseArray = makeParseArrayWithTransform();
+  exports.parse = (source, transform) => transform != null ? makeParseArrayWithTransform(transform)(source) : parseArray(source);
 });
 
-// ../../../../node_modules/pg/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 CHAR_CODE_0 = 48;
+  var CHAR_CODE_9 = 57;
+  var CHAR_CODE_DASH = 45;
+  var CHAR_CODE_COLON = 58;
+  var CHAR_CODE_SPACE = 32;
+  var CHAR_CODE_DOT = 46;
+  var CHAR_CODE_Z = 90;
+  var CHAR_CODE_MINUS = 45;
+  var CHAR_CODE_PLUS = 43;
+
+  class PGDateParser {
+    constructor(dateString) {
+      this.dateString = dateString;
+      this.pos = 0;
+      this.stringLen = dateString.length;
+    }
+    isDigit(c) {
+      return c >= CHAR_CODE_0 && c <= CHAR_CODE_9;
+    }
+    readInteger() {
+      let val = 0;
+      const start = this.pos;
+      while (this.pos < this.stringLen) {
+        const chr = this.dateString.charCodeAt(this.pos);
+        if (this.isDigit(chr)) {
+          val = val * 10;
+          this.pos += 1;
+          val += chr - CHAR_CODE_0;
+        } else {
+          break;
         }
-      };
+      }
+      if (start === this.pos) {
+        return null;
+      }
+      return val;
     }
-  };
-});
-
-// ../../../../node_modules/pg/node_modules/pg-types/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"));
+    readInteger2() {
+      const chr1 = this.dateString.charCodeAt(this.pos);
+      const chr2 = this.dateString.charCodeAt(this.pos + 1);
+      if (this.isDigit(chr1) && this.isDigit(chr2)) {
+        this.pos += 2;
+        return (chr1 - CHAR_CODE_0) * 10 + (chr2 - CHAR_CODE_0);
+      }
+      return -1;
     }
-    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);
+    skipChar(char) {
+      if (this.pos === this.stringLen) {
+        return false;
       }
-    } else {
-      date = new Date(year, month, day, hour, minute, second, ms);
-      if (is0To99(year)) {
-        date.setFullYear(year);
+      if (this.dateString.charCodeAt(this.pos) === char) {
+        this.pos += 1;
+        return true;
       }
+      return false;
     }
-    return date;
-  };
-  function getDate(isoDate) {
-    var matches = DATE.exec(isoDate);
-    if (!matches) {
-      return;
+    readBC() {
+      if (this.pos === this.stringLen) {
+        return false;
+      }
+      if (this.dateString.slice(this.pos, this.pos + 3) === " BC") {
+        this.pos += 3;
+        return true;
+      }
+      return false;
     }
-    var year = parseInt(matches[1], 10);
-    var isBC = !!matches[4];
-    if (isBC) {
-      year = bcYearToNegativeYear(year);
+    checkEnd() {
+      return this.pos === this.stringLen;
     }
-    var month = parseInt(matches[2], 10) - 1;
-    var day = matches[3];
-    var date = new Date(year, month, day);
-    if (is0To99(year)) {
-      date.setFullYear(year);
+    getUTC() {
+      return this.skipChar(CHAR_CODE_Z);
     }
-    return date;
-  }
-  function timeZoneOffset(isoDate) {
-    if (isoDate.endsWith("+00")) {
-      return 0;
+    readSign() {
+      if (this.pos >= this.stringLen) {
+        return null;
+      }
+      const char = this.dateString.charCodeAt(this.pos);
+      if (char === CHAR_CODE_PLUS) {
+        this.pos += 1;
+        return 1;
+      }
+      if (char === CHAR_CODE_MINUS) {
+        this.pos += 1;
+        return -1;
+      }
+      return null;
     }
-    var zone = TIME_ZONE.exec(isoDate.split(" ")[1]);
-    if (!zone)
-      return;
-    var type = zone[1];
-    if (type === "Z") {
+    getTZOffset() {
+      if (this.pos === this.stringLen - 3 && this.dateString.slice(this.pos, this.pos + 3) === "+00") {
+        this.pos += 3;
+        return 0;
+      }
+      if (this.stringLen === this.pos) {
+        return;
+      }
+      const sign = this.readSign();
+      if (sign === null) {
+        if (this.getUTC()) {
+          return 0;
+        }
+        return;
+      }
+      const hours = this.readInteger2();
+      if (hours === null) {
+        return null;
+      }
+      let offset = hours * 3600;
+      if (!this.skipChar(CHAR_CODE_COLON)) {
+        return offset * sign * 1000;
+      }
+      const minutes = this.readInteger2();
+      if (minutes === null) {
+        return null;
+      }
+      offset += minutes * 60;
+      if (!this.skipChar(CHAR_CODE_COLON)) {
+        return offset * sign * 1000;
+      }
+      const seconds = this.readInteger2();
+      if (seconds == null) {
+        return null;
+      }
+      return (offset + seconds) * sign * 1000;
+    }
+    readMilliseconds() {
+      if (this.skipChar(CHAR_CODE_DOT)) {
+        let i = 2;
+        let val = 0;
+        const start = this.pos;
+        while (this.pos < this.stringLen) {
+          const chr = this.dateString.charCodeAt(this.pos);
+          if (this.isDigit(chr)) {
+            this.pos += 1;
+            if (i >= 0) {
+              val += (chr - CHAR_CODE_0) * 10 ** i;
+            }
+            i -= 1;
+          } else {
+            break;
+          }
+        }
+        if (start === this.pos) {
+          return null;
+        }
+        return val;
+      }
       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 hasOwnProperty2 = Object.prototype.hasOwnProperty;
-  function extend(target) {
-    for (var i = 1;i < arguments.length; i++) {
-      var source = arguments[i];
-      for (var key in source) {
-        if (hasOwnProperty2.call(source, key)) {
-          target[key] = source[key];
+    readDate() {
+      const year = this.readInteger();
+      if (!this.skipChar(CHAR_CODE_DASH)) {
+        return null;
+      }
+      let month = this.readInteger2();
+      if (!this.skipChar(CHAR_CODE_DASH)) {
+        return null;
+      }
+      const day = this.readInteger2();
+      if (year === null || month === null || day === null) {
+        return null;
+      }
+      month = month - 1;
+      return { year, month, day };
+    }
+    readTime() {
+      if (this.stringLen - this.pos < 9 || !this.skipChar(CHAR_CODE_SPACE)) {
+        return { hours: 0, minutes: 0, seconds: 0, milliseconds: 0 };
+      }
+      const hours = this.readInteger2();
+      if (hours === null || !this.skipChar(CHAR_CODE_COLON)) {
+        return null;
+      }
+      const minutes = this.readInteger2();
+      if (minutes === null || !this.skipChar(CHAR_CODE_COLON)) {
+        return null;
+      }
+      const seconds = this.readInteger2();
+      if (seconds === null) {
+        return null;
+      }
+      const milliseconds = this.readMilliseconds();
+      if (milliseconds === null) {
+        return null;
+      }
+      return { hours, minutes, seconds, milliseconds };
+    }
+    getJSDate() {
+      const date = this.readDate();
+      if (date === null) {
+        return null;
+      }
+      const time = this.readTime();
+      if (time === null) {
+        return null;
+      }
+      const tzOffset = this.getTZOffset();
+      if (tzOffset === null) {
+        return null;
+      }
+      const isBC = this.readBC();
+      if (isBC) {
+        date.year = -(date.year - 1);
+      }
+      if (!this.checkEnd()) {
+        return null;
+      }
+      let jsDate;
+      if (tzOffset !== undefined) {
+        jsDate = new Date(Date.UTC(date.year, date.month, date.day, time.hours, time.minutes, time.seconds, time.milliseconds));
+        if (date.year <= 99 && date.year >= -99) {
+          jsDate.setUTCFullYear(date.year);
+        }
+        if (tzOffset !== 0) {
+          jsDate.setTime(jsDate.getTime() - tzOffset);
+        }
+      } else {
+        jsDate = new Date(date.year, date.month, date.day, time.hours, time.minutes, time.seconds, time.milliseconds);
+        if (date.year <= 99 && date.year >= -99) {
+          jsDate.setFullYear(date.year);
         }
       }
+      return jsDate;
+    }
+    static parse(dateString) {
+      return new PGDateParser(dateString).getJSDate();
     }
-    return target;
   }
+  module.exports = function parseDate(isoDate) {
+    if (isoDate === null || isoDate === undefined) {
+      return null;
+    }
+    const date = PGDateParser.parse(isoDate);
+    if (date === null) {
+      if (isoDate === "infinity") {
+        return Infinity;
+      }
+      if (isoDate === "-infinity") {
+        return -Infinity;
+      }
+    }
+    return date;
+  };
 });
 
-// ../../../../node_modules/pg/node_modules/pg-types/node_modules/postgres-interval/index.js
+// ../../../../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));
+    Object.assign(this, parse(raw));
   }
   var properties = ["seconds", "minutes", "hours", "days", "months", "years"];
   PostgresInterval.prototype.toPostgres = function() {
-    var filtered = properties.filter(this.hasOwnProperty, this);
+    const filtered = properties.filter((key) => Object.prototype.hasOwnProperty.call(this, key) && this[key] !== 0);
     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;
+      let value = this[property] || 0;
       if (property === "seconds" && this.milliseconds) {
         value = (value + this.milliseconds / 1000).toFixed(6).replace(/\.?0+$/, "");
       }
@@ -57085,69 +57208,97 @@ var require_postgres_interval = __commonJS((exports, module) => {
   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;
+    return toISOString.call(this, { short: false });
+  };
+  PostgresInterval.prototype.toISOStringShort = function() {
+    return toISOString.call(this, { short: true });
+  };
+  function toISOString({ short = false }) {
+    const datePart = dateProperties.map(buildProperty, this).join("");
+    const timePart = timeProperties.map(buildProperty, this).join("");
+    if (!timePart.length && !datePart.length)
+      return "PT0S";
+    if (!timePart.length)
+      return `P${datePart}`;
+    return `P${datePart}T${timePart}`;
     function buildProperty(property) {
-      var value = this[property] || 0;
+      let value = this[property] || 0;
       if (property === "seconds" && this.milliseconds) {
         value = (value + this.milliseconds / 1000).toFixed(6).replace(/0+$/, "");
       }
+      if (short && !value)
+        return "";
       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;
   }
+  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("^\\s*" + [YEAR, MONTH, DAY, TIME].map((str) => "(?:" + str + ")?").join("\\s*") + "\\s*$");
+  var ZERO_INTERVAL = Object.freeze({
+    years: 0,
+    months: 0,
+    days: 0,
+    hours: 0,
+    minutes: 0,
+    seconds: 0,
+    milliseconds: 0
+  });
   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;
-    }, {});
+    if (!interval) {
+      return ZERO_INTERVAL;
+    }
+    const matches = INTERVAL.exec(interval) || [];
+    const [
+      ,
+      yearsString,
+      monthsString,
+      daysString,
+      plusMinusTime,
+      hoursString,
+      minutesString,
+      secondsString
+    ] = matches;
+    const timeMultiplier = plusMinusTime === "-" ? -1 : 1;
+    const years = yearsString ? parseInt(yearsString, 10) : 0;
+    const months = monthsString ? parseInt(monthsString, 10) : 0;
+    const days = daysString ? parseInt(daysString, 10) : 0;
+    const hours = hoursString ? timeMultiplier * parseInt(hoursString, 10) : 0;
+    const minutes = minutesString ? timeMultiplier * parseInt(minutesString, 10) : 0;
+    const secondsFloat = parseFloat(secondsString) || 0;
+    const absSeconds = Math.floor(secondsFloat);
+    const seconds = timeMultiplier * absSeconds;
+    const milliseconds = Math.round(timeMultiplier * (secondsFloat - absSeconds) * 1e6) / 1000;
+    return {
+      years,
+      months,
+      days,
+      hours,
+      minutes,
+      seconds,
+      milliseconds
+    };
   }
+  PostgresInterval.parse = parse;
 });
 
-// ../../../../node_modules/pg/node_modules/pg-types/node_modules/postgres-bytea/index.js
-var require_postgres_bytea = __commonJS((exports, module) => {
-  module.exports = function parseBytea(input) {
+// ../../../../node_modules/postgres-bytea/decode.js
+var require_decode = __commonJS((exports, module) => {
+  module.exports = byteaToBinary;
+  function byteaToBinary(input) {
     if (/^\\x/.test(input)) {
-      return new Buffer(input.substr(2), "hex");
+      return byteaHexFormatToBinary(input);
     }
-    var output = "";
-    var i = 0;
+    return byteaEscapeFormatToBinary(input);
+  }
+  function byteaHexFormatToBinary(input) {
+    return Buffer.from(input.substr(2), "hex");
+  }
+  function byteaEscapeFormatToBinary(input) {
+    let output = "";
+    let i = 0;
     while (i < input.length) {
       if (input[i] !== "\\") {
         output += input[i];
@@ -57157,136 +57308,679 @@ var require_postgres_bytea = __commonJS((exports, module) => {
           output += String.fromCharCode(parseInt(input.substr(i + 1, 3), 8));
           i += 4;
         } else {
-          var backslashes = 1;
+          let backslashes = 1;
           while (i + backslashes < input.length && input[i + backslashes] === "\\") {
             backslashes++;
           }
-          for (var k = 0;k < Math.floor(backslashes / 2); ++k) {
+          for (let k = 0;k < Math.floor(backslashes / 2); ++k) {
             output += "\\";
           }
           i += Math.floor(backslashes / 2) * 2;
         }
       }
     }
-    return new Buffer(output, "binary");
+    return Buffer.from(output, "binary");
+  }
+});
+
+// ../../../../node_modules/postgres-bytea/encoder.js
+var require_encoder = __commonJS((exports, module) => {
+  var { Transform } = __require("stream");
+
+  class ByteaEncoder extends Transform {
+    constructor() {
+      super();
+      this.push("\\\\x");
+    }
+    _transform(chunk, encoding, callback) {
+      this.push(chunk.toString("hex"));
+      callback();
+    }
+  }
+  module.exports = ByteaEncoder;
+});
+
+// ../../../../node_modules/obuf/index.js
+var require_obuf = __commonJS((exports, module) => {
+  var Buffer2 = __require("buffer").Buffer;
+  function OffsetBuffer() {
+    this.offset = 0;
+    this.size = 0;
+    this.buffers = [];
+  }
+  module.exports = OffsetBuffer;
+  OffsetBuffer.prototype.isEmpty = function isEmpty() {
+    return this.size === 0;
+  };
+  OffsetBuffer.prototype.clone = function clone(size) {
+    var r = new OffsetBuffer;
+    r.offset = this.offset;
+    r.size = size;
+    r.buffers = this.buffers.slice();
+    return r;
+  };
+  OffsetBuffer.prototype.toChunks = function toChunks() {
+    if (this.size === 0)
+      return [];
+    if (this.offset !== 0) {
+      this.buffers[0] = this.buffers[0].slice(this.offset);
+      this.offset = 0;
+    }
+    var chunks = [];
+    var off = 0;
+    for (var i = 0;off <= this.size && i < this.buffers.length; i++) {
+      var buf = this.buffers[i];
+      off += buf.length;
+      if (off > this.size) {
+        buf = buf.slice(0, buf.length - (off - this.size));
+        this.buffers[i] = buf;
+      }
+      chunks.push(buf);
+    }
+    if (i < this.buffers.length)
+      this.buffers.length = i;
+    return chunks;
+  };
+  OffsetBuffer.prototype.toString = function toString(enc) {
+    return this.toChunks().map(function(c) {
+      return c.toString(enc);
+    }).join("");
+  };
+  OffsetBuffer.prototype.use = function use(buf, off, n) {
+    this.buffers = [buf];
+    this.offset = off;
+    this.size = n;
+  };
+  OffsetBuffer.prototype.push = function push(data) {
+    if (data.length === 0)
+      return;
+    this.size += data.length;
+    this.buffers.push(data);
+  };
+  OffsetBuffer.prototype.has = function has(n) {
+    return this.size >= n;
+  };
+  OffsetBuffer.prototype.skip = function skip(n) {
+    if (this.size === 0)
+      return;
+    this.size -= n;
+    if (this.offset + n < this.buffers[0].length) {
+      this.offset += n;
+      return;
+    }
+    var left = n - (this.buffers[0].length - this.offset);
+    this.offset = 0;
+    for (var shift = 1;left > 0 && shift < this.buffers.length; shift++) {
+      var buf = this.buffers[shift];
+      if (buf.length > left) {
+        this.offset = left;
+        break;
+      }
+      left -= buf.length;
+    }
+    this.buffers = this.buffers.slice(shift);
+  };
+  OffsetBuffer.prototype.copy = function copy(target, targetOff, off, n) {
+    if (this.size === 0)
+      return;
+    if (off !== 0)
+      throw new Error("Unsupported offset in .copy()");
+    var toff = targetOff;
+    var first = this.buffers[0];
+    var toCopy = Math.min(n, first.length - this.offset);
+    first.copy(target, toff, this.offset, this.offset + toCopy);
+    toff += toCopy;
+    var left = n - toCopy;
+    for (var i = 1;left > 0 && i < this.buffers.length; i++) {
+      var buf = this.buffers[i];
+      var toCopy = Math.min(left, buf.length);
+      buf.copy(target, toff, 0, toCopy);
+      toff += toCopy;
+      left -= toCopy;
+    }
+  };
+  OffsetBuffer.prototype.take = function take(n) {
+    if (n === 0)
+      return new Buffer2(0);
+    this.size -= n;
+    var first = this.buffers[0].length - this.offset;
+    if (first === n) {
+      var r = this.buffers.shift();
+      if (this.offset !== 0) {
+        r = r.slice(this.offset);
+        this.offset = 0;
+      }
+      return r;
+    } else if (first > n) {
+      var r = this.buffers[0].slice(this.offset, this.offset + n);
+      this.offset += n;
+      return r;
+    }
+    var out = new Buffer2(n);
+    var toOff = 0;
+    var startOff = this.offset;
+    for (var i = 0;toOff !== n && i < this.buffers.length; i++) {
+      var buf = this.buffers[i];
+      var toCopy = Math.min(buf.length - startOff, n - toOff);
+      buf.copy(out, toOff, startOff, startOff + toCopy);
+      if (startOff + toCopy < buf.length) {
+        this.offset = startOff + toCopy;
+        break;
+      } else {
+        toOff += toCopy;
+        startOff = 0;
+      }
+    }
+    this.buffers = this.buffers.slice(i);
+    if (this.buffers.length === 0)
+      this.offset = 0;
+    return out;
+  };
+  OffsetBuffer.prototype.peekUInt8 = function peekUInt8() {
+    return this.buffers[0][this.offset];
+  };
+  OffsetBuffer.prototype.readUInt8 = function readUInt8() {
+    this.size -= 1;
+    var first = this.buffers[0];
+    var r = first[this.offset];
+    if (++this.offset === first.length) {
+      this.offset = 0;
+      this.buffers.shift();
+    }
+    return r;
+  };
+  OffsetBuffer.prototype.readUInt16LE = function readUInt16LE() {
+    var first = this.buffers[0];
+    this.size -= 2;
+    var r;
+    var shift;
+    if (first.length - this.offset >= 2) {
+      r = first.readUInt16LE(this.offset);
+      shift = 0;
+      this.offset += 2;
+    } else {
+      r = first[this.offset] | this.buffers[1][0] << 8;
+      shift = 1;
+      this.offset = 1;
+    }
+    if (this.offset === this.buffers[shift].length) {
+      this.offset = 0;
+      shift++;
+    }
+    if (shift !== 0)
+      this.buffers = this.buffers.slice(shift);
+    return r;
+  };
+  OffsetBuffer.prototype.readUInt24LE = function readUInt24LE() {
+    var first = this.buffers[0];
+    var r;
+    var shift;
+    var firstHas = first.length - this.offset;
+    if (firstHas >= 3) {
+      r = first.readUInt16LE(this.offset) | first[this.offset + 2] << 16;
+      shift = 0;
+      this.offset += 3;
+    } else if (firstHas >= 2) {
+      r = first.readUInt16LE(this.offset) | this.buffers[1][0] << 16;
+      shift = 1;
+      this.offset = 1;
+    } else {
+      r = first[this.offset];
+      this.offset = 0;
+      this.buffers.shift();
+      this.size -= 1;
+      r |= this.readUInt16LE() << 8;
+      return r;
+    }
+    this.size -= 3;
+    if (this.offset === this.buffers[shift].length) {
+      this.offset = 0;
+      shift++;
+    }
+    if (shift !== 0)
+      this.buffers = this.buffers.slice(shift);
+    return r;
+  };
+  OffsetBuffer.prototype.readUInt32LE = function readUInt32LE() {
+    var first = this.buffers[0];
+    var r;
+    var shift;
+    var firstHas = first.length - this.offset;
+    if (firstHas >= 4) {
+      r = first.readUInt32LE(this.offset);
+      shift = 0;
+      this.offset += 4;
+    } else if (firstHas >= 3) {
+      r = (first.readUInt16LE(this.offset) | first[this.offset + 2] << 16) + this.buffers[1][0] * 16777216;
+      shift = 1;
+      this.offset = 1;
+    } else if (firstHas >= 2) {
+      r = first.readUInt16LE(this.offset);
+      this.offset = 0;
+      this.buffers.shift();
+      this.size -= 2;
+      r += this.readUInt16LE() * 65536;
+      return r;
+    } else {
+      r = first[this.offset];
+      this.offset = 0;
+      this.buffers.shift();
+      this.size -= 1;
+      r += this.readUInt24LE() * 256;
+      return r;
+    }
+    this.size -= 4;
+    if (this.offset === this.buffers[shift].length) {
+      this.offset = 0;
+      shift++;
+    }
+    if (shift !== 0)
+      this.buffers = this.buffers.slice(shift);
+    return r;
+  };
+  OffsetBuffer.prototype.readUInt16BE = function readUInt16BE() {
+    var r = this.readUInt16LE();
+    return (r & 255) << 8 | r >> 8;
+  };
+  OffsetBuffer.prototype.readUInt24BE = function readUInt24BE() {
+    var r = this.readUInt24LE();
+    return (r & 255) << 16 | (r >> 8 & 255) << 8 | r >> 16;
+  };
+  OffsetBuffer.prototype.readUInt32BE = function readUInt32BE() {
+    var r = this.readUInt32LE();
+    return ((r & 255) << 24 | (r >>> 8 & 255) << 16 | (r >>> 16 & 255) << 8 | r >>> 24) >>> 0;
+  };
+  function signedInt8(num) {
+    if (num >= 128)
+      return -(255 ^ num) - 1;
+    else
+      return num;
+  }
+  OffsetBuffer.prototype.peekInt8 = function peekInt8() {
+    return signedInt8(this.peekUInt8());
+  };
+  OffsetBuffer.prototype.readInt8 = function readInt8() {
+    return signedInt8(this.readUInt8());
+  };
+  function signedInt16(num) {
+    if (num >= 32768)
+      return -(65535 ^ num) - 1;
+    else
+      return num;
+  }
+  OffsetBuffer.prototype.readInt16BE = function readInt16BE() {
+    return signedInt16(this.readUInt16BE());
+  };
+  OffsetBuffer.prototype.readInt16LE = function readInt16LE() {
+    return signedInt16(this.readUInt16LE());
+  };
+  function signedInt24(num) {
+    if (num >= 8388608)
+      return -(16777215 ^ num) - 1;
+    else
+      return num;
+  }
+  OffsetBuffer.prototype.readInt24BE = function readInt24BE() {
+    return signedInt24(this.readUInt24BE());
+  };
+  OffsetBuffer.prototype.readInt24LE = function readInt24LE() {
+    return signedInt24(this.readUInt24LE());
+  };
+  function signedInt32(num) {
+    if (num >= 2147483648)
+      return -(4294967295 ^ num) - 1;
+    else
+      return num;
+  }
+  OffsetBuffer.prototype.readInt32BE = function readInt32BE() {
+    return signedInt32(this.readUInt32BE());
+  };
+  OffsetBuffer.prototype.readInt32LE = function readInt32LE() {
+    return signedInt32(this.readUInt32LE());
+  };
+});
+
+// ../../../../node_modules/postgres-bytea/decoder.js
+var require_decoder = __commonJS((exports, module) => {
+  var BufferList = require_obuf();
+  var { Transform } = __require("stream");
+  var State = {
+    READ_PREFIX: 1,
+    READ_DATA: 2
+  };
+
+  class ByteaDecoder extends Transform {
+    constructor() {
+      super();
+      this._incomingChunks = new BufferList;
+      this._state = State.READ_PREFIX;
+    }
+    _transform(chunk, encoding, callback) {
+      this._incomingChunks.push(chunk);
+      while (true) {
+        if (this._state === State.READ_PREFIX) {
+          if (this._incomingChunks.has(3)) {
+            const prefix = this._incomingChunks.take(3);
+            const prefixString = prefix.toString();
+            if (prefixString !== "\\\\x") {
+              return this.emit("error", new Error(`Expected double-escaped postgres bytea hex format prefix, received: '${prefixString}'`));
+            }
+            this._state = State.READ_DATA;
+            continue;
+          } else {
+            break;
+          }
+        }
+        if (this._state === State.READ_DATA) {
+          if (this._incomingChunks.size >= 2) {
+            let evenChunk;
+            const isEvenLength = this._incomingChunks.size % 2 === 0;
+            if (isEvenLength) {
+              evenChunk = this._incomingChunks.take(this._incomingChunks.size);
+            } else {
+              evenChunk = this._incomingChunks.take(this._incomingChunks.size - 1);
+            }
+            this.push(Buffer.from(evenChunk.toString(), "hex"));
+          }
+          break;
+        }
+      }
+      callback();
+    }
+  }
+  module.exports = ByteaDecoder;
+});
+
+// ../../../../node_modules/postgres-bytea/index.js
+var require_postgres_bytea = __commonJS((exports, module) => {
+  exports = module.exports = require_decode();
+  exports.Encoder = require_encoder();
+  exports.Decoder = require_decoder();
+});
+
+// ../../../../node_modules/postgres-range/index.js
+var require_postgres_range = __commonJS((exports, module) => {
+  var RANGE_EMPTY = 1 << 1;
+  var RANGE_LB_INC = 1 << 2;
+  var RANGE_UB_INC = 1 << 3;
+  var RANGE_LB_INF = 1 << 4;
+  var RANGE_UB_INF = 1 << 5;
+  var EMPTY = "empty";
+  var INFINITY = "infinity";
+
+  class RangeError2 extends Error {
+  }
+
+  class Range {
+    constructor(lower, upper, mask = 0) {
+      this.lower = lower;
+      this.upper = upper;
+      this.mask = mask;
+    }
+    hasMask(flag) {
+      return (this.mask & flag) === flag;
+    }
+    isEmpty() {
+      return this.hasMask(RANGE_EMPTY);
+    }
+    isBounded() {
+      return !this.hasMask(RANGE_LB_INF) && !this.hasMask(RANGE_UB_INF);
+    }
+    isLowerBoundClosed() {
+      return this.hasLowerBound() && this.hasMask(RANGE_LB_INC);
+    }
+    isUpperBoundClosed() {
+      return this.hasUpperBound() && this.hasMask(RANGE_UB_INC);
+    }
+    hasLowerBound() {
+      return !this.hasMask(RANGE_LB_INF);
+    }
+    hasUpperBound() {
+      return !this.hasMask(RANGE_UB_INF);
+    }
+    containsPoint(point) {
+      const l = this.hasLowerBound();
+      const u = this.hasUpperBound();
+      if (l && u) {
+        const inLower = this.hasMask(RANGE_LB_INC) ? this.lower <= point : this.lower < point;
+        const inUpper = this.hasMask(RANGE_UB_INC) ? this.upper >= point : this.upper > point;
+        return inLower && inUpper;
+      } else if (l) {
+        return this.hasMask(RANGE_LB_INC) ? this.lower <= point : this.lower < point;
+      } else if (u) {
+        return this.hasMask(RANGE_UB_INC) ? this.upper >= point : this.upper > point;
+      }
+      return true;
+    }
+    containsRange(range) {
+      return (!range.hasLowerBound() || this.containsPoint(range.lower)) && (!range.hasUpperBound() || this.containsPoint(range.upper));
+    }
+    toPostgres(prepareValue) {
+      return serialize(this, prepareValue);
+    }
+  }
+  function parse(input, transform = (x) => x) {
+    input = input.trim();
+    if (input === EMPTY) {
+      return new Range(null, null, RANGE_EMPTY);
+    }
+    let ptr = 0;
+    let mask = 0;
+    if (input[ptr] === "[") {
+      mask |= RANGE_LB_INC;
+      ptr += 1;
+    } else if (input[ptr] === "(") {
+      ptr += 1;
+    } else {
+      throw new RangeError2(`Unexpected character '${input[ptr]}'. Position: ${ptr}`);
+    }
+    const lb = parseBound(input, ptr);
+    if (lb.infinite) {
+      mask |= RANGE_LB_INF;
+    }
+    ptr = lb.ptr;
+    if (input[ptr] === ",") {
+      ptr += 1;
+    } else {
+      throw new RangeError2(`Expected comma as the delimiter, got '${input[ptr]}'. Position: ${ptr}`);
+    }
+    const ub = parseBound(input, ptr);
+    if (ub.infinite) {
+      mask |= RANGE_UB_INF;
+    }
+    ptr = ub.ptr;
+    if (input[ptr] === "]") {
+      mask |= RANGE_UB_INC;
+      ptr += 1;
+    } else if (input[ptr] === ")") {
+      ptr += 1;
+    } else {
+      throw new RangeError2(`Unexpected character '${input[ptr]}'. Position: ${ptr}`);
+    }
+    let lower = null;
+    let upper = null;
+    if ((mask & RANGE_LB_INF) !== RANGE_LB_INF) {
+      lower = transform(lb.value);
+    }
+    if ((mask & RANGE_UB_INF) !== RANGE_UB_INF) {
+      upper = transform(ub.value);
+    }
+    return new Range(lower, upper, mask);
+  }
+  function parseBound(input, ptr) {
+    if (input[ptr] === "," || input[ptr] === ")" || input[ptr] === "]") {
+      return {
+        infinite: true,
+        value: null,
+        ptr
+      };
+    } else {
+      let inQuote = false;
+      let value = "";
+      let pos = ptr;
+      while (inQuote || !(input[ptr] === "," || input[ptr] === ")" || input[ptr] === "]")) {
+        const ch = input[ptr++];
+        if (ch === undefined) {
+          throw new RangeError2(`Unexpected end of input. Position: ${ptr}`);
+        }
+        if (ch === "\\") {
+          if (input[ptr] === undefined) {
+            throw new RangeError2(`Unexpected end of input. Position: ${ptr}`);
+          }
+          value += input.slice(pos, ptr - 1) + input[ptr];
+          ptr += 1;
+          pos = ptr;
+        } else if (ch === '"') {
+          if (!inQuote) {
+            inQuote = true;
+            pos += 1;
+          } else if (input[ptr] === '"') {
+            value += input.slice(pos, ptr - 1) + input[ptr];
+            ptr += 1;
+            pos = ptr;
+          } else {
+            inQuote = false;
+            value += input.slice(pos, ptr - 1);
+            pos = ptr + 1;
+          }
+        }
+      }
+      if (ptr > pos) {
+        value += input.slice(pos, ptr);
+      }
+      if (value.endsWith(INFINITY)) {
+        return {
+          infinite: true,
+          value: null,
+          ptr
+        };
+      }
+      return {
+        infinite: false,
+        value,
+        ptr
+      };
+    }
+  }
+  function serialize(range, format = (x) => x) {
+    if (range.hasMask(RANGE_EMPTY)) {
+      return EMPTY;
+    }
+    let s = "";
+    s += range.isLowerBoundClosed() ? "[" : "(";
+    s += range.hasLowerBound() ? serializeBound(format(range.lower)) : "";
+    s += ",";
+    s += range.hasUpperBound() ? serializeBound(format(range.upper)) : "";
+    s += range.isUpperBoundClosed() ? "]" : ")";
+    return s;
+  }
+  function serializeBound(bnd) {
+    let needsQuotes = false;
+    let pos = 0;
+    let value = "";
+    if (typeof bnd !== "string") {
+      if (typeof bnd === "number" || typeof bnd === "bigint")
+        return bnd.toString();
+      bnd = String(bnd);
+    }
+    if (bnd === null || bnd.length === 0) {
+      return '""';
+    }
+    bnd = bnd.trim();
+    for (let i = 0;i < bnd.length; i++) {
+      const ch = bnd[i];
+      if (ch === '"' || ch === "\\" || ch === "(" || ch === ")" || ch === "[" || ch === "]" || ch === "," || ch === " ") {
+        needsQuotes = true;
+        break;
+      }
+    }
+    if (needsQuotes) {
+      value += '"';
+    }
+    let ptr = 0;
+    for (;ptr < bnd.length; ptr++) {
+      const ch = bnd[ptr];
+      if (ch === '"' || ch === "\\") {
+        value += bnd.slice(pos, ptr + 1) + ch;
+        pos = ptr + 1;
+      }
+    }
+    if (ptr > pos) {
+      value += bnd.slice(pos, ptr);
+    }
+    if (needsQuotes) {
+      value += '"';
+    }
+    return value;
+  }
+  module.exports = {
+    Range,
+    RangeError: RangeError2,
+    RANGE_EMPTY,
+    RANGE_LB_INC,
+    RANGE_UB_INC,
+    RANGE_LB_INF,
+    RANGE_UB_INF,
+    parse,
+    serialize
   };
 });
 
-// ../../../../node_modules/pg/node_modules/pg-types/lib/textParsers.js
+// ../../../../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 parseTimestampTz = 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);
-    };
-  }
+  var range = require_postgres_range();
   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));
+    return array.parse(value, Number);
   }
   function parseBigIntegerArray(value) {
-    if (!value)
-      return null;
-    return array.parse(value, allowNull(function(entry) {
+    return array.parse(value, function(entry) {
       return parseBigInteger(entry).trim();
-    }));
+    });
   }
   var parsePointArray = function(value) {
-    if (!value) {
-      return null;
-    }
-    var p2 = arrayParser.create(value, function(entry) {
-      if (entry !== null) {
-        entry = parsePoint(entry);
-      }
-      return entry;
-    });
-    return p2.parse();
+    return array.parse(value, parsePoint);
   };
   var parseFloatArray = function(value) {
-    if (!value) {
-      return null;
-    }
-    var p2 = arrayParser.create(value, function(entry) {
-      if (entry !== null) {
-        entry = parseFloat(entry);
-      }
-      return entry;
-    });
-    return p2.parse();
+    return array.parse(value, parseFloat);
   };
   var parseStringArray = function(value) {
-    if (!value) {
-      return null;
-    }
-    var p2 = arrayParser.create(value);
-    return p2.parse();
+    return array.parse(value, undefined);
   };
-  var parseDateArray = function(value) {
-    if (!value) {
-      return null;
-    }
-    var p2 = arrayParser.create(value, function(entry) {
-      if (entry !== null) {
-        entry = parseDate(entry);
-      }
-      return entry;
-    });
-    return p2.parse();
+  var parseTimestamp = function(value) {
+    const utc = value.endsWith(" BC") ? value.slice(0, -3) + "Z BC" : value + "Z";
+    return parseTimestampTz(utc);
+  };
+  var parseTimestampArray = function(value) {
+    return array.parse(value, parseTimestamp);
+  };
+  var parseTimestampTzArray = function(value) {
+    return array.parse(value, parseTimestampTz);
   };
   var parseIntervalArray = function(value) {
-    if (!value) {
-      return null;
-    }
-    var p2 = arrayParser.create(value, function(entry) {
-      if (entry !== null) {
-        entry = parseInterval(entry);
-      }
-      return entry;
-    });
-    return p2.parse();
+    return array.parse(value, parseInterval);
   };
   var parseByteAArray = function(value) {
-    if (!value) {
-      return null;
-    }
-    return array.parse(value, allowNull(parseByteA));
-  };
-  var parseInteger = function(value) {
-    return parseInt(value, 10);
+    return array.parse(value, parseByteA);
   };
   var parseBigInteger = function(value) {
-    var valStr = String(value);
+    const 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));
+    return array.parse(value, JSON.parse);
   };
   var parsePoint = function(value) {
     if (value[0] !== "(") {
@@ -57302,10 +57996,10 @@ var require_textParsers = __commonJS((exports, module) => {
     if (value[0] !== "<" && value[1] !== "(") {
       return null;
     }
-    var point = "(";
-    var radius = "";
-    var pointParsed = false;
-    for (var i = 2;i < value.length - 1; i++) {
+    let point = "(";
+    let radius = "";
+    let pointParsed = false;
+    for (let i = 2;i < value.length - 1; i++) {
       if (!pointParsed) {
         point += value[i];
       }
@@ -57320,21 +58014,35 @@ var require_textParsers = __commonJS((exports, module) => {
       }
       radius += value[i];
     }
-    var result = parsePoint(point);
+    const result = parsePoint(point);
     result.radius = parseFloat(radius);
     return result;
   };
+  function parseInt4Range(raw) {
+    return range.parse(raw, Number);
+  }
+  function parseNumRange(raw) {
+    return range.parse(raw, parseFloat);
+  }
+  function parseInt8Range(raw) {
+    return range.parse(raw, parseBigInteger);
+  }
+  function parseTimestampRange(raw) {
+    return range.parse(raw, parseTimestamp);
+  }
+  function parseTimestampTzRange(raw) {
+    return range.parse(raw, parseTimestampTz);
+  }
   var init = function(register) {
     register(20, parseBigInteger);
-    register(21, parseInteger);
-    register(23, parseInteger);
-    register(26, parseInteger);
+    register(21, Number);
+    register(23, Number);
+    register(26, Number);
     register(700, parseFloat);
     register(701, parseFloat);
     register(16, parseBool);
-    register(1082, parseDate);
-    register(1114, parseDate);
-    register(1184, parseDate);
+    register(1114, parseTimestamp);
+    register(1184, parseTimestampTz);
     register(600, parsePoint);
     register(651, parseStringArray);
     register(718, parseCircle);
@@ -57347,24 +58055,30 @@ var require_textParsers = __commonJS((exports, module) => {
     register(1017, parsePointArray);
     register(1021, parseFloatArray);
     register(1022, parseFloatArray);
-    register(1231, parseFloatArray);
+    register(1231, parseStringArray);
     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(1115, parseTimestampArray);
+    register(1182, parseStringArray);
+    register(1185, parseTimestampTzArray);
     register(1186, parseInterval);
     register(1187, parseIntervalArray);
     register(17, parseByteA);
-    register(114, JSON.parse.bind(JSON));
-    register(3802, JSON.parse.bind(JSON));
+    register(114, JSON.parse);
+    register(3802, JSON.parse);
     register(199, parseJsonArray);
     register(3807, parseJsonArray);
+    register(3904, parseInt4Range);
+    register(3906, parseNumRange);
     register(3907, parseStringArray);
+    register(3908, parseTimestampRange);
+    register(3910, parseTimestampTzRange);
+    register(3912, range.parse);
+    register(3926, parseInt8Range);
     register(2951, parseStringArray);
     register(791, parseStringArray);
     register(1183, parseStringArray);
@@ -57452,168 +58166,170 @@ var require_pg_int8 = __commonJS((exports, module) => {
   module.exports = readInt8;
 });
 
-// ../../../../node_modules/pg/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;
+// ../../../../node_modules/pg-numeric/index.js
+var require_pg_numeric = __commonJS((exports, module) => {
+  var readDigit = (buffer, index) => {
+    const digit = buffer.readUInt16BE(8 + 2 * index);
+    if (digit > 9999) {
+      throw new RangeError("Invalid numeric digit: " + digit);
     }
-    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);
+    return digit;
+  };
+  var readNumeric = (buffer) => {
+    const ndigits = buffer.readUInt16BE(0);
+    let weight = buffer.readInt16BE(2);
+    const sign = buffer.readUInt16BE(4);
+    const dscale = buffer.readUInt16BE(6);
+    let signText;
+    let isNegativeZero;
+    switch (sign) {
+      case 0:
+        signText = "";
+        isNegativeZero = false;
+        break;
+      case 16384:
+        signText = "-";
+        isNegativeZero = true;
+        break;
+      case 49152:
+        return "NaN";
+      default:
+        throw new RangeError("Invalid numeric sign: 0x" + sign.toString(16));
     }
-    var lastBits = (bits + offset) % 8;
-    if (lastBits > 0) {
-      result = callback(result, inv(data[bytes]) >> 8 - lastBits, lastBits);
+    if (2 * ndigits !== buffer.length - 8) {
+      throw new RangeError("Invalid numeric length: " + buffer.length + " bytes of data representing " + ndigits + " digits");
     }
-    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;
+    if (dscale > 16383) {
+      throw new RangeError("Invalid numeric dscale: 0x" + dscale.toString(16));
     }
-    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;
+    let result = signText;
+    let i = 0;
+    integerPart: {
+      for (;; ) {
+        if (i >= ndigits) {
+          weight = -1;
+        }
+        if (weight < 0) {
+          result += "0";
+          break integerPart;
+        }
+        const digit = readDigit(buffer, i);
+        i++;
+        weight--;
+        if (digit !== 0) {
+          isNegativeZero = false;
+          result += String(digit);
+          break;
         }
       }
-      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;
+      while (weight >= 0 && i < ndigits) {
+        const digit = readDigit(buffer, i);
+        i++;
+        weight--;
+        result += String(1e4 + digit).substring(1);
+      }
+      while (weight >= 0) {
+        result += "0000";
+        weight--;
+      }
+    }
+    fractionalPart:
+      if (dscale !== 0) {
+        result += ".";
+        const omitted = -1 - weight;
+        if (omitted > 0) {
+          if (4 * omitted > dscale) {
+            result += "0".repeat(dscale);
+            break fractionalPart;
+          }
+          result += "0".repeat(4 * omitted);
+        }
+        while (-4 * weight <= dscale) {
+          const digit = i < ndigits ? readDigit(buffer, i) : 0;
+          i++;
+          weight--;
+          if (isNegativeZero && digit !== 0) {
+            isNegativeZero = false;
+          }
+          result += String(1e4 + digit).substring(1);
+        }
+        {
+          const digit = i < ndigits ? readDigit(buffer, i) : 0;
+          result += String(1e4 + digit).substr(1, dscale % 4);
+          if (isNegativeZero && digit >= Math.pow(10, 4 - dscale % 4)) {
+            isNegativeZero = false;
+          }
+        }
       }
-      return NaN;
-    }
-    return (sign === 0 ? 1 : -1) * Math.pow(2, exponent - bias) * mantissa;
+    return isNegativeZero ? result.substring(1) : result;
   };
+  module.exports = readNumeric;
+});
+
+// ../../../../node_modules/pg-types/lib/binaryParsers.js
+var require_binaryParsers = __commonJS((exports, module) => {
+  var parseInt64 = require_pg_int8();
+  var parseNumeric = require_pg_numeric();
   var parseInt16 = function(value) {
-    if (parseBits(value, 1) == 1) {
-      return -1 * (parseBits(value, 15, 1, true) + 1);
-    }
-    return parseBits(value, 15, 1);
+    return value.readInt16BE(0);
   };
   var parseInt32 = function(value) {
-    if (parseBits(value, 1) == 1) {
-      return -1 * (parseBits(value, 31, 1, true) + 1);
-    }
-    return parseBits(value, 31, 1);
+    return value.readInt32BE(0);
   };
   var parseFloat32 = function(value) {
-    return parseFloatFromBits(value, 23, 8);
+    return value.readFloatBE(0);
   };
   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;
+    return value.readDoubleBE(0);
   };
-  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;
-    };
+  var parseTimestampUTC = function(value) {
+    const rawValue = 4294967296 * value.readInt32BE(0) + value.readUInt32BE(4);
+    const result = new Date(Math.round(rawValue / 1000) + 946684800000);
     return result;
   };
   var parseArray = function(value) {
-    var dim2 = 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 < dim2; 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) {
+    const dim2 = value.readInt32BE(0);
+    const elementType = value.readUInt32BE(8);
+    let offset = 12;
+    const dims = [];
+    for (let i = 0;i < dim2; i++) {
+      dims[i] = value.readInt32BE(offset);
+      offset += 4;
+      offset += 4;
+    }
+    const parseElement = function(elementType2) {
+      const length = value.readInt32BE(offset);
+      offset += 4;
+      if (length === -1) {
         return null;
       }
-      var result;
-      if (elementType2 == 23 || elementType2 == 20) {
-        result = parseBits(value, length * 8, offset);
-        offset += length * 8;
+      let result;
+      if (elementType2 === 23) {
+        result = value.readInt32BE(offset);
+        offset += length;
+        return result;
+      } else if (elementType2 === 20) {
+        result = parseInt64(value.slice(offset, offset += length));
         return result;
-      } else if (elementType2 == 25) {
-        result = value.toString(this.encoding, offset >> 3, (offset += length << 3) >> 3);
+      } else if (elementType2 === 25) {
+        result = value.toString("utf8", offset, offset += length);
         return result;
       } else {
-        console.log("ERROR: ElementType not implemented: " + elementType2);
+        throw new Error("ElementType not implemented: " + elementType2);
       }
     };
-    var parse = function(dimension, elementType2) {
-      var array = [];
-      var i2;
+    const parse = function(dimension, elementType2) {
+      const array = [];
+      let i;
       if (dimension.length > 1) {
-        var count = dimension.shift();
-        for (i2 = 0;i2 < count; i2++) {
-          array[i2] = parse(dimension, elementType2);
+        const count = dimension.shift();
+        for (i = 0;i < count; i++) {
+          array[i] = parse(dimension, elementType2);
         }
         dimension.unshift(count);
       } else {
-        for (i2 = 0;i2 < dimension[0]; i2++) {
-          array[i2] = parseElement(elementType2);
+        for (i = 0;i < dimension[0]; i++) {
+          array[i] = parseElement(elementType2);
         }
       }
       return array;
@@ -57624,9 +58340,7 @@ var require_binaryParsers = __commonJS((exports, module) => {
     return value.toString("utf8");
   };
   var parseBool = function(value) {
-    if (value === null)
-      return null;
-    return parseBits(value, 8) > 0;
+    return value[0] !== 0;
   };
   var init = function(register) {
     register(20, parseInt64);
@@ -57637,8 +58351,8 @@ var require_binaryParsers = __commonJS((exports, module) => {
     register(700, parseFloat32);
     register(701, parseFloat64);
     register(16, parseBool);
-    register(1114, parseDate.bind(null, false));
-    register(1184, parseDate.bind(null, true));
+    register(1114, parseTimestampUTC);
+    register(1184, parseTimestampUTC);
     register(1000, parseArray);
     register(1007, parseArray);
     register(1016, parseArray);
@@ -57651,7 +58365,7 @@ var require_binaryParsers = __commonJS((exports, module) => {
   };
 });
 
-// ../../../../node_modules/pg/node_modules/pg-types/lib/builtins.js
+// ../../../../node_modules/pg-types/lib/builtins.js
 var require_builtins = __commonJS((exports, module) => {
   module.exports = {
     BOOL: 16,
@@ -57717,15 +58431,13 @@ var require_builtins = __commonJS((exports, module) => {
   };
 });
 
-// ../../../../node_modules/pg/node_modules/pg-types/index.js
+// ../../../../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: {},
@@ -57742,10 +58454,13 @@ var require_pg_types = __commonJS((exports) => {
     return typeParsers[format][oid] || noParse;
   }
   function setTypeParser(oid, format, parseFn) {
-    if (typeof format == "function") {
+    if (typeof format === "function") {
       parseFn = format;
       format = "text";
     }
+    if (!Number.isInteger(oid)) {
+      throw new TypeError("oid must be an integer: " + oid);
+    }
     typeParsers[format][oid] = parseFn;
   }
   textParsers.init(function(oid, converter) {