postgrejs 2.12.0

package/cjs/data-types/point-type.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayPointType = exports.PointType = void 0;
+const constants_js_1 = require("../constants.js");
+const POINT_PATTERN1 = /^\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\)$/;
+const POINT_PATTERN2 = /^(-?\d+\.?\d*) *, *(-?\d+\.?\d*)$/;
+exports.PointType = {
+    name: 'point',
+    oid: constants_js_1.DataTypeOIDs.point,
+    jsType: 'object',
+    parseBinary(v) {
+        return {
+            x: v.readDoubleBE(0),
+            y: v.readDoubleBE(8),
+        };
+    },
+    encodeBinary(buf, v) {
+        buf.writeDoubleBE(v.x);
+        buf.writeDoubleBE(v.y);
+    },
+    parseText(v) {
+        const m = v.match(POINT_PATTERN1) || v.match(POINT_PATTERN2);
+        if (!m)
+            return undefined;
+        return {
+            x: parseFloat(m[1]),
+            y: parseFloat(m[2]),
+        };
+    },
+    isType(v) {
+        return typeof v === 'object' && Object.keys(v).length === 2 && typeof v.x === 'number' && typeof v.y === 'number';
+    },
+};
+exports.ArrayPointType = {
+    ...exports.PointType,
+    name: '_point',
+    oid: constants_js_1.DataTypeOIDs._point,
+    elementsOID: constants_js_1.DataTypeOIDs.point,
+};

package/cjs/data-types/time-type.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayTimeType = exports.TimeType = void 0;
+const constants_js_1 = require("../constants.js");
+const parse_time_js_1 = require("../util/parse-time.js");
+const timeMul = 4294967296;
+exports.TimeType = {
+    name: 'time',
+    oid: constants_js_1.DataTypeOIDs.time,
+    jsType: 'string',
+    parseBinary(v, options) {
+        const fetchAsString = options.fetchAsString && options.fetchAsString.includes(constants_js_1.DataTypeOIDs.time);
+        const hi = v.readInt32BE();
+        const lo = v.readUInt32BE(4);
+        let d = new Date((lo + hi * timeMul) / 1000);
+        if (fetchAsString || !options.utcDates)
+            d = new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
+        return fetchAsString ? dateToTimeString(d) : d;
+    },
+    encodeBinary(buf, v, options) {
+        if (typeof v === 'string')
+            v = (0, parse_time_js_1.parseTime)(v, false, options.utcDates);
+        if (!(v instanceof Date))
+            v = new Date(v);
+        // Postgresql ignores timezone data so we are
+        let n = options.utcDates ? v.getTime() : v.getTime() - v.getTimezoneOffset() * 60 * 1000;
+        n = n * 1000;
+        const hi = Math.floor(n / timeMul);
+        const lo = n - hi * timeMul;
+        buf.writeInt32BE(hi);
+        buf.writeUInt32BE(lo);
+    },
+    parseText(v, options) {
+        if (options.fetchAsString && options.fetchAsString.includes(constants_js_1.DataTypeOIDs.time))
+            return v;
+        return (0, parse_time_js_1.parseTime)(v, false, options.utcDates);
+    },
+    isType(v) {
+        return ((v instanceof Date && v.getFullYear() === 1970 && v.getMonth() === 0 && v.getDate() === 1) ||
+            (typeof v === 'string' && parse_time_js_1.STRICT_TIME_PATTERN.test(v)));
+    },
+};
+function padZero(v) {
+    return v < 9 ? '0' + v : '' + v;
+}
+function dateToTimeString(d) {
+    return padZero(d.getHours()) + ':' + padZero(d.getMinutes()) + ':' + padZero(d.getSeconds());
+}
+exports.ArrayTimeType = {
+    ...exports.TimeType,
+    name: '_time',
+    oid: constants_js_1.DataTypeOIDs._time,
+    elementsOID: constants_js_1.DataTypeOIDs.time,
+};

