postgrejs 2.15.4 → 2.16.0

package/esm/protocol/pg-socket.js

@@ -1,29 +1,33 @@
-import crypto from 'crypto';
-import net from 'net';
-import promisify from 'putil-promisify';
-import tls from 'tls';
-import { ConnectionState } from '../constants.js';
-import { SafeEventEmitter } from '../safe-event-emitter.js';
-import { Backend } from './backend.js';
-import { DatabaseError } from './database-error.js';
-import { Frontend } from './frontend.js';
-import { Protocol } from './protocol.js';
-import { SASL } from './sasl.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgSocket = void 0;
+const tslib_1 = require("tslib");
+const crypto_1 = tslib_1.__importDefault(require("crypto"));
+const net_1 = tslib_1.__importDefault(require("net"));
+const putil_promisify_1 = tslib_1.__importDefault(require("putil-promisify"));
+const tls_1 = tslib_1.__importDefault(require("tls"));
+const constants_js_1 = require("../constants.js");
+const safe_event_emitter_js_1 = require("../safe-event-emitter.js");
+const backend_js_1 = require("./backend.js");
+const database_error_js_1 = require("./database-error.js");
+const frontend_js_1 = require("./frontend.js");
+const protocol_js_1 = require("./protocol.js");
+const sasl_js_1 = require("./sasl.js");
 const DEFAULT_PORT_NUMBER = 5432;
 const COMMAND_RESULT_PATTERN = /^([^\d]+)(?: (\d+)(?: (\d+))?)?$/;
