postgrejs 3.6.1 → 3.7.0

package/data-types/inet-type.js

@@ -0,0 +1,286 @@
+import { DataTypeOIDs } from '../constants.js';
+/**
+ * `inet` and `cidr` share a file because they share everything that
+ * matters: one wire format, one JavaScript shape, and one pair of
+ * conversions. A single flag byte tells them apart on the wire, and on
+ * output the only difference is whether the netmask is always printed.
+ *
+ * Both decode to a string. JavaScript has no address type, and every Node
+ * API that takes an address - `net`, `dns`, `http` - takes a string, so an
+ * object of parts would be something every caller has to join back
+ * together before using. `pg` answers with a string too.
+ */
+/**
+ * PostgreSQL's own address-family numbers, deliberately not the
+ * platform's: they are written into the stored value, so they cannot
+ * depend on how a particular `<sys/socket.h>` happens to number `AF_INET6`.
+ */
+const PGSQL_AF_INET = 2;
+const PGSQL_AF_INET6 = 3;
+const IPV4_PATTERN = /^\d{1,3}(?:\.\d{1,3}){0,3}$/;
+const IPV6_GROUP_PATTERN = /^[0-9a-fA-F]{1,4}$/;
+/**
+ * Writes the four octets of an IPv4 address.
+ *
+ * Fewer than four is allowed, the rest reading as zero - `10/8` for
+ * `10.0.0.0/8`. That is PostgreSQL's own rule for both types, confirmed
+ * against the server rather than assumed: `inet '10.0/16'` is accepted
+ * and stored as `10.0.0.0/16`.
+ */
+function writeIPv4(out, offset, v) {
+    if (!IPV4_PATTERN.test(v))
+        return false;
+    const parts = v.split('.');
+    const l = parts.length;
+    let i;
+    let n;
+    for (i = 0; i < l; i++) {
+        n = +parts[i];
+        if (n > 255)
+            return false;
+        out[offset + i] = n;
+    }
+    return true;
+}
+/**
+ * Writes the sixteen bytes of an IPv6 address, accepting the two
+ * shorthands the server does: a single `::` standing for at least one
+ * all-zero group, and a trailing dotted-quad for the last two groups.
+ */
+function writeIPv6(out, offset, v) {
+    const dot = v.indexOf('.');
+    if (dot >= 0) {
+        // An embedded IPv4 tail occupies the last two groups. Rewritten into
+        // hex here so the group walk below does not have to know about it.
+        const i = v.lastIndexOf(':', dot);
+        if (i < 0)
+            return false;
+        const quad = Buffer.alloc(4);
+        const tail = v.slice(i + 1);
+        // Unlike a bare IPv4 address, the embedded form has no abbreviated
+        // spelling - `::1.2` is not an address.
+        if (tail.split('.').length !== 4 || !writeIPv4(quad, 0, tail))
+            return false;
+        v =
+            v.slice(0, i + 1) +
+                quad.readUInt16BE(0).toString(16) +
+                ':' +
+                quad.readUInt16BE(2).toString(16);
+    }
+    const halves = v.split('::');
+    if (halves.length > 2)
+        return false;
+    const head = halves[0] ? halves[0].split(':') : [];
+    const tail = halves.length === 2 && halves[1] ? halves[1].split(':') : [];
+    const given = head.length + tail.length;
+    // Without `::` every group must be written out; with it, at least one
+    // must be left for the `::` itself to stand for.
+    if (halves.length === 2 ? given > 7 : given !== 8)
+        return false;
+    out.fill(0, offset, offset + 16);
+    let p = offset;
+    let g;
+    for (g of head) {
+        if (!IPV6_GROUP_PATTERN.test(g))
+            return false;
+        out.writeUInt16BE(parseInt(g, 16), p);
+        p += 2;
+    }
+    p = offset + 16 - tail.length * 2;
+    for (g of tail) {
+        if (!IPV6_GROUP_PATTERN.test(g))
+            return false;
+        out.writeUInt16BE(parseInt(g, 16), p);
+        p += 2;
+    }
+    return true;
+}
+/**
+ * Renders sixteen bytes the way `inet_net_ntop()` does, which is what
+ * this has to match - not any general IPv6 convention - because the
+ * point is to hand back the string the server itself would have printed.
+ *
+ * The longest run of zero groups collapses to `::`, but only when it
+ * covers at least two of them (`::2:3:4:5:6:7:8` comes back from the
+ * server as `0:2:3:4:5:6:7:8`), and the earliest run wins a tie. An
+ * address whose last four bytes are really an IPv4 one is printed in
+ * dotted form.
+ */
+function formatIPv6(buf, offset) {
+    const words = new Array(8);
+    let i;
+    for (i = 0; i < 8; i++)
+        words[i] = buf.readUInt16BE(offset + i * 2);
+    let bestBase = -1;
+    let bestLen = 0;
+    let curBase = -1;
+    let curLen = 0;
+    for (i = 0; i < 8; i++) {
+        if (words[i] !== 0) {
+            curBase = -1;
+            continue;
+        }
+        if (curBase === -1) {
+            curBase = i;
+            curLen = 1;
+        }
+        else
+            curLen++;
+        if (curLen > bestLen) {
+            bestBase = curBase;
+            bestLen = curLen;
+        }
+    }
+    if (bestLen < 2)
+        bestBase = -1;
+    let out = '';
+    for (i = 0; i < 8; i++) {
+        if (bestBase !== -1 && i >= bestBase && i < bestBase + bestLen) {
+            if (i === bestBase)
+                out += ':';
+            continue;
+        }
+        if (i !== 0)
+            out += ':';
+        // `::a.b.c.d` and `::ffff:a.b.c.d` - the two prefixes that mean the
+        // tail is an IPv4 address. Nothing else qualifies, so `::1:1.2.3.4`
+        // prints as `::1:102:304`.
+        if (i === 6 &&
+            bestBase === 0 &&
+            (bestLen === 6 || (bestLen === 5 && words[5] === 0xffff))) {
+            out +=
+                buf[offset + 12] +
+                    '.' +
+                    buf[offset + 13] +
+                    '.' +
+                    buf[offset + 14] +
+                    '.' +
+                    buf[offset + 15];
+            break;
+        }
+        out += words[i].toString(16);
+    }
+    // A run that reaches the end leaves only one colon behind.
+    if (bestBase !== -1 && bestBase + bestLen === 8)
+        out += ':';
+    return out;
+}
+/**
+ * The address and its netmask, or undefined if the string is not one.
+ * Splitting is done here rather than by the caller because the two types
+ * differ only in what they do with the parts.
+ */
+function parseAddress(v) {
+    if (typeof v !== 'string')
+        return undefined;
+    const slash = v.indexOf('/');
+    const addr = slash < 0 ? v : v.slice(0, slash);
+    const family = addr.includes(':') ? PGSQL_AF_INET6 : PGSQL_AF_INET;
+    const size = family === PGSQL_AF_INET6 ? 16 : 4;
+    const bytes = Buffer.alloc(size);
+    const ok = family === PGSQL_AF_INET6
+        ? writeIPv6(bytes, 0, addr)
+        : writeIPv4(bytes, 0, addr);
+    if (!ok)
+        return undefined;
+    let bits = size * 8;
+    if (slash >= 0) {
+        const s = v.slice(slash + 1);
+        if (!/^\d{1,3}$/.test(s))
+            return undefined;
+        bits = +s;
+        if (bits > size * 8)
+            return undefined;
+    }
+    return { family, bits, bytes };
+}
+function encode(buf, v, isCidr) {
+    const a = parseAddress(v);
+    if (!a)
+        throw new Error(`"${v}" is not a valid ${isCidr ? 'cidr' : 'inet'} value`);
+    buf.writeUInt8(a.family);
+    // Unsigned: a full IPv6 mask is 128, which does not fit a signed byte.
+    buf.writeUInt8(a.bits);
+    buf.writeUInt8(isCidr ? 1 : 0);
+    buf.writeUInt8(a.bytes.length);
+    buf.writeBytes(a.bytes);
+}
+/**
+ * Four header bytes - family, netmask bits, the cidr flag and the
+ * address length - then the address itself. The flag is what decides
+ * whether the netmask is printed, so one decoder serves both types: a
+ * `cidr` always carries its mask, an `inet` only when it is not the whole
+ * address.
+ */
+function decode(v, offset) {
+    const family = v[offset];
+    const bits = v[offset + 1];
+    const isCidr = v[offset + 2];
+    const size = v[offset + 3];
+    if (family !== PGSQL_AF_INET && family !== PGSQL_AF_INET6)
+        throw new Error(`Unknown address family ${family} in inet value`);
+    const text = family === PGSQL_AF_INET6
+        ? formatIPv6(v, offset + 4)
+        : v[offset + 4] +
+            '.' +
+            v[offset + 5] +
+            '.' +
+            v[offset + 6] +
+            '.' +
+            v[offset + 7];
+    return isCidr || bits !== size * 8 ? text + '/' + bits : text;
+}
+export const InetType = {
+    name: 'inet',
+    oid: DataTypeOIDs.inet,
+    jsType: 'string',
+    // An address is not a shape - it is a string like any other, and an
+    // application storing one in a `text` column passes exactly the same
+    // value. Inferring this type from a string would send `inet` where
+    // `text` was meant and break that query, so the type is reached only by
+    // naming it: `new BindParam(DataTypeOIDs.inet, '192.168.0.1')`, or a
+    // column whose declared type says so.
+    inferrable: false,
+    encodeText(v) {
+        // Handed to the server as written; it does its own parsing here, and
+        // accepts spellings this file's own parser is not asked to know.
+        return '' + v;
+    },
+    encodeBinary(buf, v) {
+        encode(buf, v, false);
+    },
+    decodeBinary(v, offset = 0) {
+        return decode(v, offset);
+    },
+    decodeText(v) {
+        return v;
+    },
+    // An address is pure ASCII, so 'latin1' decodes identically to 'utf8'
+    // while skipping V8's multi-byte-sequence detection.
+    decodeTextBuffer(buf, offset, len) {
+        return buf.toString('latin1', offset, offset + len);
+    },
+    isType(v) {
+        return !!parseAddress(v);
+    },
+};
+export const ArrayInetType = {
+    ...InetType,
+    name: '_inet',
+    oid: DataTypeOIDs._inet,
+    elementsOID: DataTypeOIDs.inet,
+};
+export const CidrType = {
+    ...InetType,
+    name: 'cidr',
+    oid: DataTypeOIDs.cidr,
+    encodeBinary(buf, v) {
+        encode(buf, v, true);
+    },
+};
+export const ArrayCidrType = {
+    ...CidrType,
+    name: '_cidr',
+    oid: DataTypeOIDs._cidr,
+    elementsOID: DataTypeOIDs.cidr,
+};

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