package/cjs/data-types/timestamp-type.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayTimestampType = exports.TimestampType = void 0;
+const constants_js_1 = require("../constants.js");
+const parse_datetime_js_1 = require("../util/parse-datetime.js");
+const timeShift = 946684800000;
+const timeMul = 4294967296;
+exports.TimestampType = {
+    name: 'timestamp',
+    oid: constants_js_1.DataTypeOIDs.timestamp,
+    jsType: 'Date',
+    parseBinary(v, options) {
+        const fetchAsString = options.fetchAsString && options.fetchAsString.includes(constants_js_1.DataTypeOIDs.timestamp);
+        const hi = v.readInt32BE();
+        const lo = v.readUInt32BE(4);
+        if (lo === 0xffffffff && hi === 0x7fffffff)
+            return fetchAsString ? 'infinity' : Infinity;
+        if (lo === 0x00000000 && hi === -0x80000000)
+            return fetchAsString ? '-infinity' : -Infinity;
+        // Shift from 2000 to 1970
+        let d = new Date((lo + hi * timeMul) / 1000 + timeShift);
+        if (fetchAsString || !options.utcDates)
+            d = new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
+        return fetchAsString ? dateToTimestampString(d) : d;
+    },
+    encodeBinary(buf, v, options) {
+        if (typeof v === 'string')
+            v = (0, parse_datetime_js_1.parseDateTime)(v, true, false, options.utcDates);
+        if (v === Infinity) {
+            buf.writeInt32BE(0x7fffffff); // hi
+            buf.writeUInt32BE(0xffffffff); // lo
+            return;
+        }
+        if (v === -Infinity) {
+            buf.writeInt32BE(-0x80000000); // hi
+            buf.writeUInt32BE(0x00000000); // lo
+            return;
+        }
+        if (!(v instanceof Date))
+            v = new Date(v);
+        // Postgresql ignores timezone data so we are
+        let n = options.utcDates ? v.getTime() : v.getTime() - v.getTimezoneOffset() * 60 * 1000;
+        n = (n - timeShift) * 1000;
+        const hi = Math.floor(n / timeMul);
+        const lo = n - hi * timeMul;
+        buf.writeInt32BE(hi);
+        buf.writeUInt32BE(lo);
+    },
+    parseText(v, options) {
+        if (options.fetchAsString && options.fetchAsString.includes(constants_js_1.DataTypeOIDs.timestamp))
+            return v;
+        return (0, parse_datetime_js_1.parseDateTime)(v, true, false, options.utcDates);
+    },
+    isType(v) {
+        return (v instanceof Date &&
+            !(v.getFullYear() === 1970 && v.getMonth() === 0 && v.getDate() === 1) &&
+            !(v.getHours() === 0 && v.getMinutes() === 0 && v.getSeconds() === 0 && v.getMilliseconds() === 0));
+    },
+};
+function padZero(v) {
+    return v < 9 ? '0' + v : '' + v;
+}
+function dateToTimestampString(d) {
+    return (d.getFullYear() +
+        '-' +
+        padZero(d.getMonth() + 1) +
+        '-' +
+        padZero(d.getDate()) +
+        ' ' +
+        padZero(d.getHours()) +
+        ':' +
+        padZero(d.getMinutes()) +
+        ':' +
+        padZero(d.getSeconds()));
+}
+exports.ArrayTimestampType = {
+    ...exports.TimestampType,
+    name: '_timestamp',
+    oid: constants_js_1.DataTypeOIDs._timestamp,
+    elementsOID: constants_js_1.DataTypeOIDs.timestamp,
+};

