postgrejs 3.6.0 → 3.7.0

package/data-types/lseg-type.js

@@ -1,4 +1,5 @@
 import { DataTypeOIDs } from '../constants.js';
+import { LineSegment, TwoPoints } from './classes/geometric.js';
 const LSEG_PATTERN1 = /^\[ *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *]$/;
 const LSEG_PATTERN2 = /^\( *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *\)$/;
 const LSEG_PATTERN3 = /^\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\)$/;
@@ -6,7 +7,7 @@ const LSEG_PATTERN4 = /^(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *, *(-
 export const LsegType = {
     name: 'lseg',
     oid: DataTypeOIDs.lseg,
-    jsType: 'object',
+    jsType: 'LineSegment',
     encodeText(v) {
         return `[(${v.x1},${v.y1}),(${v.x2},${v.y2})]`;
     },
@@ -17,12 +18,7 @@ export const LsegType = {
         buf.writeDoubleBE(v.y2);
     },
     decodeBinary(v, offset = 0) {
-        return {
-            x1: v.readDoubleBE(offset),
-            y1: v.readDoubleBE(offset + 8),
-            x2: v.readDoubleBE(offset + 16),
-            y2: v.readDoubleBE(offset + 24),
-        };
+        return new LineSegment(v.readDoubleBE(offset), v.readDoubleBE(offset + 8), v.readDoubleBE(offset + 16), v.readDoubleBE(offset + 24));
     },
     decodeText(v) {
         const m = v.match(LSEG_PATTERN1) ||
@@ -31,24 +27,18 @@ export const LsegType = {
             v.match(LSEG_PATTERN4);
         if (!m)
             return undefined;
-        return {
-            x1: parseFloat(m[1]),
-            y1: parseFloat(m[2]),
-            x2: parseFloat(m[3]),
-            y2: parseFloat(m[4]),
-        };
+        return new LineSegment(parseFloat(m[1]), parseFloat(m[2]), parseFloat(m[3]), parseFloat(m[4]));
     },
     // See box-type.ts's decodeTextBuffer comment - same rationale.
     decodeTextBuffer(buf, offset, len, options) {
         return LsegType.decodeText(buf.toString('latin1', offset, offset + len), options);
     },
+    // A plain object of the four numbers is still accepted - it is what
+    // this type returned before these classes existed - but only a plain
+    // one: box and lseg carry the same four, so an instance of the other
+    // must not be claimed here.
     isType(v) {
-        return (typeof v === 'object' &&
-            Object.keys(v).length === 4 &&
-            typeof v.x1 === 'number' &&
-            typeof v.y1 === 'number' &&
-            typeof v.x2 === 'number' &&
-            typeof v.y2 === 'number');
+        return v instanceof LineSegment || TwoPoints.isTwoPointsLike(v);
     },
 };
 export const ArrayLsegType = {

package/data-types/macaddr-type.d.ts

@@ -0,0 +1,5 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const MacaddrType: DataType;
+export declare const ArrayMacaddrType: DataType;
+export declare const Macaddr8Type: DataType;
+export declare const ArrayMacaddr8Type: DataType;

package/data-types/macaddr-type.js

@@ -0,0 +1,86 @@
+import { DataTypeOIDs } from '../constants.js';
+/**
+ * `macaddr` and `macaddr8` share a file for the same reason `inet` and
+ * `cidr` do: one wire format - the address bytes and nothing else - and
+ * one JavaScript shape, differing only in length.
+ *
+ * Both decode to a string, in the `08:00:2b:01:02:03` form the server
+ * prints. `pg` answers with a string too.
+ */
+const SEPARATORS = /[.:-]/g;
+const HEX_PATTERN = /^[0-9a-fA-F]+$/;
+/**
+ * PostgreSQL accepts a MAC address written half a dozen ways -
+ * `08:00:2b:01:02:03`, `08-00-2b-01-02-03`, `0800.2b01.0203`,
+ * `08002b-010203`, `08002b010203` - which all come to the same thing
+ * once the separators are dropped: the right number of hex digits. It is
+ * not checked that the separators were placed sensibly, since nothing is
+ * gained by rejecting `0:800:2b0:102:03` on the client instead of just
+ * reading it.
+ */
+function parseMacaddr(v, size) {
+    if (typeof v !== 'string')
+        return undefined;
+    const hex = v.replace(SEPARATORS, '');
+    if (hex.length !== size * 2 || !HEX_PATTERN.test(hex)) {
+        // A six-byte address in a macaddr8 is not an error: the server widens
+        // it by inserting ff:fe in the middle, the modified EUI-64 rule, and
+        // `macaddr8 '08:00:2b:01:02:03'` is stored as `08:00:2b:ff:fe:01:02:03`.
+        if (size !== 8 || hex.length !== 12 || !HEX_PATTERN.test(hex))
+            return undefined;
+        return Buffer.from(hex.slice(0, 6) + 'fffe' + hex.slice(6), 'hex');
+    }
+    return Buffer.from(hex, 'hex');
+}
+function createType(name, oid, size) {
+    return {
+        name,
+        oid,
+        jsType: 'string',
+        // See inet-type.ts: a MAC address is an ordinary string as far as
+        // JavaScript is concerned, and inferring this type from one would
+        // send `macaddr` where `text` was meant. Name it to reach it.
+        inferrable: false,
+        encodeText(v) {
+            // Handed over as written - the server parses every spelling.
+            return '' + v;
+        },
+        encodeBinary(buf, v) {
+            const b = parseMacaddr(v, size);
+            if (!b)
+                throw new Error(`"${v}" is not a valid ${name} value`);
+            buf.writeBytes(b);
+        },
+        decodeBinary(v, offset = 0) {
+            let out = v.toString('hex', offset, offset + 1);
+            let i;
+            for (i = 1; i < size; i++)
+                out += ':' + v.toString('hex', offset + i, offset + i + 1);
+            return out;
+        },
+        decodeText(v) {
+            return v;
+        },
+        // Hex and colons - see inet-type.ts for why 'latin1'.
+        decodeTextBuffer(buf, offset, len) {
+            return buf.toString('latin1', offset, offset + len);
+        },
+        isType(v) {
+            return !!parseMacaddr(v, size);
+        },
+    };
+}
+export const MacaddrType = createType('macaddr', DataTypeOIDs.macaddr, 6);
+export const ArrayMacaddrType = {
+    ...MacaddrType,
+    name: '_macaddr',
+    oid: DataTypeOIDs._macaddr,
+    elementsOID: DataTypeOIDs.macaddr,
+};
+export const Macaddr8Type = createType('macaddr8', DataTypeOIDs.macaddr8, 8);
+export const ArrayMacaddr8Type = {
+    ...Macaddr8Type,
+    name: '_macaddr8',
+    oid: DataTypeOIDs._macaddr8,
+    elementsOID: DataTypeOIDs.macaddr8,
+};

package/data-types/numeric-type.js

@@ -1,16 +1,55 @@
 import { DataTypeOIDs } from '../constants.js';
 import { assertCoercedNumber } from '../util/assert-integer.js';
 import { fastParseFloatBuffer } from '../util/fast-parsefloat.js';
+import { Numeric } from './classes/numeric.js';
 const NUMERIC_NEG = 0x4000;
 const NUMERIC_NAN = 0xc000;
 const NUMERIC_PINF = 0xd000;
 const NUMERIC_NINF = 0xf000;
 const DEC_DIGITS = 4;
-const ROUND_POWERS = [0, 1000, 100, 10];
+/**
+ * Every two-digit string, so a base-10000 group is written with two
+ * lookups and one join instead of four divisions and four number-to-
+ * string conversions. Built once; 100 short strings.
+ */
+const PAIRS = new Array(100);
+for (let i = 0; i < 100; i++)
+    PAIRS[i] = i < 10 ? '0' + i : '' + i;
+/** The decimal without the zeroes a declared scale pads it out to. */
+function trimTrailingZeros(s) {
+    const dot = s.indexOf('.');
+    if (dot < 0)
+        return s;
+    let end = s.length;
+    while (end > dot + 1 && s.charCodeAt(end - 1) === 48 /* 0 */)
+        end--;
+    return s.substring(0, end === dot + 1 ? dot : end);
+}
+/**
+ * A number when a double carries the decimal faithfully, a Numeric when
+ * it does not.
+ *
+ * Faithfully means printing back the same digits, which is the only
+ * thing a caller can observe - so the test is the round trip itself
+ * rather than a rule about magnitude. It catches both ways of losing a
+ * value: digits a double cannot hold (`12345678901234567.89` comes back
+ * as `...68`) and a magnitude JavaScript prints in exponential notation
+ * (`-0.00000000000000001` as `-1e-17`), which PostgreSQL never writes.
+ *
+ * The padding a declared scale adds is not a difference - a
+ * `numeric(40,6)` holding 19.99 arrives as `19.990000` - so it comes off
+ * before the comparison.
+ */
+function toNumberOrNumeric(s) {
+    const n = parseFloat(s);
+    return String(n) === trimTrailingZeros(s) ? n : new Numeric(s);
+}
 export const NumericType = {
     name: 'numeric',
     oid: DataTypeOIDs.numeric,
-    jsType: 'number',
+    // A number while one carries the value, a Numeric after that - the
+    // widened type is named here the way int8 names BigInt.
+    jsType: 'Numeric',
     /**
      * numeric on the wire is a base-10000 number: a digit count, the weight
      * of the first group (in groups of four decimal digits, not digits), a
@@ -110,16 +149,44 @@ export const NumericType = {
             digits[i] = v.readInt16BE(offset + 8 + i * 2);
         }
         const numString = numberBytesToString(digits, scale, weight, sign);
-        return parseFloat(numString);
+        // The header bounds the value before the digits are even looked at,
+        // so the ordinary column never pays for the round-trip check below.
+        // A double carries about fifteen significant decimal digits and
+        // prints in plain notation while its exponent stays inside
+        // (-7, 21); `weight` is the first group's position counted in fours
+        // and `scale` the digits after the point, which is enough to rule
+        // both out. `weight === -1` is a value in [0.0001, 1), far from the
+        // exponent that would make JavaScript switch notation.
+        if ((weight >= 0 && weight <= 4 && (weight + 1) * DEC_DIGITS + scale <= 15) ||
+            (weight === -1 && scale <= 15))
+            return parseFloat(numString);
+        return toNumberOrNumeric(numString);
     },
     encodeText(v) {
-        const n = typeof v === 'number' ? v : parseFloat(v);
-        return '' + n;
+        // Handed over as written. Going through a double here would undo
+        // exactly what encodeBinary is careful to preserve, and the server
+        // accepts every spelling this could normalize to anyway - including
+        // the exponent form a JavaScript number stringifies to.
+        return typeof v === 'string' ? v.trim() : String(v);
+    },
+    decodeText(v) {
+        // NaN and the infinities arrive as those words and stay numbers.
+        const n = parseFloat(v);
+        if (!Number.isFinite(n))
+            return n;
+        return String(n) === trimTrailingZeros(v) ? n : new Numeric(v);
+    },
+    decodeTextBuffer(buf, offset, len, options) {
+        // Eight characters hold at most eight digits, cannot reach 1e21 -
+        // which needs twenty-two - and cannot reach 1e-7, which needs `0.`
+        // and seven more. So a value this short is carried faithfully by
+        // definition and keeps the parser that never builds a string.
+        if (len <= 8)
+            return fastParseFloatBuffer(buf, offset, len);
+        return NumericType.decodeText(buf.toString('latin1', offset, offset + len), options);
     },
-    decodeText: parseFloat,
-    decodeTextBuffer: fastParseFloatBuffer,
     isType(v) {
-        return typeof v === 'number';
+        return typeof v === 'number' || v instanceof Numeric;
     },
 };
 export const ArrayNumericType = {
@@ -158,78 +225,40 @@ export function expandExponential(str) {
  * @return String the number as String
  */
 export function numberBytesToString(digits, scale, weight, sign) {
-    let i;
-    let d;
-    /*
-     * Allocate space for the result.
-     *
-     * i is set to the # of decimal digits before decimal point.
-     * dscale is the # of decimal digits we will print after decimal point.
-     * We may generate as many as DEC_DIGITS-1 excess digits at the end, and in addition we
-     * need room for sign, decimal point, null terminator.
-     */
-    i = (weight + 1) * DEC_DIGITS;
-    if (i <= 0)
-        i = 1;
-    /*
-     * Output a dash for negative values
-     */
+    const l = digits.length;
     let out = sign === NUMERIC_NEG ? '-' : '';
-    /*
-     * Output all digits before the decimal point
-     */
+    let d;
+    let g;
     if (weight < 0) {
+        // The value is below 1, so the integer part is a bare zero and the
+        // first digit group belongs after the point.
         d = weight + 1;
         out += '0';
     }
     else {
-        for (d = 0; d <= weight; d++) {
-            /* In the first digit, suppress extra leading decimal zeroes */
-            out += digitToString(d, digits, d !== 0);
+        // Leading zeroes are suppressed in the first group only - it is the
+        // most significant one - and every group after it is four digits.
+        out += l > 0 ? '' + digits[0] : '0';
+        for (d = 1; d <= weight; d++) {
+            g = d < l ? digits[d] : 0;
+            out += PAIRS[(g / 100) | 0] + PAIRS[g % 100];
         }
     }
-    /*
-     * If requested, output a decimal point and all the digits that follow it.
-     * We initially put out a multiple of DEC_DIGITS digits, then truncate if
-     * needed.
-     */
     if (scale > 0) {
-        out += '.';
+        let frac = '';
+        let i;
         for (i = 0; i < scale; d++, i += DEC_DIGITS) {
-            out += digitToString(d, digits, true);
-        }
-    }
-    const extra = (i - scale) % DEC_DIGITS;
-    return out.substring(0, out.length - extra);
-}
-/* https://github.com/pgjdbc/pgjdbc/blob/3eca3a76aa4a04cb28cb960ed674cb67db30b5e3/pgjdbc/src/main/java/org/postgresql/util/ByteConverter.java */
-/**
- * Convert a number from binary representation to text representation.
- * @param idx index of the digit to be converted in the digits array
- * @param digits array of shorts that can be decoded as the number String
- * @param alwaysPutIt a flag that indicate whether or not to put the digit char even if it is zero
- * @return String the number as String
- */
-function digitToString(idx, digits, alwaysPutIt) {
-    let out = '';
-    let dig = idx >= 0 && idx < digits.length ? digits[idx] : 0;
-    // Each dig represents 4 decimal digits (e.g. 9999)
-    // If we continue the number, then we need to print 0 as 0000 (alwaysPutIt parameter is true)
-    const l = ROUND_POWERS.length;
-    let p;
-    for (p = 1; p < l; p++) {
-        const pow = ROUND_POWERS[p];
-        const d1 = Math.trunc(dig / pow);
-        dig -= d1 * pow;
-        const putit = d1 > 0;
-        if (putit || alwaysPutIt) {
-            out += d1;
-            // We printed a character, so we need to print the rest of the current digits in dig
-            // For instance, we need to keep printing 000 from 1000 even if idx==0 (== it is the very
-            // beginning)
-            alwaysPutIt = true;
+            g = d >= 0 && d < l ? digits[d] : 0;
+            frac += PAIRS[(g / 100) | 0] + PAIRS[g % 100];
         }
+        // Whole groups are written, so the last one can overshoot the
+        // display scale by up to three digits. Trimmed from the fraction
+        // rather than from the whole string: the two are the same thing
+        // whenever there is a fraction, and when there is not - a value
+        // below 1 with a scale of 0 - trimming the whole string took the
+        // bare `0` with it.
+        out +=
+            '.' + (i > scale ? frac.substring(0, frac.length - (i - scale)) : frac);
     }
-    out += dig;
     return out;
 }

package/data-types/path-type.d.ts

@@ -0,0 +1,5 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const PathType: DataType;
+export declare const ArrayPathType: DataType;
+export declare const PolygonType: DataType;
+export declare const ArrayPolygonType: DataType;

package/data-types/path-type.js

@@ -0,0 +1,139 @@
+import { DataTypeOIDs } from '../constants.js';
+import { Path, Point, Polygon } from './classes/geometric.js';
+/**
+ * `path` and `polygon` are a series of points each, and differ on the
+ * wire only in that a path carries a flag saying whether it is closed.
+ * They share this file the way `box` and `lseg` share their shape, and
+ * for the same reason they are two classes: nothing about the points
+ * themselves says which type they were meant for.
+ */
+/**
+ * Every coordinate in the literal, in order. The server writes
+ * `((1,2),(3,4))` for a closed path or a polygon and `[(1,2),(3,4)]` for
+ * an open path, and a float8 may reach exponent form - so the numbers
+ * are read out rather than matched against a fixed shape.
+ */
+const NUMBER_PATTERN = /-?\d+(?:\.\d+)?(?:e[-+]?\d+)?/gi;
+const POINTS_PATTERN = /^\s*([[(])\s*\(.*\)\s*[\])]\s*$/;
+function parsePoints(v) {
+    if (!POINTS_PATTERN.test(v))
+        return undefined;
+    const nums = v.match(NUMBER_PATTERN);
+    // A path or polygon holds at least one point, and coordinates come in
+    // pairs - an odd count is a literal this does not understand.
+    if (!nums || !nums.length || nums.length % 2)
+        return undefined;
+    const points = new Array(nums.length / 2);
+    let i;
+    for (i = 0; i < points.length; i++)
+        points[i] = new Point(parseFloat(nums[i * 2]), parseFloat(nums[i * 2 + 1]));
+    return points;
+}
+/** An int32 count, then each point as two float8s. */
+function writePoints(buf, points) {
+    const l = points.length;
+    buf.writeInt32BE(l);
+    let i;
+    for (i = 0; i < l; i++) {
+        buf.writeDoubleBE(points[i].x);
+        buf.writeDoubleBE(points[i].y);
+    }
+}
+function readPoints(v, offset) {
+    const count = v.readInt32BE(offset);
+    const points = new Array(count);
+    let i;
+    let p = offset + 4;
+    for (i = 0; i < count; i++) {
+        points[i] = new Point(v.readDoubleBE(p), v.readDoubleBE(p + 8));
+        p += 16;
+    }
+    return points;
+}
+/**
+ * A plain array of points is accepted as a parameter - it cannot be
+ * inferred, since `determine()` answers `point[]` for one, but it is
+ * unambiguous once the type has been named with a BindParam.
+ */
+function toPoints(v, name) {
+    if (Array.isArray(v))
+        return v.map(p => new Point(p.x, p.y));
+    if (v && Array.isArray(v.points))
+        return v.points;
+    throw new TypeError(`"${typeof v}" cannot be encoded as a ${name} - pass a ${name === 'path' ? 'Path' : 'Polygon'} or an array of points`);
+}
+export const PathType = {
+    name: 'path',
+    oid: DataTypeOIDs.path,
+    jsType: 'Path',
+    encodeText(v) {
+        return v instanceof Path
+            ? v.toString()
+            : new Path(toPoints(v, 'path')).toString();
+    },
+    /** A closed flag, then the count and the points. */
+    encodeBinary(buf, v) {
+        buf.writeUInt8(v instanceof Path ? (v.isClosed ? 1 : 0) : 1);
+        writePoints(buf, toPoints(v, 'path'));
+    },
+    decodeBinary(v, offset = 0) {
+        return new Path(readPoints(v, offset + 1), !!v[offset]);
+    },
+    decodeText(v) {
+        const points = parsePoints(v);
+        if (!points)
+            return undefined;
+        // `[...]` is an open path, `(...)` a closed one.
+        return new Path(points, v.trimStart()[0] !== '[');
+    },
+    // See box-type.ts's decodeTextBuffer comment - same rationale.
+    decodeTextBuffer(buf, offset, len, options) {
+        return PathType.decodeText(buf.toString('latin1', offset, offset + len), options);
+    },
+    // Only a Path: a plain array of points is a `point[]` as far as
+    // inference is concerned, and claiming it here would take those arrays
+    // away from that type.
+    isType(v) {
+        return v instanceof Path;
+    },
+};
+export const ArrayPathType = {
+    ...PathType,
+    name: '_path',
+    oid: DataTypeOIDs._path,
+    elementsOID: DataTypeOIDs.path,
+};
+export const PolygonType = {
+    name: 'polygon',
+    oid: DataTypeOIDs.polygon,
+    jsType: 'Polygon',
+    encodeText(v) {
+        return v instanceof Polygon
+            ? v.toString()
+            : new Polygon(toPoints(v, 'polygon')).toString();
+    },
+    encodeBinary(buf, v) {
+        writePoints(buf, toPoints(v, 'polygon'));
+    },
+    decodeBinary(v, offset = 0) {
+        return new Polygon(readPoints(v, offset));
+    },
+    decodeText(v) {
+        const points = parsePoints(v);
+        return points && new Polygon(points);
+    },
+    // See box-type.ts's decodeTextBuffer comment - same rationale.
+    decodeTextBuffer(buf, offset, len, options) {
+        return PolygonType.decodeText(buf.toString('latin1', offset, offset + len), options);
+    },
+    // See PathType.isType().
+    isType(v) {
+        return v instanceof Polygon;
+    },
+};
+export const ArrayPolygonType = {
+    ...PolygonType,
+    name: '_polygon',
+    oid: DataTypeOIDs._polygon,
+    elementsOID: DataTypeOIDs.polygon,
+};

package/data-types/pg-lsn-type.d.ts

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const PgLsnType: DataType;
+export declare const ArrayPgLsnType: DataType;

package/data-types/pg-lsn-type.js

@@ -0,0 +1,58 @@
+import { DataTypeOIDs } from '../constants.js';
+/**
+ * A `pg_lsn` is a position in the write-ahead log - what
+ * `pg_current_wal_lsn()` and every column of `pg_stat_replication`
+ * answer with, so replication and monitoring tools read these routinely.
+ *
+ * It decodes to the `16/B374D848` string the server prints: the two
+ * 32-bit halves in upper-case hex, separated by a slash and neither of
+ * them padded - `0/0` and `A/B` are what the server writes for those,
+ * not `0/00000000`. That spelling is how an LSN is written everywhere -
+ * in logs, in
+ * `recovery_target_lsn`, in the documentation - and it casts straight
+ * back. A number would lose that and gain nothing, since the value is
+ * compared rather than arithmetic.
+ */
+const LSN_PATTERN = /^([0-9a-fA-F]{1,8})\/([0-9a-fA-F]{1,8})$/;
+export const PgLsnType = {
+    name: 'pg_lsn',
+    oid: DataTypeOIDs.pg_lsn,
+    jsType: 'string',
+    // See inet-type.ts: a string-shaped type stays out of inference.
+    inferrable: false,
+    encodeText(v) {
+        return '' + v;
+    },
+    /** One unsigned 64-bit value, written as its two halves. */
+    encodeBinary(buf, v) {
+        const m = typeof v === 'string' ? LSN_PATTERN.exec(v) : undefined;
+        if (!m)
+            throw new Error(`"${v}" is not a valid pg_lsn value`);
+        buf.writeUInt32BE(parseInt(m[1], 16));
+        buf.writeUInt32BE(parseInt(m[2], 16));
+    },
+    decodeBinary(v, offset = 0) {
+        return (v.readUInt32BE(offset).toString(16).toUpperCase() +
+            '/' +
+            v
+                .readUInt32BE(offset + 4)
+                .toString(16)
+                .toUpperCase());
+    },
+    decodeText(v) {
+        return v;
+    },
+    // Hex and a slash - see inet-type.ts for why 'latin1'.
+    decodeTextBuffer(buf, offset, len) {
+        return buf.toString('latin1', offset, offset + len);
+    },
+    isType(v) {
+        return typeof v === 'string' && LSN_PATTERN.test(v);
+    },
+};
+export const ArrayPgLsnType = {
+    ...PgLsnType,
+    name: '_pg_lsn',
+    oid: DataTypeOIDs._pg_lsn,
+    elementsOID: DataTypeOIDs.pg_lsn,
+};

package/data-types/point-type.js

@@ -1,10 +1,11 @@
 import { DataTypeOIDs } from '../constants.js';
+import { Point } from './classes/geometric.js';
 const POINT_PATTERN1 = /^\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\)$/;
 const POINT_PATTERN2 = /^(-?\d+\.?\d*) *, *(-?\d+\.?\d*)$/;
 export const PointType = {
     name: 'point',
     oid: DataTypeOIDs.point,
-    jsType: 'object',
+    jsType: 'Point',
     encodeText(v) {
         return `(${v.x},${v.y})`;
     },
@@ -13,29 +14,23 @@ export const PointType = {
         buf.writeDoubleBE(v.y);
     },
     decodeBinary(v, offset = 0) {
-        return {
-            x: v.readDoubleBE(offset),
-            y: v.readDoubleBE(offset + 8),
-        };
+        return new Point(v.readDoubleBE(offset), v.readDoubleBE(offset + 8));
     },
     decodeText(v) {
         const m = v.match(POINT_PATTERN1) || v.match(POINT_PATTERN2);
         if (!m)
             return undefined;
-        return {
-            x: parseFloat(m[1]),
-            y: parseFloat(m[2]),
-        };
+        return new Point(parseFloat(m[1]), parseFloat(m[2]));
     },
     // See box-type.ts's decodeTextBuffer comment - same rationale.
     decodeTextBuffer(buf, offset, len, options) {
         return PointType.decodeText(buf.toString('latin1', offset, offset + len), options);
     },
+    // A plain `{x, y}` is still accepted: it is what this type returned
+    // before Point existed, and code that builds one by hand should keep
+    // working.
     isType(v) {
-        return (typeof v === 'object' &&
-            Object.keys(v).length === 2 &&
-            typeof v.x === 'number' &&
-            typeof v.y === 'number');
+        return v instanceof Point || Point.isPointLike(v);
     },
 };
 export const ArrayPointType = {

package/data-types/range-type.d.ts

@@ -0,0 +1,23 @@
+import type { DataType } from '../interfaces/data-type.js';
+import type { OID } from '../types.js';
+/**
+ * Builds the DataType pair for one of PostgreSQL's range types.
+ *
+ * Every range shares one wire format regardless of what it ranges over -
+ * a flags byte, then each bound that exists as a length-prefixed value of
+ * the element type - so the element's own codec does the work and this
+ * only has to say which bounds are there.
+ *
+ * Note what is deliberately not set: `elementsOID`. That marks an *array*
+ * type, and get-parsers.ts routes anything carrying it through
+ * decodeBinaryArray. A range is a scalar whose parts happen to be typed.
+ */
+export declare function createRangeType(name: string, oid: OID, element: DataType): DataType;
+/**
+ * The multirange counterpart: a count, then each range length-prefixed,
+ * and in text a brace-wrapped comma-separated list. The ranges themselves
+ * are the same format, so this delegates to the range type rather than
+ * repeating it.
+ */
+export declare function createMultiRangeType(name: string, oid: OID, range: DataType): DataType;
+export declare const RangeTypes: DataType[];