@@ -0,0 +1,5 @@
+import type { DataType } from '../interfaces/data-type.js';
+import { Interval } from './classes/interval.js';
+export declare function parseIntervalText(v: string): Interval;
+export declare const IntervalType: DataType;
+export declare const ArrayIntervalType: DataType;

package/data-types/interval-type.js

@@ -0,0 +1,79 @@
+import { DataTypeOIDs } from '../constants.js';
+import { readBigInt64BE } from '../util/bigint-methods.js';
+import { Interval } from './classes/interval.js';
+/**
+ * What PostgreSQL prints under the default `IntervalStyle` - years, months
+ * and days as counted words, then a signed clock time. Every part is
+ * optional and the server omits the ones that are zero, except that a
+ * wholly zero interval still prints `00:00:00`.
+ */
+const INTERVAL_PATTERN = /^\s*(?:([+-]?\d+)\s+years?\s*)?(?:([+-]?\d+)\s+mons?\s*)?(?:([+-]?\d+)\s+days?\s*)?(?:([+-])?(\d+):(\d\d):(\d\d)(?:\.(\d{1,6}))?)?\s*$/;
+function toInterval(v) {
+    if (v instanceof Interval)
+        return v;
+    if (typeof v === 'string')
+        return parseIntervalText(v);
+    if (v && typeof v === 'object')
+        return new Interval(v);
+    throw new TypeError(`"${typeof v}" cannot be encoded as an interval - pass an Interval, ` +
+        'a plain object of its fields, or a string PostgreSQL would accept');
+}
+export function parseIntervalText(v) {
+    const m = INTERVAL_PATTERN.exec(v);
+    if (!m) {
+        // Rather than answering with a zero interval, which is what reading
+        // an unrecognized shape leniently would amount to. The other styles
+        // (`sql_standard`, `postgres_verbose`, `iso_8601`) are not parsed
+        // here, and the binary path - which is the default - never sees any
+        // of this.
+        throw new Error(`"${v}" is not an interval in PostgreSQL's default IntervalStyle`);
+    }
+    const sign = m[4] === '-' ? -1 : 1;
+    return new Interval({
+        years: m[1] ? parseInt(m[1], 10) : 0,
+        months: m[2] ? parseInt(m[2], 10) : 0,
+        days: m[3] ? parseInt(m[3], 10) : 0,
+        hours: m[5] ? sign * parseInt(m[5], 10) : 0,
+        minutes: m[6] ? sign * parseInt(m[6], 10) : 0,
+        seconds: m[7] ? sign * parseInt(m[7], 10) : 0,
+        // The fraction is microseconds with trailing zeroes dropped, so `.5`
+        // is half a second rather than five microseconds.
+        milliseconds: m[8] ? (sign * parseInt(m[8].padEnd(6, '0'), 10)) / 1000 : 0,
+    });
+}
+export const IntervalType = {
+    name: 'interval',
+    oid: DataTypeOIDs.interval,
+    jsType: 'Interval',
+    /**
+     * 16 bytes, and three separate quantities rather than one total: a
+     * signed microsecond count for the time, then a day count and a month
+     * count. The server keeps them apart because they are not convertible -
+     * see the Interval class.
+     */
+    decodeBinary(v, offset = 0) {
+        const micros = typeof v.readBigInt64BE === 'function'
+            ? v.readBigInt64BE(offset)
+            : readBigInt64BE(v, offset);
+        return Interval.fromParts(micros, v.readInt32BE(offset + 8), v.readInt32BE(offset + 12));
+    },
+    encodeBinary(buf, v) {
+        const iv = toInterval(v);
+        buf.writeBigInt64BE(iv.totalMicroseconds);
+        buf.writeInt32BE(iv.days);
+        buf.writeInt32BE(iv.totalMonths);
+    },
+    decodeText: parseIntervalText,
+    encodeText(v) {
+        return toInterval(v).toString();
+    },
+    isType(v) {
+        return v instanceof Interval;
+    },
+};
+export const ArrayIntervalType = {
+    ...IntervalType,
+    name: '_interval',
+    oid: DataTypeOIDs._interval,
+    elementsOID: DataTypeOIDs.interval,
+};

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

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