package/cjs/data-types/timestamptz-type.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayTimestamptzType = exports.TimestamptzType = void 0;
+const constants_js_1 = require("../constants.js");
+const parse_datetime_js_1 = require("../util/parse-datetime.js");
+const timeShift = 946684800000;
+const timeMul = 4294967296;
+exports.TimestamptzType = {
+    name: 'timestamptz',
+    oid: constants_js_1.DataTypeOIDs.timestamptz,
+    jsType: 'Date',
+    parseBinary(v, options) {
+        const fetchAsString = options.fetchAsString && options.fetchAsString.includes(constants_js_1.DataTypeOIDs.timestamptz);
+        const hi = v.readInt32BE();
+        const lo = v.readUInt32BE(4);
+        if (lo === 0xffffffff && hi === 0x7fffffff)
+            return fetchAsString ? 'infinity' : Infinity;
+        if (lo === 0x00000000 && hi === -0x80000000)
+            return fetchAsString ? '-infinity' : -Infinity;
+        // Shift from 2000 to 1970
+        let d = new Date((lo + hi * timeMul) / 1000 + timeShift);
+        if (fetchAsString || !options.utcDates)
+            d = new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
+        return fetchAsString ? dateToTimestamptzString(d) : d;
+    },
+    encodeBinary(buf, v, options) {
+        if (typeof v === 'string')
+            v = (0, parse_datetime_js_1.parseDateTime)(v, true, true, options.utcDates);
+        if (v === Infinity) {
+            buf.writeInt32BE(0x7fffffff); // hi
+            buf.writeUInt32BE(0xffffffff); // lo
+            return;
+        }
+        if (v === -Infinity) {
+            buf.writeInt32BE(-0x80000000); // hi
+            buf.writeUInt32BE(0x00000000); // lo
+            return;
+        }
+        if (!(v instanceof Date))
+            v = new Date(v);
+        let n = v.getTime();
+        n = (n - timeShift) * 1000;
+        const hi = Math.floor(n / timeMul);
+        const lo = n - hi * timeMul;
+        buf.writeInt32BE(hi);
+        buf.writeUInt32BE(lo);
+    },
+    parseText(v, options) {
+        const d = (0, parse_datetime_js_1.parseDateTime)(v, true, true, options.utcDates);
+        if (options.fetchAsString && options.fetchAsString.includes(constants_js_1.DataTypeOIDs.timestamptz)) {
+            if (d instanceof Date)
+                return dateToTimestamptzString(d);
+            if (d === Infinity)
+                return 'infinity';
+            if (d === -Infinity)
+                return '-infinity';
+            return '';
+        }
+        return d;
+    },
+    isType(v) {
+        return v instanceof Date;
+    },
+};
+function dateToTimestamptzString(d) {
+    return d.toISOString().replace('T', ' ');
+}
+exports.ArrayTimestamptzType = {
+    ...exports.TimestamptzType,
+    name: '_timestamptz',
+    oid: constants_js_1.DataTypeOIDs._timestamptz,
+    elementsOID: constants_js_1.DataTypeOIDs.timestamptz,
+};

package/cjs/data-types/uuid-type.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayUuidType = exports.UuidType = void 0;
+const constants_js_1 = require("../constants.js");
+const GUID_PATTERN = /^[0-9a-fA-F]{8}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{12}$/;
+exports.UuidType = {
+    name: 'uuid',
+    oid: constants_js_1.DataTypeOIDs.uuid,
+    jsType: 'String',
+    parseBinary(v) {
+        return (v.toString('hex', 0, 4) +
+            '-' +
+            v.toString('hex', 4, 6) +
+            '-' +
+            v.toString('hex', 6, 8) +
+            '-' +
+            v.toString('hex', 8, 10) +
+            '-' +
+            v.toString('hex', 10, 16));
+    },
+    encodeBinary(buf, v) {
+        if (!GUID_PATTERN.test(v))
+            throw new Error(`"${v}" is not a valid guid value`);
+        const b = Buffer.from(v.replace(/-/g, ''), 'hex');
+        buf.writeBuffer(b);
+    },
+    parseText(v) {
+        return v;
+    },
+    isType(v) {
+        return typeof v === 'string' && GUID_PATTERN.test(v);
+    },
+};
+exports.ArrayUuidType = {
+    ...exports.UuidType,
+    name: '_uuid',
+    oid: constants_js_1.DataTypeOIDs._uuid,
+    elementsOID: constants_js_1.DataTypeOIDs.uuid,
+};