-export class PgSocket extends SafeEventEmitter {
+class PgSocket extends safe_event_emitter_js_1.SafeEventEmitter {
     constructor(options) {
         super();
         this.options = options;
-        this._state = ConnectionState.CLOSED;
-        this._backend = new Backend();
+        this._state = constants_js_1.ConnectionState.CLOSED;
+        this._backend = new backend_js_1.Backend();
         this._sessionParameters = {};
-        this._frontend = new Frontend({ buffer: options.buffer });
+        this._frontend = new frontend_js_1.Frontend({ buffer: options.buffer });
         this.setMaxListeners(99);
     }
     get state() {
         if (!this._socket || this._socket.destroyed)
-            this._state = ConnectionState.CLOSED;
+            this._state = constants_js_1.ConnectionState.CLOSED;
         return this._state;
     }
     get processID() {
@@ -38,11 +42,11 @@ export class PgSocket extends SafeEventEmitter {
     connect() {
         if (this._socket)
             return;
-        this._state = ConnectionState.CONNECTING;
+        this._state = constants_js_1.ConnectionState.CONNECTING;
         const options = this.options;
-        const socket = (this._socket = new net.Socket());
+        const socket = (this._socket = new net_1.default.Socket());
         const errorHandler = err => {
-            this._state = ConnectionState.CLOSED;
+            this._state = constants_js_1.ConnectionState.CLOSED;
             this._removeListeners();
             this._reset();
             socket.destroy();
@@ -58,9 +62,9 @@ export class PgSocket extends SafeEventEmitter {
                 this._removeListeners();
                 if (x.toString() === 'S') {
                     const tslOptions = { ...options.ssl, socket };
-                    if (options.host && net.isIP(options.host) === 0)
+                    if (options.host && net_1.default.isIP(options.host) === 0)
                         tslOptions.servername = options.host;
-                    const tlsSocket = (this._socket = tls.connect(tslOptions));
+                    const tlsSocket = (this._socket = tls_1.default.connect(tslOptions));
                     tlsSocket.once('error', errorHandler);
                     tlsSocket.once('secureConnect', () => {
                         this._removeListeners();
@@ -91,15 +95,15 @@ export class PgSocket extends SafeEventEmitter {
     }
     close() {
         if (!this._socket || this._socket.destroyed) {
-            this._state = ConnectionState.CLOSED;
+            this._state = constants_js_1.ConnectionState.CLOSED;
             this._socket = undefined;
             this._reset();
             return;
         }
-        if (this._state === ConnectionState.CLOSING)
+        if (this._state === constants_js_1.ConnectionState.CLOSING)
             return;
         const socket = this._socket;
-        this._state = ConnectionState.CLOSING;
+        this._state = constants_js_1.ConnectionState.CLOSING;
         this._removeListeners();
         socket.once('close', () => this._handleClose());
         socket.destroy();
@@ -165,7 +169,7 @@ export class PgSocket extends SafeEventEmitter {
             };
             const msgHandler = (code, msg) => {
                 const x = callback(code, msg, done);
-                if (promisify.isPromise(x))
+                if (putil_promisify_1.default.isPromise(x))
                     x.catch(err => done(err));
             };
             this.once('error', errorHandler);
@@ -191,7 +195,7 @@ export class PgSocket extends SafeEventEmitter {
         const socket = this._socket;
         if (!socket)
             return;
-        this._state = ConnectionState.AUTHORIZING;
+        this._state = constants_js_1.ConnectionState.AUTHORIZING;
         this._reset();
         socket.on('data', (data) => this._handleData(data));
         socket.on('error', (err) => this._handleError(err));
@@ -204,11 +208,11 @@ export class PgSocket extends SafeEventEmitter {
     _handleClose() {
         this._reset();
         this._socket = undefined;
-        this._state = ConnectionState.CLOSED;
+        this._state = constants_js_1.ConnectionState.CLOSED;
         this.emit('close');
     }
     _handleError(err) {
-        if (this._state !== ConnectionState.READY) {
+        if (this._state !== constants_js_1.ConnectionState.READY) {
             this._socket?.end();
         }
         this.emit('error', err);
@@ -217,33 +221,33 @@ export class PgSocket extends SafeEventEmitter {
         this._backend.parse(data, (code, payload) => {
             try {
                 switch (code) {
-                    case Protocol.BackendMessageCode.Authentication:
+                    case protocol_js_1.Protocol.BackendMessageCode.Authentication:
                         this._handleAuthenticationMessage(payload);
                         break;
-                    case Protocol.BackendMessageCode.ErrorResponse:
-                        this.emit('error', new DatabaseError(payload));
+                    case protocol_js_1.Protocol.BackendMessageCode.ErrorResponse:
+                        this.emit('error', new database_error_js_1.DatabaseError(payload));
                         break;
-                    case Protocol.BackendMessageCode.NoticeResponse:
+                    case protocol_js_1.Protocol.BackendMessageCode.NoticeResponse:
                         this.emit('notice', payload);
                         break;
-                    case Protocol.BackendMessageCode.NotificationResponse:
+                    case protocol_js_1.Protocol.BackendMessageCode.NotificationResponse:
                         this.emit('notification', payload);
                         break;
-                    case Protocol.BackendMessageCode.ParameterStatus:
+                    case protocol_js_1.Protocol.BackendMessageCode.ParameterStatus:
                         this._handleParameterStatus(payload);
                         break;
-                    case Protocol.BackendMessageCode.BackendKeyData:
+                    case protocol_js_1.Protocol.BackendMessageCode.BackendKeyData:
                         this._handleBackendKeyData(payload);
                         break;
-                    case Protocol.BackendMessageCode.ReadyForQuery:
-                        if (this._state !== ConnectionState.READY) {
-                            this._state = ConnectionState.READY;
+                    case protocol_js_1.Protocol.BackendMessageCode.ReadyForQuery:
+                        if (this._state !== constants_js_1.ConnectionState.READY) {
+                            this._state = constants_js_1.ConnectionState.READY;
                             this.emit('ready');
                         }
                         else
                             this.emit('message', code, payload);
                         break;
-                    case Protocol.BackendMessageCode.CommandComplete: {
+                    case protocol_js_1.Protocol.BackendMessageCode.CommandComplete: {
                         const msg = this._handleCommandComplete(payload);
                         this.emit('message', code, msg);
                         break;
@@ -269,44 +273,44 @@ export class PgSocket extends SafeEventEmitter {
             return;
         }
         switch (msg.kind) {
-            case Protocol.AuthenticationMessageKind.CleartextPassword:
+            case protocol_js_1.Protocol.AuthenticationMessageKind.CleartextPassword:
                 this._resolvePassword(password => {
                     this._send(this._frontend.getPasswordMessage(password));
                 });
                 break;
-            case Protocol.AuthenticationMessageKind.MD5Password:
+            case protocol_js_1.Protocol.AuthenticationMessageKind.MD5Password:
                 this._resolvePassword(password => {
-                    const md5 = (x) => crypto.createHash('md5').update(x, 'utf8').digest('hex');
+                    const md5 = (x) => crypto_1.default.createHash('md5').update(x, 'utf8').digest('hex');
                     const l = md5(password + this.options.user);
                     const r = md5(Buffer.concat([Buffer.from(l), msg.salt]));
                     const pass = 'md5' + r;
                     this._send(this._frontend.getPasswordMessage(pass));
                 });
                 break;
-            case Protocol.AuthenticationMessageKind.SASL: {
+            case protocol_js_1.Protocol.AuthenticationMessageKind.SASL: {
                 if (!msg.mechanisms.includes('SCRAM-SHA-256')) {
                     throw new Error('SASL: Only mechanism SCRAM-SHA-256 is currently supported');
                 }
-                const saslSession = (this._saslSession = SASL.createSession(this.options.user || '', 'SCRAM-SHA-256'));
+                const saslSession = (this._saslSession = sasl_js_1.SASL.createSession(this.options.user || '', 'SCRAM-SHA-256'));
                 this._send(this._frontend.getSASLMessage(saslSession));
                 break;
             }
-            case Protocol.AuthenticationMessageKind.SASLContinue: {
+            case protocol_js_1.Protocol.AuthenticationMessageKind.SASLContinue: {
                 const saslSession = this._saslSession;
                 if (!saslSession)
                     throw new Error('SASL: Session not started yet');
                 this._resolvePassword(password => {
-                    SASL.continueSession(saslSession, password, msg.data);
+                    sasl_js_1.SASL.continueSession(saslSession, password, msg.data);
                     const buf = this._frontend.getSASLFinalMessage(saslSession);
                     this._send(buf);
                 });
                 break;
             }
-            case Protocol.AuthenticationMessageKind.SASLFinal: {
+            case protocol_js_1.Protocol.AuthenticationMessageKind.SASLFinal: {
                 const session = this._saslSession;
                 if (!session)
                     throw new Error('SASL: Session not started yet');
-                SASL.finalizeSession(session, msg.data);
+                sasl_js_1.SASL.finalizeSession(session, msg.data);
                 this._saslSession = undefined;
                 break;
             }
@@ -340,3 +344,4 @@ export class PgSocket extends SafeEventEmitter {
         }
     }
 }
+exports.PgSocket = PgSocket;

package/esm/protocol/protocol.js

@@ -1,4 +1,7 @@
-export var Protocol;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Protocol = void 0;
+var Protocol;
 (function (Protocol) {
     Protocol.VERSION_MAJOR = 3;
     Protocol.VERSION_MINOR = 0;
@@ -65,4 +68,4 @@ export var Protocol;
         DataFormat[DataFormat["text"] = 0] = "text";
         DataFormat[DataFormat["binary"] = 1] = "binary";
     })(DataFormat = Protocol.DataFormat || (Protocol.DataFormat = {}));
-})(Protocol || (Protocol = {}));
+})(Protocol || (exports.Protocol = Protocol = {}));

package/esm/protocol/sasl.js

@@ -1,12 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SASL = void 0;
+const tslib_1 = require("tslib");
 /* eslint-disable no-bitwise */
-import crypto from 'crypto';
-export var SASL;
+const crypto_1 = tslib_1.__importDefault(require("crypto"));
+var SASL;
 (function (SASL) {
     const CLIENT_KEY = 'Client Key';
     const SERVER_KEY = 'Server Key';
     const GS2_HEADER = 'n,,';
     function createSession(username, mechanism) {
-        const nonce = crypto.randomBytes(18).toString('base64');
+        const nonce = crypto_1.default.randomBytes(18).toString('base64');
         const clientFirstMessage = `${GS2_HEADER}${firstMessageBare(username, nonce)}`;
         return {
             username,
@@ -80,14 +84,14 @@ export var SASL;
      * HMAC() == output length of H()
      */
     const hi = function (text, salt, iterations) {
-        return crypto.pbkdf2Sync(text, Buffer.from(salt, 'base64'), iterations, 32, 'sha256');
+        return crypto_1.default.pbkdf2Sync(text, Buffer.from(salt, 'base64'), iterations, 32, 'sha256');
     };
     const encode64 = str => Buffer.from(str).toString('base64');
     const hmac = function (key, msg) {
-        return crypto.createHmac('sha256', key).update(msg).digest();
+        return crypto_1.default.createHmac('sha256', key).update(msg).digest();
     };
     const hash = function (data) {
-        return crypto.createHash('sha256').update(data).digest();
+        return crypto_1.default.createHash('sha256').update(data).digest();
     };
     const xor = function (a, b) {
         a = Buffer.isBuffer(a) ? a : Buffer.from(a);
@@ -101,4 +105,4 @@ export var SASL;
         }
         return out;
     };
-})(SASL || (SASL = {}));
+})(SASL || (exports.SASL = SASL = {}));

package/esm/protocol/smart-buffer.js

@@ -1,7 +1,11 @@
-import * as os from 'os';
-import { writeBigUInt64BE } from '../util/bigint-methods.js';
-import { BufferReader } from './buffer-reader.js';
-export class SmartBuffer extends BufferReader {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartBuffer = void 0;
+const tslib_1 = require("tslib");
+const os = tslib_1.__importStar(require("os"));
+const bigint_methods_js_1 = require("../util/bigint-methods.js");
+const buffer_reader_js_1 = require("./buffer-reader.js");
+class SmartBuffer extends buffer_reader_js_1.BufferReader {
     constructor(cfg) {
         // @ts-ignore
         super(Buffer.allocUnsafe((cfg?.pageSize ? parseInt(cfg.pageSize, 10) : 0) || SmartBuffer.DEFAULT_PAGE_SIZE));
@@ -135,7 +139,7 @@ export class SmartBuffer extends BufferReader {
         if (typeof this.buffer.writeBigInt64BE === 'function')
             this.buffer.writeBigInt64BE(n, this.offset);
         else
-            writeBigUInt64BE(this.buffer, n, this.offset);
+            (0, bigint_methods_js_1.writeBigUInt64BE)(this.buffer, n, this.offset);
         this.offset += 8;
         return this;
     }
@@ -164,5 +168,6 @@ export class SmartBuffer extends BufferReader {
         this._stMaxPages = this.length ? Math.ceil(this.length / this.pageSize) : 1;
     }
 }
+exports.SmartBuffer = SmartBuffer;
 SmartBuffer.DEFAULT_PAGE_SIZE = 4096;
 SmartBuffer.DEFAULT_MAX_SIZE = Math.min(Math.floor(os.totalmem() / 2), 1024 * 1024 * 1024 * 2);

package/esm/safe-event-emitter.js

@@ -1,5 +1,8 @@
-import { EventEmitter } from 'events';
-export class SafeEventEmitter extends EventEmitter {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SafeEventEmitter = void 0;
+const events_1 = require("events");
+class SafeEventEmitter extends events_1.EventEmitter {
     emit(event, ...args) {
         try {
             if (event === 'error' && !this.listenerCount('error'))
@@ -11,3 +14,4 @@ export class SafeEventEmitter extends EventEmitter {
         }
     }
 }
+exports.SafeEventEmitter = SafeEventEmitter;

package/esm/types.js

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

package/esm/util/array-calculatedim.js

@@ -1,4 +1,7 @@
-export function arrayCalculateDim(arr) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayCalculateDim = arrayCalculateDim;
+function arrayCalculateDim(arr) {
     if (!arr || arr.length === 0)
         return [0];
     const dim = [arr.length];

package/esm/util/bigint-methods.js

@@ -1,9 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readBigInt64BE = readBigInt64BE;
+exports.writeBigUInt64BE = writeBigUInt64BE;
 /* eslint-disable no-bitwise */
 const big0 = BigInt(0);
 const beAnd = BigInt('0xffffffff');
 const big32 = BigInt(32);
 // https://github.com/nodejs/node/blob/v13.9.0/lib/internal/buffer.js
-export function readBigInt64BE(buf, offset = 0) {
+function readBigInt64BE(buf, offset = 0) {
     const first = buf[offset];
     const last = buf[offset + 7];
     if (first === undefined || last === undefined)
@@ -14,7 +18,7 @@ export function readBigInt64BE(buf, offset = 0) {
         buf[++offset];
     return ((BigInt(val) << big32) + BigInt(buf[++offset] * 2 ** 24 + buf[++offset] * 2 ** 16 + buf[++offset] * 2 ** 8 + last));
 }
-export function writeBigUInt64BE(buf, value, offset = 0) {
+function writeBigUInt64BE(buf, value, offset = 0) {
     // @ts-ignore
     let lo = Number(value & beAnd);
     buf[offset + 7] = lo;

package/esm/util/config-from-env.js

@@ -1,10 +1,13 @@
-import { toInt, toIntDef } from 'putil-varhelpers';
-export function configFromEnv() {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configFromEnv = configFromEnv;
+const putil_varhelpers_1 = require("putil-varhelpers");
+function configFromEnv() {
     const env = process.env;
     const result = {};
     result.host = env.PGHOST || env.PGHOSTADDR;
     if (env.PGPORT)
-        result.port = toIntDef(env.PGPORT, 5432);
+        result.port = (0, putil_varhelpers_1.toIntDef)(env.PGPORT, 5432);
     if (env.PGDATABASE)
         result.database = env.PGDATABASE;
     if (env.PGUSER)
@@ -18,9 +21,9 @@ export function configFromEnv() {
     if (env.PGSCHEMA)
         result.schema = env.PGSCHEMA;
     if (env.PGCONNECT_TIMEOUT)
-        result.connectTimeoutMs = toIntDef(env.PGCONNECT_TIMEOUT, 30000);
+        result.connectTimeoutMs = (0, putil_varhelpers_1.toIntDef)(env.PGCONNECT_TIMEOUT, 30000);
     if (env.PGMAX_BUFFER_SIZE) {
-        result.buffer = { maxLength: toInt(env.PGMAX_BUFFER_SIZE) };
+        result.buffer = { maxLength: (0, putil_varhelpers_1.toInt)(env.PGMAX_BUFFER_SIZE) };
     }
     return result;
 }

package/esm/util/connection-config.js

@@ -1,23 +1,28 @@
-import merge from 'putil-merge';
-import { configFromEnv } from './config-from-env.js';
-export function getConnectionConfig(config) {
-    const cfg = configFromEnv();
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConnectionConfig = getConnectionConfig;
+exports.parseConnectionString = parseConnectionString;
+const tslib_1 = require("tslib");
+const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
+const config_from_env_js_1 = require("./config-from-env.js");
+function getConnectionConfig(config) {
+    const cfg = (0, config_from_env_js_1.configFromEnv)();
     if (typeof config === 'string') {
-        merge(cfg, parseConnectionString(config));
+        (0, putil_merge_1.default)(cfg, parseConnectionString(config));
     }
     else if (typeof config === 'object') {
-        merge(cfg, config);
+        (0, putil_merge_1.default)(cfg, config);
     }
     if (cfg.host) {
         const x = parseConnectionString('' + cfg.host);
-        merge(cfg, x);
+        (0, putil_merge_1.default)(cfg, x);
     }
     cfg.user = cfg.user || 'postgres';
     cfg.database = cfg.database || 'postgres';
     cfg.host = cfg.host || '127.0.0.1';
     return cfg;
 }
-export function parseConnectionString(str) {
+function parseConnectionString(str) {
     if (str.startsWith('/'))
         str = 'socket:/' + str;
     if (!str.includes('://'))

package/esm/util/convert-row-to-object.js

@@ -1,4 +1,7 @@
-export function convertRowToObject(fields, row) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertRowToObject = convertRowToObject;
+function convertRowToObject(fields, row) {
     const out = {};
     const l = row.length;
     let i;

package/esm/util/decode-binaryarray.js

@@ -1,8 +1,11 @@
-import { BufferReader } from '../protocol/buffer-reader.js';
-export function decodeBinaryArray(buf, decoder, options = {}) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeBinaryArray = decodeBinaryArray;
+const buffer_reader_js_1 = require("../protocol/buffer-reader.js");
+function decodeBinaryArray(buf, decoder, options = {}) {
     if (!buf.length)
         return null;
-    const io = new BufferReader(buf);
+    const io = new buffer_reader_js_1.BufferReader(buf);
     const ndims = io.readInt32BE();
     io.readInt32BE(); // hasNulls
     const elementOID = io.readInt32BE(); // element oid

package/esm/util/encode-binaryarray.js

@@ -1,8 +1,11 @@
-import { DataTypeOIDs } from '../constants.js';
-import { arrayCalculateDim } from './array-calculatedim.js';
-export function encodeBinaryArray(io, value, itemOid, options, encode, encodeCalculateDimFn) {
-    encodeCalculateDimFn = encodeCalculateDimFn || arrayCalculateDim;
-    itemOid = itemOid || DataTypeOIDs.varchar;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeBinaryArray = encodeBinaryArray;
+const constants_js_1 = require("../constants.js");
+const array_calculatedim_js_1 = require("./array-calculatedim.js");
+function encodeBinaryArray(io, value, itemOid, options, encode, encodeCalculateDimFn) {
+    encodeCalculateDimFn = encodeCalculateDimFn || array_calculatedim_js_1.arrayCalculateDim;
+    itemOid = itemOid || constants_js_1.DataTypeOIDs.varchar;
     const dim = encodeCalculateDimFn(value);
     const ndims = dim.length;
     const zeroOffset = io.offset;

package/esm/util/escape-literal.js

@@ -1,5 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeLiteral = escapeLiteral;
 // Ported from PostgreSQL 9.2.4 source code in src/interfaces/libpq/fe-exec.c
-export function escapeLiteral(str) {
+function escapeLiteral(str) {
     let backSlash = false;
     let out = "'";
     let i;

package/esm/util/fast-parseint.js

@@ -1,4 +1,7 @@
-export function fastParseInt(str) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fastParseInt = fastParseInt;
+function fastParseInt(str) {
     /* istanbul ignore next */
     if (typeof str === 'number')
         return Math.floor(str);

package/esm/util/get-parsers.js

@@ -1,8 +1,11 @@
-import { DataFormat } from '../constants.js';
-import { decodeBinaryArray } from './decode-binaryarray.js';
-import { parsePostgresArray } from './parse-array.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParsers = getParsers;
+const constants_js_1 = require("../constants.js");
+const decode_binaryarray_js_1 = require("./decode-binaryarray.js");
+const parse_array_js_1 = require("./parse-array.js");
 const DefaultColumnParser = (v) => v;
-export function getParsers(typeMap, fields) {
+function getParsers(typeMap, fields) {
     const parsers = new Array(fields.length);
     const l = fields.length;
     let f;
@@ -12,20 +15,20 @@ export function getParsers(typeMap, fields) {
         const dataTypeReg = typeMap.get(f.dataTypeId);
         if (dataTypeReg) {
             const isArray = !!dataTypeReg.elementsOID;
-            if (f.format === DataFormat.binary) {
+            if (f.format === constants_js_1.DataFormat.binary) {
                 const decode = dataTypeReg.parseBinary;
                 if (decode) {
                     parsers[i] = !isArray
                         ? decode
-                        : (v, options) => decodeBinaryArray(v, decode, options);
+                        : (v, options) => (0, decode_binaryarray_js_1.decodeBinaryArray)(v, decode, options);
                 }
             }
-            else if (f.format === DataFormat.text) {
+            else if (f.format === constants_js_1.DataFormat.text) {
                 const parse = dataTypeReg.parseText;
                 if (parse) {
                     parsers[i] = !isArray
                         ? parse
-                        : (v, options) => parsePostgresArray(v, {
+                        : (v, options) => (0, parse_array_js_1.parsePostgresArray)(v, {
                             transform: x => parse(x, options),
                             separator: dataTypeReg.arraySeparator,
                         });

package/esm/util/parse-array.js

@@ -1,4 +1,7 @@
-export function parsePostgresArray(s, opts) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePostgresArray = parsePostgresArray;
+function parsePostgresArray(s, opts) {
     if (!s)
         return;
     const sep = (opts?.separator || ',').substring(0, 1);

package/esm/util/parse-datetime.js

@@ -1,11 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDateTime = parseDateTime;
 // noinspection RegExpUnnecessaryNonCapturingGroup
-import { fastParseInt } from './fast-parseint.js';
+const fast_parseint_js_1 = require("./fast-parseint.js");
 // noinspection RegExpUnnecessaryNonCapturingGroup
 const TIMESTAMP_PATTERN = 
 // eslint-disable-next-line
 /^(\d{4})-?(0[1-9]|1[012])?-?([123]0|[012][1-9]|31)?(?:[T ]?([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?)?$/;
 const INFINITY_PATTERN = /^-?infinity$/;
-export function parseDateTime(str, parseTime, parseTimeZone, utc) {
+function parseDateTime(str, parseTime, parseTimeZone, utc) {
     let m = str.match(TIMESTAMP_PATTERN);
     if (!m) {
         m = str.match(INFINITY_PATTERN);
@@ -17,15 +20,15 @@ export function parseDateTime(str, parseTime, parseTimeZone, utc) {
     const l = parseTime ? 7 : 3;
     for (let i = 0; i < l; i++) {
         const s = m[i + 1];
-        args[i] = fastParseInt(s) || 0;
+        args[i] = (0, fast_parseint_js_1.fastParseInt)(s) || 0;
     }
     // Months starts from 0
     if (args[1] > 0)
         args[1]--;
     if (parseTimeZone && parseTime && m[9]) {
         const r = m[9] === '-' ? -1 : 1;
-        args[3] -= (fastParseInt(m[10]) || 0) * r;
-        args[4] -= (fastParseInt(m[11]) || 0) * r;
+        args[3] -= ((0, fast_parseint_js_1.fastParseInt)(m[10]) || 0) * r;
+        args[4] -= ((0, fast_parseint_js_1.fastParseInt)(m[11]) || 0) * r;
         return new Date(Date.UTC(...args));
     }
     if (m[8] || utc)

package/esm/util/parse-row.js

@@ -1,4 +1,7 @@
-export function parseRow(parsers, row, options) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRow = parseRow;
+function parseRow(parsers, row, options) {
     const l = row.length;
     let i;
     for (i = 0; i < l; i++) {

package/esm/util/parse-time.js

@@ -1,22 +1,26 @@
-import { fastParseInt } from './fast-parseint.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIME_PATTERN = exports.STRICT_TIME_PATTERN = void 0;
+exports.parseTime = parseTime;
+const fast_parseint_js_1 = require("./fast-parseint.js");
 // eslint-disable-next-line
 // noinspection RegExpUnnecessaryNonCapturingGroup
-export const STRICT_TIME_PATTERN = /^([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?$/;
+exports.STRICT_TIME_PATTERN = /^([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?$/;
 // noinspection RegExpUnnecessaryNonCapturingGroup
-export const TIME_PATTERN = /^([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?$/;
-export function parseTime(str, parseTimeZone, utc) {
-    const m = str.match(TIME_PATTERN);
+exports.TIME_PATTERN = /^([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?$/;
+function parseTime(str, parseTimeZone, utc) {
+    const m = str.match(exports.TIME_PATTERN);
     if (!m)
         return new Date('invalid');
     const args = [1970, 0, 1, 0, 0, 0, 0];
     for (let i = 1; i < 4; i++) {
         const s = m[i];
-        args[i + 2] = fastParseInt(s) || 0;
+        args[i + 2] = (0, fast_parseint_js_1.fastParseInt)(s) || 0;
     }
     if (parseTimeZone && m[6]) {
         const r = m[9] === '-' ? -1 : 1;
-        args[3] -= (fastParseInt(m[7]) || 0) * r;
-        args[4] -= (fastParseInt(m[8]) || 0) * r;
+        args[3] -= ((0, fast_parseint_js_1.fastParseInt)(m[7]) || 0) * r;
+        args[4] -= ((0, fast_parseint_js_1.fastParseInt)(m[8]) || 0) * r;
         return new Date(Date.UTC(...args));
     }
     if (m[5] || utc)