package/data-types/jsonpath-type.js

@@ -0,0 +1,53 @@
+import { DataTypeOIDs } from '../constants.js';
+/**
+ * A jsonpath decodes to a string, and there is nothing else it could
+ * sensibly be: the binary form is the text form with one byte in front
+ * of it. Parsing the expression into a tree would be inventing an API
+ * for something the server already understands and this client never
+ * evaluates. `pg` leaves it a string too.
+ *
+ * The string that comes back is PostgreSQL's normalized spelling, not
+ * what was written - `$.a[*].b` is stored and printed as `$."a"[*]."b"`.
+ */
+/** The only format the server has ever written, and the one it reads. */
+const JSONPATH_VERSION = 1;
+export const JsonPathType = {
+    name: 'jsonpath',
+    oid: DataTypeOIDs.jsonpath,
+    jsType: 'string',
+    // A jsonpath is a string, and inferring this type from one would send
+    // `jsonpath` where `text` was meant. See inet-type.ts.
+    inferrable: false,
+    encodeText(v) {
+        return '' + v;
+    },
+    /** A version byte, then the expression as UTF-8 - no length prefix. */
+    encodeBinary(buf, v) {
+        if (typeof v !== 'string')
+            throw new Error(`"${v}" is not a valid jsonpath value`);
+        buf.writeUInt8(JSONPATH_VERSION);
+        buf.writeString(v, 'utf8');
+    },
+    decodeBinary(v, offset = 0, len) {
+        const version = v[offset];
+        if (version !== JSONPATH_VERSION)
+            throw new Error(`Unsupported jsonpath version ${version}`);
+        return v.toString('utf8', offset + 1, offset + len);
+    },
+    decodeText(v) {
+        return v;
+    },
+    isType(v) {
+        // Every jsonpath begins with a variable or a mode word, and `$` is
+        // the only variable an expression can start with once `strict` or
+        // `lax` is allowed for - enough to tell a path from ordinary text
+        // without parsing one.
+        return typeof v === 'string' && /^\s*(?:(?:strict|lax)\s+)?[$@]/.test(v);
+    },
+};
+export const ArrayJsonPathType = {
+    ...JsonPathType,
+    name: '_jsonpath',
+    oid: DataTypeOIDs._jsonpath,
+    elementsOID: DataTypeOIDs.jsonpath,
+};

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

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