package/cjs/data-types/varchar-type.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayVarcharType = exports.VarcharType = void 0;
+const constants_js_1 = require("../constants.js");
+exports.VarcharType = {
+    name: 'varchar',
+    oid: constants_js_1.DataTypeOIDs.varchar,
+    jsType: 'string',
+    parseBinary(v) {
+        return v.toString('utf8');
+    },
+    encodeBinary(buf, v) {
+        buf.writeString('' + v, 'utf8');
+    },
+    parseText(v) {
+        return '' + v;
+    },
+    isType(v) {
+        return typeof v === 'string';
+    },
+};
+exports.ArrayVarcharType = {
+    ...exports.VarcharType,
+    name: '_varchar',
+    oid: constants_js_1.DataTypeOIDs._varchar,
+    elementsOID: constants_js_1.DataTypeOIDs.varchar,
+};

package/cjs/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants.js"), exports);
+__exportStar(require("./data-type-map.js"), exports);
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./connection/bind-param.js"), exports);
+__exportStar(require("./connection/connection.js"), exports);
+__exportStar(require("./connection/cursor.js"), exports);
+__exportStar(require("./connection/pool.js"), exports);
+__exportStar(require("./connection/prepared-statement.js"), exports);
+__exportStar(require("./interfaces/command-result.js"), exports);
+__exportStar(require("./interfaces/data-mapping-options.js"), exports);
+__exportStar(require("./interfaces/data-type.js"), exports);
+__exportStar(require("./interfaces/database-connection-params.js"), exports);
+__exportStar(require("./interfaces/field-info.js"), exports);
+__exportStar(require("./interfaces/query-options.js"), exports);
+__exportStar(require("./interfaces/query-result.js"), exports);
+__exportStar(require("./interfaces/script-execute-options.js"), exports);
+__exportStar(require("./interfaces/script-result.js"), exports);
+__exportStar(require("./interfaces/statement-prepare-options.js"), exports);
+__exportStar(require("./util/connection-config.js"), exports);
+__exportStar(require("./util/escape-literal.js"), exports);
+__exportStar(require("./util/parse-datetime.js"), exports);
+__exportStar(require("./util/stringify-arrayliteral.js"), exports);
+__exportStar(require("./util/stringify-for-sql.js"), exports);
+__exportStar(require("./protocol/smart-buffer.js"), exports);
+__exportStar(require("./protocol/database-error.js"), exports);

