postgrejs 3.6.1 → 3.7.0

package/data-type-map.js

@@ -1,28 +1,43 @@
 import { DataTypeOIDs } from './constants.js';
+import { ArrayBitType, ArrayVarbitType, BitType, VarbitType, } from './data-types/bit-type.js';
 import { ArrayBoolType, BoolType } from './data-types/bool-type.js';
 import { ArrayBoxType, BoxType } from './data-types/box-type.js';
 import { ArrayByteaType, ByteaType } from './data-types/bytea-type.js';
 import { ArrayCharType, CharType } from './data-types/char-type.js';
 import { ArrayCircleType, CircleType } from './data-types/circle-type.js';
+import { getTypeOid, REQUIRES_TYPE_OID, } from './data-types/classes/type-oid.js';
 import { ArrayDateType, DateType } from './data-types/date-type.js';
 import { ArrayFloat4Type, Float4Type } from './data-types/float4-type.js';
 import { ArrayFloat8Type, Float8Type } from './data-types/float8-type.js';
+import { ArrayCidrType, ArrayInetType, CidrType, InetType, } from './data-types/inet-type.js';
 import { ArrayInt2Type, Int2Type } from './data-types/int2-type.js';
 import { ArrayInt2VectorType, Int2VectorType, } from './data-types/int2-vector-type.js';
 import { ArrayInt4Type, Int4Type } from './data-types/int4-type.js';
 import { ArrayInt8Type, Int8Type } from './data-types/int8-type.js';
+import { ArrayIntervalType, IntervalType } from './data-types/interval-type.js';
 import { ArrayJsonType, JsonType } from './data-types/json-type.js';
 import { ArrayJsonbType, JsonbType } from './data-types/jsonb-type.js';
+import { ArrayJsonPathType, JsonPathType } from './data-types/jsonpath-type.js';
+import { ArrayLineType, LineType } from './data-types/line-type.js';
 import { ArrayLsegType, LsegType } from './data-types/lseg-type.js';
+import { ArrayMacaddr8Type, ArrayMacaddrType, Macaddr8Type, MacaddrType, } from './data-types/macaddr-type.js';
 import { ArrayNumericType, NumericType } from './data-types/numeric-type.js';
 import { ArrayOidType, OidType } from './data-types/oid-type.js';
 import { ArrayOidVectorType, OidVectorType, } from './data-types/oid-vector-type.js';
+import { ArrayPathType, ArrayPolygonType, PathType, PolygonType, } from './data-types/path-type.js';
+import { ArrayPgLsnType, PgLsnType } from './data-types/pg-lsn-type.js';
 import { ArrayPointType, PointType } from './data-types/point-type.js';
+import { RangeTypes } from './data-types/range-type.js';
+import { ArrayPgSnapshotType, ArrayTxidSnapshotType, PgSnapshotType, TxidSnapshotType, } from './data-types/snapshot-type.js';
+import { ArrayTidType, TidType } from './data-types/tid-type.js';
 import { ArrayTimeType, TimeType } from './data-types/time-type.js';
 import { ArrayTimestampType, TimestampType, } from './data-types/timestamp-type.js';
 import { ArrayTimestamptzType, TimestamptzType, } from './data-types/timestamptz-type.js';
+import { ArrayTimeTzType, TimeTzType } from './data-types/timetz-type.js';
+import { ArrayTsQueryType, ArrayTsVectorType, TsQueryType, TsVectorType, } from './data-types/tsvector-type.js';
 import { ArrayUuidType, UuidType } from './data-types/uuid-type.js';
 import { ArrayVarcharType, VarcharType } from './data-types/varchar-type.js';
