postgrejs 2.16.0 → 2.17.0

package/esm/protocol/pg-socket.js

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

package/esm/protocol/protocol.js

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

package/esm/protocol/sasl.js

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

package/esm/protocol/smart-buffer.js

@@ -1,11 +1,7 @@
-"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 {
+import * as os from 'os';
+import { writeBigUInt64BE } from '../util/bigint-methods.js';
+import { BufferReader } from './buffer-reader.js';
+export class SmartBuffer extends BufferReader {
     constructor(cfg) {
         // @ts-ignore
         super(Buffer.allocUnsafe((cfg?.pageSize ? parseInt(cfg.pageSize, 10) : 0) || SmartBuffer.DEFAULT_PAGE_SIZE));
@@ -139,7 +135,7 @@ class SmartBuffer extends buffer_reader_js_1.BufferReader {
         if (typeof this.buffer.writeBigInt64BE === 'function')
             this.buffer.writeBigInt64BE(n, this.offset);
         else
-            (0, bigint_methods_js_1.writeBigUInt64BE)(this.buffer, n, this.offset);
+            writeBigUInt64BE(this.buffer, n, this.offset);
         this.offset += 8;
         return this;
     }
@@ -168,6 +164,5 @@ class SmartBuffer extends buffer_reader_js_1.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,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SafeEventEmitter = void 0;
-const events_1 = require("events");
-class SafeEventEmitter extends events_1.EventEmitter {
+import { EventEmitter } from 'events';
+export class SafeEventEmitter extends EventEmitter {
     emit(event, ...args) {
         try {
             if (event === 'error' && !this.listenerCount('error'))
@@ -14,4 +11,3 @@ class SafeEventEmitter extends events_1.EventEmitter {
         }
     }
 }
-exports.SafeEventEmitter = SafeEventEmitter;

package/esm/types.js

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

package/esm/util/array-calculatedim.js

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

package/esm/util/bigint-methods.js

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

package/esm/util/connection-config.js

@@ -1,28 +1,23 @@
-"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)();
+import merge from 'putil-merge';
+import { configFromEnv } from './config-from-env.js';
+export function getConnectionConfig(config) {
+    const cfg = configFromEnv();
     if (typeof config === 'string') {
-        (0, putil_merge_1.default)(cfg, parseConnectionString(config));
+        merge(cfg, parseConnectionString(config));
     }
     else if (typeof config === 'object') {
-        (0, putil_merge_1.default)(cfg, config);
+        merge(cfg, config);
     }
     if (cfg.host) {
         const x = parseConnectionString('' + cfg.host);
-        (0, putil_merge_1.default)(cfg, x);
+        merge(cfg, x);
     }
     cfg.user = cfg.user || 'postgres';
     cfg.database = cfg.database || 'postgres';
     cfg.host = cfg.host || '127.0.0.1';
     return cfg;
 }
-function parseConnectionString(str) {
+export function parseConnectionString(str) {
     if (str.startsWith('/'))
         str = 'socket:/' + str;
     if (!str.includes('://'))

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

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

package/esm/util/decode-binaryarray.js

@@ -1,11 +1,8 @@
-"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 = {}) {
+import { BufferReader } from '../protocol/buffer-reader.js';
+export function decodeBinaryArray(buf, decoder, options = {}) {
     if (!buf.length)
         return null;
-    const io = new buffer_reader_js_1.BufferReader(buf);
+    const io = new BufferReader(buf);
     const ndims = io.readInt32BE();
     io.readInt32BE(); // hasNulls
     const elementOID = io.readInt32BE(); // element oid

package/esm/util/encode-binaryarray.js

@@ -1,11 +1,8 @@
-"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;
+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;
     const dim = encodeCalculateDimFn(value);
     const ndims = dim.length;
     const zeroOffset = io.offset;

package/esm/util/escape-literal.js

@@ -1,8 +1,5 @@
-"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
-function escapeLiteral(str) {
+export function escapeLiteral(str) {
     let backSlash = false;
     let out = "'";
     let i;

package/esm/util/fast-parseint.js

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

package/esm/util/get-parsers.js

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

package/esm/util/parse-array.js

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

package/esm/util/parse-datetime.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseDateTime = parseDateTime;
 // noinspection RegExpUnnecessaryNonCapturingGroup
-const fast_parseint_js_1 = require("./fast-parseint.js");
+import { fastParseInt } from './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$/;
-function parseDateTime(str, parseTime, parseTimeZone, utc) {
+export function parseDateTime(str, parseTime, parseTimeZone, utc) {
     let m = str.match(TIMESTAMP_PATTERN);
     if (!m) {
         m = str.match(INFINITY_PATTERN);
@@ -20,15 +17,15 @@ 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] = (0, fast_parseint_js_1.fastParseInt)(s) || 0;
+        args[i] = 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] -= ((0, fast_parseint_js_1.fastParseInt)(m[10]) || 0) * r;
-        args[4] -= ((0, fast_parseint_js_1.fastParseInt)(m[11]) || 0) * r;
+        args[3] -= (fastParseInt(m[10]) || 0) * r;
+        args[4] -= (fastParseInt(m[11]) || 0) * r;
         return new Date(Date.UTC(...args));
     }
     if (m[8] || utc)

package/esm/util/parse-row.js

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

package/esm/util/parse-time.js

@@ -1,26 +1,22 @@
-"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");
+import { fastParseInt } from './fast-parseint.js';
 // eslint-disable-next-line
 // noinspection RegExpUnnecessaryNonCapturingGroup
-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])?))?$/;
+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])?))?$/;
 // noinspection RegExpUnnecessaryNonCapturingGroup
-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);
+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);
     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] = (0, fast_parseint_js_1.fastParseInt)(s) || 0;
+        args[i + 2] = fastParseInt(s) || 0;
     }
     if (parseTimeZone && m[6]) {
         const r = m[9] === '-' ? -1 : 1;
-        args[3] -= ((0, fast_parseint_js_1.fastParseInt)(m[7]) || 0) * r;
-        args[4] -= ((0, fast_parseint_js_1.fastParseInt)(m[8]) || 0) * r;
+        args[3] -= (fastParseInt(m[7]) || 0) * r;
+        args[4] -= (fastParseInt(m[8]) || 0) * r;
         return new Date(Date.UTC(...args));
     }
     if (m[5] || utc)