package/cjs/interfaces/command-result.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/interfaces/data-mapping-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/interfaces/data-type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/interfaces/database-connection-params.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/interfaces/field-info.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/interfaces/query-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/interfaces/query-result.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/interfaces/script-execute-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/interfaces/script-result.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/interfaces/statement-prepare-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/protocol/backend.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Backend = void 0;
+const buffer_reader_js_1 = require("./buffer-reader.js");
+const protocol_js_1 = require("./protocol.js");
+// 1 byte message type, 4 byte frame length
+const HEADER_LENGTH = 5;
+const ErrorFieldTypes = {
+    M: 'message',
+    S: 'severity',
+    V: 'severity',
+    C: 'code',
+    D: 'detail',
+    H: 'hint',
+    P: 'position',
+    p: 'internalPosition',
+    q: 'internalQuery',
+    W: 'where',
+    s: 'schema',
+    t: 'table',
+    c: 'column',
+    d: 'dataType',
+    n: 'constraint',
+    F: 'file',
+    L: 'line',
+    R: 'routine',
+};
+class Backend {
+    reset() {
+        this._buf = undefined;
+    }
+    parse(data, callback) {
+        if (this._buf) {
+            data = Buffer.concat([this._buf, data]);
+            this._buf = undefined;
+        }
+        const io = new buffer_reader_js_1.BufferReader(data);
+        let offsetBookmark;
+        while (io.length - io.offset >= HEADER_LENGTH) {
+            offsetBookmark = io.offset;
+            const code = io.readUInt8();
+            const len = io.readUInt32BE();
+            // Check if frame data not received yet
+            if (io.length - io.offset < len - 4) {
+                io.offset = offsetBookmark;
+                this._buf = io.readBuffer();
+                return;
+            }
+            const parser = MessageParsers[code];
+            const v = parser && parser(io, code, len);
+            callback(code, v);
+            // Set offset to next message
+            io.offset = offsetBookmark + len + 1;
+        }
+        if (io.offset < io.length)
+            this._buf = io.readBuffer(io.length - io.offset);
+    }
+}
+exports.Backend = Backend;
+const MessageParsers = {
+    [protocol_js_1.Protocol.BackendMessageCode.Authentication]: parseAuthentication,
+    [protocol_js_1.Protocol.BackendMessageCode.BackendKeyData]: parseBackendKeyData,
+    [protocol_js_1.Protocol.BackendMessageCode.CommandComplete]: parseCommandComplete,
+    [protocol_js_1.Protocol.BackendMessageCode.CopyData]: parseCopyData,
+    [protocol_js_1.Protocol.BackendMessageCode.CopyInResponse]: parseCopyResponse,
+    [protocol_js_1.Protocol.BackendMessageCode.CopyOutResponse]: parseCopyResponse,
+    [protocol_js_1.Protocol.BackendMessageCode.CopyBothResponse]: parseCopyResponse,
+    [protocol_js_1.Protocol.BackendMessageCode.DataRow]: parseDataRow,
+    [protocol_js_1.Protocol.BackendMessageCode.ErrorResponse]: parseErrorResponse,
+    [protocol_js_1.Protocol.BackendMessageCode.NoticeResponse]: parseErrorResponse,
+    [protocol_js_1.Protocol.BackendMessageCode.NotificationResponse]: parseNotificationResponse,
+    [protocol_js_1.Protocol.BackendMessageCode.FunctionCallResponse]: parseFunctionCallResponse,
+    [protocol_js_1.Protocol.BackendMessageCode.NegotiateProtocolVersion]: parseNegotiateProtocolVersion,
+    [protocol_js_1.Protocol.BackendMessageCode.ParameterDescription]: parseParameterDescription,
+    [protocol_js_1.Protocol.BackendMessageCode.ParameterStatus]: parseParameterStatus,
+    [protocol_js_1.Protocol.BackendMessageCode.ReadyForQuery]: parseReadyForQuery,
+    [protocol_js_1.Protocol.BackendMessageCode.RowDescription]: parseRowDescription,
+};
+function parseAuthentication(io, code, len) {
+    const kind = io.readUInt32BE();
+    switch (kind) {
+        case 0:
+            return; // AuthenticationOk
+        case 2:
+            return {
+                kind: 'KerberosV5',
+            };
+        case 3:
+            return {
+                kind: 'CleartextPassword',
+            };
+        case 5:
+            return {
+                kind: 'MD5Password',
+                salt: io.readBuffer(len - 8),
+            };
+        case 6:
+            return {
+                kind: 'SCMCredential',
+            };
+        case 7:
+            return {
+                kind: 'GSS',
+            };
+        case 9:
+            return {
+                kind: 'SSPI',
+            };
+        case 8:
+            return {
+                kind: 'GSSContinue',
+                data: io.readBuffer(len - 8),
+            };
+        case 10: {
+            const out = {
+                kind: 'SASL',
+                mechanisms: [],
+            };
+            let mechanism;
+            while ((mechanism = io.readCString())) {
+                out.mechanisms.push(mechanism);
+            }
+            return out;
+        }
+        case 11:
+            return {
+                kind: 'SASLContinue',
+                data: io.readLString(len - 8, 'utf8'),
+            };
+        case 12:
+            return {
+                kind: 'SASLFinal',
+                data: io.readLString(len - 8, 'utf8'),
+            };
+        default:
+            throw new Error(`Unknown authentication kind (${kind})`);
+    }
+}
+function parseBackendKeyData(io) {
+    return {
+        processID: io.readUInt32BE(),
+        secretKey: io.readUInt32BE(),
+    };
+}
+function parseCommandComplete(io) {
+    return {
+        command: io.readCString('utf8'),
+    };
+}
+function parseCopyData(io, code, len) {
+    return {
+        data: io.readBuffer(len - 4),
+    };
+}
+function parseCopyResponse(io) {
+    const out = {
+        overallFormat: io.readUInt8() === 0 ? protocol_js_1.Protocol.DataFormat.text : protocol_js_1.Protocol.DataFormat.binary,
+        columnCount: io.readUInt16BE(),
+    };
+    if (out.columnCount) {
+        out.columnFormats = [];
+        for (let i = 0; i < out.columnCount; i++) {
+            out.columnFormats.push(io.readUInt16BE() === 0 ? protocol_js_1.Protocol.DataFormat.text : protocol_js_1.Protocol.DataFormat.binary);
+        }
+    }
+    return out;
+}
+function parseDataRow(io) {
+    const out = {
+        columnCount: io.readUInt16BE(),
+    };
+    if (out.columnCount) {
+        out.columns = [];
+        for (let i = 0; i < out.columnCount; i++) {
+            // The length of the column value, in bytes (this count does not include itself).
+            // Can be zero. As a special case, -1 indicates a NULL column value.
+            // No value bytes follow in the NULL case.
+            const l = io.readInt32BE();
+            if (l < 0)
+                out.columns.push(null);
+            else
+                out.columns.push(io.readBuffer(l));
+        }
+    }
+    return out;
+}
+function parseErrorResponse(io) {
+    const out = {};
+    let fieldType;
+    while ((fieldType = io.readLString(1)) !== '\0') {
+        const value = io.readCString('utf8');
+        const key = ErrorFieldTypes[fieldType];
+        if (key)
+            out[key] = value;
+    }
+    return out;
+}
+function parseNotificationResponse(io) {
+    return {
+        processId: io.readUInt32BE(),
+        channel: io.readCString(),
+        payload: io.readCString(),
+    };
+}
+function parseFunctionCallResponse(io, code, len) {
+    return {
+        result: io.readBuffer(len - 4),
+    };
+}
+function parseNegotiateProtocolVersion(io) {
+    return {
+        supportedVersionMinor: io.readUInt32BE(),
+        numberOfNotSupportedVersions: io.readUInt32BE(),
+        option: io.readCString('utf8'),
+    };
+}
+function parseParameterDescription(io) {
+    const out = {
+        parameterCount: io.readUInt32BE(),
+        parameterIds: [],
+    };
+    for (let i = 0; i < out.parameterCount; i++) {
+        out.parameterIds.push(io.readUInt32BE());
+    }
+    return out;
+}
+function parseParameterStatus(io) {
+    return {
+        name: io.readCString('utf8'),
+        value: io.readCString('utf8'),
+    };
+}
+function parseReadyForQuery(io) {
+    return {
+        status: io.readLString(1),
+    };
+}
+function parseRowDescription(io) {
+    const fieldCount = io.readUInt16BE();
+    const out = {
+        fields: [],
+    };
+    for (let i = 0; i < fieldCount; i++) {
+        const field = {
+            fieldName: io.readCString('utf8'),
+            tableId: io.readInt32BE(),
+            columnId: io.readInt16BE(),
+            dataTypeId: io.readInt32BE(),
+            fixedSize: io.readInt16BE(),
+            modifier: io.readInt32BE(),
+            format: io.readInt16BE() === 0 ? protocol_js_1.Protocol.DataFormat.text : protocol_js_1.Protocol.DataFormat.binary,
+        };
+        out.fields.push(field);
+    }
+    return out;
+}