package/data-types/line-type.js

@@ -0,0 +1,41 @@
+import { DataTypeOIDs } from '../constants.js';
+import { Line } from './classes/geometric.js';
+const LINE_PATTERN = /^\{ *(-?[\d.]+(?:e[-+]?\d+)?) *, *(-?[\d.]+(?:e[-+]?\d+)?) *, *(-?[\d.]+(?:e[-+]?\d+)?) *\}$/i;
+export const LineType = {
+    name: 'line',
+    oid: DataTypeOIDs.line,
+    jsType: 'Line',
+    encodeText(v) {
+        return `{${v.a},${v.b},${v.c}}`;
+    },
+    /** Three float8s: the A, B and C of Ax + By + C = 0. */
+    encodeBinary(buf, v) {
+        buf.writeDoubleBE(v.a);
+        buf.writeDoubleBE(v.b);
+        buf.writeDoubleBE(v.c);
+    },
+    decodeBinary(v, offset = 0) {
+        return new Line(v.readDoubleBE(offset), v.readDoubleBE(offset + 8), v.readDoubleBE(offset + 16));
+    },
+    decodeText(v) {
+        const m = v.match(LINE_PATTERN);
+        if (!m)
+            return undefined;
+        return new Line(parseFloat(m[1]), parseFloat(m[2]), parseFloat(m[3]));
+    },
+    // See box-type.ts's decodeTextBuffer comment - same rationale.
+    decodeTextBuffer(buf, offset, len, options) {
+        return LineType.decodeText(buf.toString('latin1', offset, offset + len), options);
+    },
+    // A plain `{a, b, c}` is accepted for the same reason `{x, y}` is by
+    // point - see point-type.ts.
+    isType(v) {
+        return v instanceof Line || Line.isLineLike(v);
+    },
+};
+export const ArrayLineType = {
+    ...LineType,
+    name: '_line',
+    oid: DataTypeOIDs._line,
+    elementsOID: DataTypeOIDs.line,
+};

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,
+};