+import { ArrayCidType, ArrayXid8Type, ArrayXidType, CidType, Xid8Type, XidType, } from './data-types/xid-type.js';
 export class DataTypeMap {
     _itemsByOID = {};
     _items = [];
@@ -60,6 +75,25 @@ export class DataTypeMap {
     determine(value) {
         if (value == null)
             return DataTypeOIDs.unknown;
+        if (typeof value === 'object') {
+            // A value that already knows which type it came from says so,
+            // rather than being matched by shape - which is the only thing
+            // that can work when several types share one JavaScript class.
+            const carried = getTypeOid(value);
+            if (carried !== undefined)
+                return carried;
+            const ctor = value
+                .constructor;
+            if (ctor && ctor[REQUIRES_TYPE_OID]) {
+                // Checked before the walk below rather than after it: JsonType
+                // takes any object, so left to the walk this value would quietly
+                // go out declared `json` and come back looking right.
+                throw new TypeError(`A ${ctor.name} carries no type OID, and ` +
+                    'which PostgreSQL type it is cannot be told from the value - ' +
+                    'give it one (`new Range(lower, upper, bounds, oid)`) or name ' +
+                    'it at the call site (`new BindParam(oid, value)`)');
+            }
+        }
         const valueIsArray = Array.isArray(value);
         let i;
         let t;
@@ -97,6 +131,9 @@ GlobalTypeMap.register([CircleType, ArrayCircleType]);
 GlobalTypeMap.register([PointType, ArrayPointType]);
 GlobalTypeMap.register([LsegType, ArrayLsegType]);
 GlobalTypeMap.register([BoxType, ArrayBoxType]);
+GlobalTypeMap.register([LineType, ArrayLineType]);
+GlobalTypeMap.register([PathType, ArrayPathType]);
+GlobalTypeMap.register([PolygonType, ArrayPolygonType]);
 GlobalTypeMap.register([Int2VectorType, ArrayInt2VectorType]);
 GlobalTypeMap.register({
     ...VarcharType,
@@ -138,10 +175,55 @@ GlobalTypeMap.register({
     oid: DataTypeOIDs._xml,
     elementsOID: DataTypeOIDs.xml,
 });
+// `refcursor` is a cursor's name and `pg_node_tree` a catalog blob, and
+// both are literally text on the wire - `refcursor`'s own typsend is
+// textsend. Registered before varchar the way bpchar and the rest are,
+// and marked uninferrable on top of that: a plain string is not evidence
+// of either, and sending one declared `refcursor` where `text` was meant
+// would be refused by the server.
+GlobalTypeMap.register({
+    ...VarcharType,
+    name: 'refcursor',
+    oid: DataTypeOIDs.refcursor,
+    inferrable: false,
+});
+GlobalTypeMap.register({
+    ...ArrayVarcharType,
+    name: '_refcursor',
+    oid: DataTypeOIDs._refcursor,
+    elementsOID: DataTypeOIDs.refcursor,
+    inferrable: false,
+});
+// pg_node_tree has no array type of its own.
+GlobalTypeMap.register({
+    ...VarcharType,
+    name: 'pg_node_tree',
+    oid: DataTypeOIDs.pg_node_tree,
+    inferrable: false,
+});
 GlobalTypeMap.register([VarcharType, ArrayVarcharType]);
 GlobalTypeMap.register([UuidType, ArrayUuidType]);
 GlobalTypeMap.register([CharType, ArrayCharType]);
 GlobalTypeMap.register([TimestamptzType, ArrayTimestamptzType]);
 GlobalTypeMap.register([TimeType, ArrayTimeType]);
+GlobalTypeMap.register([TimeTzType, ArrayTimeTzType]);
 GlobalTypeMap.register([DateType, ArrayDateType]);
 GlobalTypeMap.register([TimestampType, ArrayTimestampType]);
+GlobalTypeMap.register([IntervalType, ArrayIntervalType]);
+GlobalTypeMap.register(RangeTypes);
+GlobalTypeMap.register([InetType, ArrayInetType]);
+GlobalTypeMap.register([CidrType, ArrayCidrType]);
+GlobalTypeMap.register([BitType, ArrayBitType]);
+GlobalTypeMap.register([VarbitType, ArrayVarbitType]);
+GlobalTypeMap.register([JsonPathType, ArrayJsonPathType]);
+GlobalTypeMap.register([TsVectorType, ArrayTsVectorType]);
+GlobalTypeMap.register([TsQueryType, ArrayTsQueryType]);
+GlobalTypeMap.register([XidType, ArrayXidType]);
+GlobalTypeMap.register([Xid8Type, ArrayXid8Type]);
+GlobalTypeMap.register([CidType, ArrayCidType]);
+GlobalTypeMap.register([TidType, ArrayTidType]);
+GlobalTypeMap.register([PgLsnType, ArrayPgLsnType]);
+GlobalTypeMap.register([PgSnapshotType, ArrayPgSnapshotType]);
+GlobalTypeMap.register([TxidSnapshotType, ArrayTxidSnapshotType]);
+GlobalTypeMap.register([MacaddrType, ArrayMacaddrType]);
+GlobalTypeMap.register([Macaddr8Type, ArrayMacaddr8Type]);

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

@@ -0,0 +1,5 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const BitType: DataType;
+export declare const ArrayBitType: DataType;
+export declare const VarbitType: DataType;
+export declare const ArrayVarbitType: DataType;

package/data-types/bit-type.js

@@ -0,0 +1,91 @@
+import { DataTypeOIDs } from '../constants.js';
+/**
+ * `bit` and `varbit` are one type on the wire - the length is a property
+ * of the column, not of the value - so they share a codec and differ
+ * only in which OID they register under.
+ *
+ * Both decode to a string of `0` and `1`, which is what the type is:
+ * PostgreSQL prints it that way, accepts it back that way, and the
+ * alternatives are all worse. A number loses leading zeroes and anything
+ * past 53 bits; a Buffer loses the bit count, so `1` and `10000000`
+ * become the same eight padded bits. `pg` leaves it a string too.
+ */
+/** Every byte's eight bits, so decoding is one lookup per byte. */
+const BYTE_BITS = new Array(256);
+for (let i = 0; i < 256; i++)
+    BYTE_BITS[i] = i.toString(2).padStart(8, '0');
+const BIT_PATTERN = /^[01]*$/;
+/**
+ * An int32 bit count, then the bits themselves packed most-significant
+ * first and the last byte zero-padded. A zero-length value is the count
+ * and nothing else.
+ */
+function decode(v, offset) {
+    const bits = v.readInt32BE(offset);
+    const whole = bits >> 3;
+    const start = offset + 4;
+    let out = '';
+    let i;
+    for (i = 0; i < whole; i++)
+        out += BYTE_BITS[v[start + i]];
+    const rest = bits & 7;
+    if (rest)
+        out += BYTE_BITS[v[start + whole]].slice(0, rest);
+    return out;
+}
+function encode(buf, v, name) {
+    if (typeof v !== 'string' || !BIT_PATTERN.test(v))
+        throw new Error(`"${v}" is not a valid ${name} value - a string of 0 and 1 is`);
+    const bits = v.length;
+    buf.writeInt32BE(bits);
+    const bytes = Buffer.alloc((bits + 7) >> 3);
+    let i;
+    for (i = 0; i < bits; i++)
+        if (v.charCodeAt(i) === 49)
+            bytes[i >> 3] |= 128 >> (i & 7);
+    buf.writeBytes(bytes);
+}
+function createType(name, oid) {
+    return {
+        name,
+        oid,
+        jsType: 'string',
+        // `0` and `1` are ordinary characters, and a string of them is far
+        // more often text than a bit string - inferring this type would send
+        // `bit` where `text` was meant. See inet-type.ts.
+        inferrable: false,
+        encodeText(v) {
+            return '' + v;
+        },
+        encodeBinary(buf, v) {
+            encode(buf, v, name);
+        },
+        decodeBinary(v, offset = 0) {
+            return decode(v, offset);
+        },
+        decodeText(v) {
+            return v;
+        },
+        // Two characters, both ASCII - see inet-type.ts for why 'latin1'.
+        decodeTextBuffer(buf, offset, len) {
+            return buf.toString('latin1', offset, offset + len);
+        },
+        isType(v) {
+            return typeof v === 'string' && BIT_PATTERN.test(v);
+        },
+    };
+}
+export const BitType = createType('bit', DataTypeOIDs.bit);
+export const ArrayBitType = {
+    ...BitType,
+    name: '_bit',
+    oid: DataTypeOIDs._bit,
+    elementsOID: DataTypeOIDs.bit,
+};
+export const VarbitType = createType('varbit', DataTypeOIDs.varbit);
+export const ArrayVarbitType = {
+    ...VarbitType,
+    name: '_varbit',
+    oid: DataTypeOIDs._varbit,
+    elementsOID: DataTypeOIDs.varbit,
+};

package/data-types/box-type.js

@@ -1,11 +1,12 @@
 import { DataTypeOIDs } from '../constants.js';
+import { Box, TwoPoints } from './classes/geometric.js';
 const BOX_PATTERN1 = /^\( *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *\)$/;
 const BOX_PATTERN2 = /^\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\)$/;
 const BOX_PATTERN3 = /^(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *, *(-?\d+\.?\d*)$/;
 export const BoxType = {
     name: 'box',
     oid: DataTypeOIDs.box,
-    jsType: 'object',
+    jsType: 'Box',
     arraySeparator: ';',
     encodeText(v) {
         return `(${v.x1},${v.y1}),(${v.x2},${v.y2})`;
@@ -17,34 +18,23 @@ export const BoxType = {
         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 Box(v.readDoubleBE(offset), v.readDoubleBE(offset + 8), v.readDoubleBE(offset + 16), v.readDoubleBE(offset + 24));
     },
     decodeText(v) {
         const m = v.match(BOX_PATTERN1) || v.match(BOX_PATTERN2) || v.match(BOX_PATTERN3);
         if (!m)
             return undefined;
-        return {
-            x1: parseFloat(m[1]),
-            y1: parseFloat(m[2]),
-            x2: parseFloat(m[3]),
-            y2: parseFloat(m[4]),
-        };
+        return new Box(parseFloat(m[1]), parseFloat(m[2]), parseFloat(m[3]), parseFloat(m[4]));
     },
     decodeTextBuffer(buf, offset, len, options) {
         return BoxType.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 Box || TwoPoints.isTwoPointsLike(v);
     },
 };
 export const ArrayBoxType = {

package/data-types/circle-type.js

@@ -1,4 +1,5 @@
 import { DataTypeOIDs } from '../constants.js';
+import { Circle } from './classes/geometric.js';
 const CIRCLE_PATTERN1 = /^< *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *(-?\d+\.?\d*) *>$/;
 const CIRCLE_PATTERN2 = /^\( *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *(-?\d+\.?\d*) *\)$/;
 const CIRCLE_PATTERN3 = /^\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *(-?\d+\.?\d*)$/;
@@ -6,7 +7,7 @@ const CIRCLE_PATTERN4 = /^(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *, *(-?\d+\.?\d*)$/;
 export const CircleType = {
     name: 'circle',
     oid: DataTypeOIDs.circle,
-    jsType: 'object',
+    jsType: 'Circle',
     encodeText(v) {
         return `<(${v.x},${v.y}),${v.r}>`;
     },
@@ -16,11 +17,7 @@ export const CircleType = {
         buf.writeDoubleBE(v.r);
     },
     decodeBinary(v, offset = 0) {
-        return {
-            x: v.readDoubleBE(offset),
-            y: v.readDoubleBE(offset + 8),
-            r: v.readDoubleBE(offset + 16),
-        };
+        return new Circle(v.readDoubleBE(offset), v.readDoubleBE(offset + 8), v.readDoubleBE(offset + 16));
     },
     decodeText(v) {
         const m = v.match(CIRCLE_PATTERN1) ||
@@ -29,22 +26,15 @@ export const CircleType = {
             v.match(CIRCLE_PATTERN4);
         if (!m)
             return undefined;
-        return {
-            x: parseFloat(m[1]),
-            y: parseFloat(m[2]),
-            r: parseFloat(m[3]),
-        };
+        return new Circle(parseFloat(m[1]), parseFloat(m[2]), parseFloat(m[3]));
     },
     // See box-type.ts's decodeTextBuffer comment - same rationale.
     decodeTextBuffer(buf, offset, len, options) {
         return CircleType.decodeText(buf.toString('latin1', offset, offset + len), options);
     },
+    // See point-type.ts: the plain object shape is still accepted.
     isType(v) {
-        return (typeof v === 'object' &&
-            Object.keys(v).length === 3 &&
-            typeof v.x === 'number' &&
-            typeof v.y === 'number' &&
-            typeof v.r === 'number');
+        return v instanceof Circle || Circle.isCircleLike(v);
     },
 };
 export const ArrayCircleType = {

package/data-types/classes/geometric.d.ts

@@ -0,0 +1,105 @@
+/** A `point`: one position. */
+export declare class Point {
+    x: number;
+    y: number;
+    constructor(x?: number, y?: number);
+    /** As PostgreSQL prints it, so it casts back through `::point`. */
+    toString(): string;
+    toJSON(): string;
+    static isPointLike(v: any): boolean;
+}
+/** A `circle`: a centre and a radius. */
+export declare class Circle {
+    x: number;
+    y: number;
+    r: number;
+    constructor(x?: number, y?: number, r?: number);
+    /** As PostgreSQL prints it, so it casts back through `::circle`. */
+    toString(): string;
+    toJSON(): string;
+    static isCircleLike(v: any): boolean;
+}
+/**
+ * Two corners, which is how both `box` and `lseg` are carried - and why
+ * they are two classes rather than one shared shape. They were
+ * indistinguishable as plain objects: both types' isType() accepted
+ * `{x1, y1, x2, y2}`, so `determine()` answered `box` for every one of
+ * them and an lseg parameter could not be expressed at all.
+ */
+declare abstract class TwoPoints {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    constructor(x1?: number, y1?: number, x2?: number, y2?: number);
+    toJSON(): string;
+    static isTwoPointsLike(v: any): boolean;
+}
+/** A `box`: a rectangle given by two opposite corners. */
+export declare class Box extends TwoPoints {
+    /** As PostgreSQL prints it, so it casts back through `::box`. */
+    toString(): string;
+}
+/** An `lseg`: the straight line between two points. */
+export declare class LineSegment extends TwoPoints {
+    /** As PostgreSQL prints it, so it casts back through `::lseg`. */
+    toString(): string;
+}
+/**
+ * A `line`: the infinite line Ax + By + C = 0.
+ *
+ * PostgreSQL stores and prints the three coefficients whatever form the
+ * literal took - `line '((0,0),(1,1))'` comes back as `{1,-1,0}` - so
+ * that is what this carries. A pair of points would be a second, lossy
+ * spelling of the same thing, since a line through them is not the
+ * points.
+ */
+export declare class Line {
+    a: number;
+    b: number;
+    c: number;
+    constructor(a?: number, b?: number, c?: number);
+    /** As PostgreSQL prints it, so it casts back through `::line`. */
+    toString(): string;
+    toJSON(): string;
+    static isLineLike(v: any): boolean;
+}
+/**
+ * The list of points `path` and `polygon` share. They are two classes
+ * rather than one for the same reason `Box` and `LineSegment` are: the
+ * values are indistinguishable by shape, so only the class can say which
+ * type a parameter is meant for.
+ */
+declare abstract class PointList {
+    points: Point[];
+    /** Plain `{x, y}` objects are accepted and kept as Points. */
+    constructor(points?: (Point | {
+        x: number;
+        y: number;
+    })[]);
+    toJSON(): string;
+    protected join(): string;
+}
+/**
+ * A `path`: a series of points, open or closed.
+ *
+ * Closed is the default because it is PostgreSQL's - a literal written
+ * without brackets, `path '1,2,3,4'`, comes back closed. The flag is
+ * part of the value and not a formatting choice: the server stores it
+ * and prints `[...]` for an open path against `(...)` for a closed one.
+ */
+export declare class Path extends PointList {
+    isClosed: boolean;
+    constructor(points?: (Point | {
+        x: number;
+        y: number;
+    })[], isClosed?: boolean);
+    /** As PostgreSQL prints it, so it casts back through `::path`. */
+    toString(): string;
+}
+/** A `polygon`: a closed series of points. */
+export declare class Polygon extends PointList {
+    /** As PostgreSQL prints it, so it casts back through `::polygon`. */
+    toString(): string;
+}
+export { PointList, TwoPoints };

package/data-types/classes/geometric.js

@@ -0,0 +1,197 @@
+/**
+ * Whether a value is a bare object literal rather than an instance of
+ * some class.
+ *
+ * The geometric types accept both - a Point, and the `{x, y}` that was
+ * the only thing they returned before these classes existed - but a
+ * BoxType must not claim a LineSegment just because it carries the same
+ * four numbers, so the shape check is limited to plain objects.
+ */
+function isPlainObject(v) {
+    return (v !== null &&
+        typeof v === 'object' &&
+        Object.getPrototypeOf(v) === Object.prototype);
+}
+function isNum(v) {
+    return typeof v === 'number';
+}
+/** A `point`: one position. */
+export class Point {
+    x;
+    y;
+    constructor(x = 0, y = 0) {
+        this.x = x;
+        this.y = y;
+    }
+    /** As PostgreSQL prints it, so it casts back through `::point`. */
+    toString() {
+        return `(${this.x},${this.y})`;
+    }
+    toJSON() {
+        return this.toString();
+    }
+    /* c8 ignore next 3 */
+    static isPointLike(v) {
+        return (isPlainObject(v) &&
+            Object.keys(v).length === 2 &&
+            isNum(v.x) &&
+            isNum(v.y));
+    }
+}
+/** A `circle`: a centre and a radius. */
+export class Circle {
+    x;
+    y;
+    r;
+    constructor(x = 0, y = 0, r = 0) {
+        this.x = x;
+        this.y = y;
+        this.r = r;
+    }
+    /** As PostgreSQL prints it, so it casts back through `::circle`. */
+    toString() {
+        return `<(${this.x},${this.y}),${this.r}>`;
+    }
+    toJSON() {
+        return this.toString();
+    }
+    static isCircleLike(v) {
+        return (isPlainObject(v) &&
+            Object.keys(v).length === 3 &&
+            isNum(v.x) &&
+            isNum(v.y) &&
+            isNum(v.r));
+    }
+}
+/**
+ * Two corners, which is how both `box` and `lseg` are carried - and why
+ * they are two classes rather than one shared shape. They were
+ * indistinguishable as plain objects: both types' isType() accepted
+ * `{x1, y1, x2, y2}`, so `determine()` answered `box` for every one of
+ * them and an lseg parameter could not be expressed at all.
+ */
+class TwoPoints {
+    x1;
+    y1;
+    x2;
+    y2;
+    constructor(x1 = 0, y1 = 0, x2 = 0, y2 = 0) {
+        this.x1 = x1;
+        this.y1 = y1;
+        this.x2 = x2;
+        this.y2 = y2;
+    }
+    toJSON() {
+        return this.toString();
+    }
+    static isTwoPointsLike(v) {
+        return (isPlainObject(v) &&
+            Object.keys(v).length === 4 &&
+            isNum(v.x1) &&
+            isNum(v.y1) &&
+            isNum(v.x2) &&
+            isNum(v.y2));
+    }
+}
+/** A `box`: a rectangle given by two opposite corners. */
+export class Box extends TwoPoints {
+    /** As PostgreSQL prints it, so it casts back through `::box`. */
+    toString() {
+        return `(${this.x1},${this.y1}),(${this.x2},${this.y2})`;
+    }
+}
+/** An `lseg`: the straight line between two points. */
+export class LineSegment extends TwoPoints {
+    /** As PostgreSQL prints it, so it casts back through `::lseg`. */
+    toString() {
+        return `[(${this.x1},${this.y1}),(${this.x2},${this.y2})]`;
+    }
+}
+/**
+ * A `line`: the infinite line Ax + By + C = 0.
+ *
+ * PostgreSQL stores and prints the three coefficients whatever form the
+ * literal took - `line '((0,0),(1,1))'` comes back as `{1,-1,0}` - so
+ * that is what this carries. A pair of points would be a second, lossy
+ * spelling of the same thing, since a line through them is not the
+ * points.
+ */
+export class Line {
+    a;
+    b;
+    c;
+    constructor(a = 0, b = 0, c = 0) {
+        this.a = a;
+        this.b = b;
+        this.c = c;
+    }
+    /** As PostgreSQL prints it, so it casts back through `::line`. */
+    toString() {
+        return `{${this.a},${this.b},${this.c}}`;
+    }
+    toJSON() {
+        return this.toString();
+    }
+    static isLineLike(v) {
+        return (isPlainObject(v) &&
+            Object.keys(v).length === 3 &&
+            isNum(v.a) &&
+            isNum(v.b) &&
+            isNum(v.c));
+    }
+}
+/**
+ * The list of points `path` and `polygon` share. They are two classes
+ * rather than one for the same reason `Box` and `LineSegment` are: the
+ * values are indistinguishable by shape, so only the class can say which
+ * type a parameter is meant for.
+ */
+class PointList {
+    points;
+    /** Plain `{x, y}` objects are accepted and kept as Points. */
+    constructor(points = []) {
+        this.points = points.map(p => p instanceof Point ? p : new Point(p.x, p.y));
+    }
+    toJSON() {
+        return this.toString();
+    }
+    join() {
+        let out = '';
+        const l = this.points.length;
+        let i;
+        for (i = 0; i < l; i++) {
+            if (i)
+                out += ',';
+            out += this.points[i].toString();
+        }
+        return out;
+    }
+}
+/**
+ * A `path`: a series of points, open or closed.
+ *
+ * Closed is the default because it is PostgreSQL's - a literal written
+ * without brackets, `path '1,2,3,4'`, comes back closed. The flag is
+ * part of the value and not a formatting choice: the server stores it
+ * and prints `[...]` for an open path against `(...)` for a closed one.
+ */
+export class Path extends PointList {
+    isClosed;
+    constructor(points = [], isClosed = true) {
+        super(points);
+        this.isClosed = isClosed;
+    }
+    /** As PostgreSQL prints it, so it casts back through `::path`. */
+    toString() {
+        const inner = this.join();
+        return this.isClosed ? `(${inner})` : `[${inner}]`;
+    }
+}
+/** A `polygon`: a closed series of points. */
+export class Polygon extends PointList {
+    /** As PostgreSQL prints it, so it casts back through `::polygon`. */
+    toString() {
+        return `(${this.join()})`;
+    }
+}
+export { PointList, TwoPoints };