@juit/pgproxy-types 1.0.0

package/src/parsers/bytea.ts

@@ -0,0 +1,77 @@
+/* ========================================================================== *
+ * INTERNALS                                                                  *
+ * ========================================================================== */
+
+/* Internal interface mimicking NodeJS's `Buffer`'s constructor */
+interface NodeJSBuffer {
+  from(source:string, format: 'hex'): Uint8Array
+  from(source:Uint8Array): Uint8Array
+}
+
+/** Parse a BYTEA encoded in HEX */
+function parseEncoded(input: string): Uint8Array {
+  const array = new Uint8Array((input.length - 2) / 2)
+  let index = 0
+  for (let i = 2; i < input.length; i += 2) {
+    array[index ++] = parseInt(input.substring(i, i + 2), 16)
+  }
+  return array
+}
+
+/** Parse a BYTEA using the _escaped_ format */
+function parseEscaped(input: string, Buffer?: NodeJSBuffer | null): Uint8Array {
+  const result = new Uint8Array(input.length)
+  let pos = 0
+
+  for (let i = 0; i < input.length; i ++) {
+    const code = input.charCodeAt(i)
+    if (code !== 0x5c) {
+      /* Simple non-escaped character */
+      result[pos ++] = code
+    } else {
+      /* If we have a backslash, it may be followed by three octal digits */
+      const token = input.substring(i + 1, i + 4)
+      if (/[0-7]{3}/.test(token)) {
+        result[pos ++] = parseInt(token, 8)
+        i += 3 // advance after the octal number
+      } else {
+        /* Count how may backslashes we got... */
+        let backslashes = 1
+
+        for (
+          let char = input[++i];
+          (i < input.length) && (char === '\\');
+          char = input[++i]
+        ) backslashes ++
+
+        /* Fill the result with HALF the backslashes (escaped) */
+        result.fill(0x5c, pos, pos += backslashes >>> 1)
+
+        /* We consumed the character after the backslash */
+        i --
+      }
+    }
+  }
+
+  /* Return wrapping Buffer.from(array) with a subarray, or just a slice... */
+  return Buffer ? Buffer.from(result.subarray(0, pos)) : result.slice(0, pos)
+}
+
+/* ========================================================================== *
+ * EXPORTED PARSER                                                            *
+ * ========================================================================== */
+
+/** Parse a PostgreSQL `BYTEA` string (escaped or encoded in hexadecimal) */
+export function parseByteA(input: string, Buffer?: NodeJSBuffer | null): Uint8Array
+/* Overload defaulting `Buffer` to `globalThis.Buffer` (Node's Buffer class) */
+export function parseByteA(
+    input: string,
+    Buffer: NodeJSBuffer | null | undefined = (globalThis as any).Buffer,
+): Uint8Array {
+  if (input.startsWith('\\x')) {
+    /* Shortcut for NodeJS, use Buffer.from(str, 'hex') */
+    return Buffer ? Buffer.from(input.substring(2), 'hex') : parseEncoded(input)
+  } else {
+    return parseEscaped(input, Buffer)
+  }
+}

package/src/parsers/geometric.ts

@@ -0,0 +1,96 @@
+import type { PGParser } from '../parsers'
+import type { PGSerializable } from '../serializers'
+
+/* ========================================================================== *
+ * GEOMETRIC TYPES                                                            *
+ * ========================================================================== */
+
+/** A parsed PostgreSQL `point` */
+export interface PGPoint extends PGSerializable {
+  readonly x: number,
+  readonly y: number,
+}
+
+/** A parsed PostgreSQL `circle` */
+export interface PGCircle extends PGPoint {
+  readonly radius: number,
+}
+
+/** Constructor for {@link PGPoint} */
+export interface PGPointConstructor {
+  new(x: number, y: number): PGPoint
+}
+
+/** Constructor for {@link PGCircle} */
+export interface PGCircleConstructor {
+  new(x: number, y: number, radius: number): PGCircle
+}
+
+
+/** Create a new {@link PGPoint} instance */
+export const PGPoint: PGPointConstructor = class PGPointImpl implements PGPoint {
+  constructor(public readonly x: number, public readonly y: number) {}
+
+  toPostgres(): string {
+    return `(${this.x},${this.y})`
+  }
+}
+
+/** Create a new {@link PGCircle} instance */
+export const PGCircle: PGCircleConstructor = class PGCircleImpl extends PGPoint implements PGCircle {
+  constructor(x: number, y: number, public readonly radius: number) {
+    super(x, y)
+  }
+
+  toPostgres(): string {
+    return `<(${this.x},${this.y}),${this.radius}>`
+  }
+}
+
+/* ===== INVALID CONSTANTS ================================================== */
+
+const INVALID_POINT = new PGPoint(NaN, NaN)
+const INVALID_CIRCLE = new PGCircle(NaN, NaN, NaN)
+
+/* ========================================================================== *
+ * PARSERS                                                                    *
+ * ========================================================================== */
+
+/** Parse a PostgreSQL `point` */
+export const parsePoint: PGParser<PGPoint> = (value: string): PGPoint => {
+  if (value[0] !== '(') return INVALID_POINT
+
+  const values = value.substring(1, value.length - 1).split(',')
+
+  return new PGPoint(parseFloat(values[0]!), parseFloat(values[1]!))
+}
+
+/** Parse a PostgreSQL `circle` */
+export const parseCircle: PGParser<PGCircle> = (value: string): PGCircle => {
+  if (value[0] !== '<' && value[1] !== '(') return INVALID_CIRCLE
+
+  let point = '('
+  let radius = ''
+  let pointParsed = false
+  for (let i = 2; i < value.length - 1; i++) {
+    if (!pointParsed) {
+      point += value[i]
+    }
+
+    if (value[i] === ')') {
+      pointParsed = true
+      continue
+    } else if (!pointParsed) {
+      continue
+    }
+
+    if (value[i] === ',') {
+      continue
+    }
+
+    radius += value[i]
+  }
+
+  const { x, y } = parsePoint(point)
+  return new PGCircle(x, y, parseFloat(radius))
+}

package/src/parsers/interval.ts

@@ -0,0 +1,40 @@
+import postgresInterval from 'postgres-interval'
+
+import type { PGParser } from '../parsers'
+import type { PGSerializable } from '../serializers'
+
+/** A parsed PostgreSQL `interval` */
+export interface PGInterval extends PGSerializable {
+  years: number;
+  months: number;
+  days: number;
+  hours: number;
+  minutes: number;
+  seconds: number;
+  milliseconds: number;
+
+  toISO(): string;
+  toISOString(): string;
+  toISOStringShort(): string;
+}
+
+/** Constructor for {@link PGInterval} */
+export interface PGIntervalConstructor {
+  new (value: string): PGInterval
+}
+
+// The "postgres-interval" code exports a function, not a class, but still
+// declares all its prototype and whatnot in there... Types are wrong!
+const PostgresInterval: PGIntervalConstructor = postgresInterval as any
+
+/** A parsed PostgreSQL `interval` */
+export const PGInterval: PGIntervalConstructor = class PGIntervalImpl
+  extends PostgresInterval
+  implements PGInterval {
+  constructor(value: string) {
+    super(value)
+  }
+}
+
+/** Parse a PostgreSQL `interval` */
+export const parseInterval: PGParser<PGInterval> = (value: string) => new PGInterval(value)

package/src/parsers/range.ts

@@ -0,0 +1,128 @@
+import postgresRange from 'postgres-range'
+
+import { parseArray } from './array'
+import { parseBigint, parseString, parseTimestamp, parseTimestampTz } from './basic'
+
+import type { PGParser } from '../parsers'
+import type { PGSerializable, PGSerialize } from '../serializers'
+import type { PGArray } from './array'
+
+/* ========================================================================== *
+ * PGRANGE TYPE                                                               *
+ * ========================================================================== */
+
+/** A parsed PostgreSQL `range` */
+export interface PGRange<T> {
+  readonly lower: T | null
+  readonly upper: T | null
+  readonly mask: number
+
+  hasMask(flags: number): boolean
+  isBounded(): boolean
+  isEmpty(): boolean
+  isLowerBoundClosed(): boolean
+  isUpperBoundClosed(): boolean
+  hasLowerBound(): boolean
+  hasUpperBound(): boolean
+
+  containsPoint(point: T): boolean
+  containsRange(range: PGRange<T>): boolean
+}
+
+/** Constructor (with static constants) for {@link PGRange} */
+export interface PGRangeConstructor {
+  new <T>(lower: T | null, upper: T | null, flags: number): PGRange<T>
+
+  readonly RANGE_EMPTY: number
+  readonly RANGE_LB_INC: number
+  readonly RANGE_UB_INC: number
+  readonly RANGE_LB_INF: number
+  readonly RANGE_UB_INF: number
+}
+
+/** A parsed PostgreSQL `range` */
+export const PGRange: PGRangeConstructor = class PGRangeImpl<T>
+  extends postgresRange.Range<T>
+  implements PGRange<T>, PGSerializable {
+  readonly mask: number
+
+  constructor(lower: T | null, upper: T | null, flags: number) {
+    super(lower, upper, flags)
+    this.mask = flags
+  }
+
+  toPostgres(serialize: PGSerialize): string {
+    return postgresRange.serialize(this, serialize)
+  }
+
+  static readonly RANGE_EMPTY = postgresRange.RANGE_EMPTY
+  static readonly RANGE_LB_INC = postgresRange.RANGE_LB_INC
+  static readonly RANGE_UB_INC = postgresRange.RANGE_UB_INC
+  static readonly RANGE_LB_INF = postgresRange.RANGE_LB_INF
+  static readonly RANGE_UB_INF = postgresRange.RANGE_UB_INF
+}
+
+/* ========================================================================== *
+ * PARSERS                                                                    *
+ * ========================================================================== */
+
+/** Parse a PostgreSQL `range` */
+export function parseRange(value: string): PGRange<string>
+/** Parse a PostgreSQL `range` */
+export function parseRange<T>(value: string, parser: PGParser<T>): PGRange<T>
+/* Overloaded implementation */
+export function parseRange(
+    value: string,
+    parser: PGParser<any> = parseString,
+): PGRange<any> {
+  const range = postgresRange.parse(value, parser)
+  return new PGRange(range.lower, range.upper, (range as any).mask)
+}
+
+/* ===== SPECIALIZED TYPES ================================================== */
+
+/** Parse a PostgreSQL `range` of _integers_ */
+export const parseIntRange: PGParser<PGRange<number>> =
+  (value: string) => parseRange(value, parseInt)
+
+/** Parse a PostgreSQL `range` of _floats_ */
+export const parseFloatRange: PGParser<PGRange<number>> =
+  (value: string) => parseRange(value, parseFloat)
+
+/** Parse a PostgreSQL `range` of _big integers_ */
+export const parseBigintRange: PGParser<PGRange<bigint>> =
+  (value: string) => parseRange(value, parseBigint)
+
+/** Parse a PostgreSQL `range` of _timestamps_ */
+export const parseTimestampRange: PGParser<PGRange<Date>> =
+  (value: string) => parseRange(value, parseTimestamp)
+
+/** Parse a PostgreSQL `range` of _timestamps with time zone_ */
+export const parseTimestampTzRange: PGParser<PGRange<Date>> =
+  (value: string) => parseRange(value, parseTimestampTz)
+
+/* ===== ARRAYS OF RANGES =================================================== */
+
+/** Parse an array of PostgreSQL `range` of _strings_ */
+export const parseRangeArray: PGParser<PGArray<PGRange<string>>> =
+  (value: string) => parseArray<PGRange<string>>(value, parseRange)
+
+/** Parse an array of PostgreSQL `range` of _integers_ */
+export const parseIntRangeArray: PGParser<PGArray<PGRange<number>>> =
+  (value: string) => parseArray(value, parseIntRange)
+
+/** Parse an array of PostgreSQL `range` of _floats_ */
+export const parseFloatRangeArray: PGParser<PGArray<PGRange<number>>> =
+  (value: string) => parseArray(value, parseFloatRange)
+
+/** Parse an array of PostgreSQL `range` of _big integers_ */
+export const parseBigintRangeArray: PGParser<PGArray<PGRange<bigint>>> =
+  (value: string) => parseArray(value, parseBigintRange)
+
+/** Parse an array of PostgreSQL `range` of _timestamps_ */
+export const parseTimestampRangeArray: PGParser<PGArray<PGRange<Date>>> =
+  (value: string) => parseArray(value, parseTimestampRange)
+
+/** Parse an array of PostgreSQL `range` of _timestamps with time zone_ */
+export const parseTimestampTzRangeArray: PGParser<PGArray<PGRange<Date>>> =
+  (value: string) => parseArray(value, parseTimestampTzRange)

package/src/parsers.ts

@@ -0,0 +1,57 @@
+/* eslint-disable comma-dangle */
+
+/** A function parsing a `string` returned from PostgreSQL */
+export type PGParser<T = string> = (value: string) => T
+
+export {
+  parseArray,
+  parseBigintArray,
+  parseBoolArray,
+  parseByteAArray,
+  parseCircleArray,
+  parseFloatArray,
+  parseIntArray,
+  parseIntervalArray,
+  parseJsonArray,
+  parsePointArray,
+  parseTimestampArray,
+  parseTimestampTzArray
+} from './parsers/array'
+
+export {
+  parseBigint,
+  parseBool,
+  parseJson,
+  parseString,
+  parseTimestamp,
+  parseTimestampTz,
+  parseVoid
+} from './parsers/basic'
+
+export {
+  parseByteA
+} from './parsers/bytea'
+
+export {
+  parseCircle,
+  parsePoint
+} from './parsers/geometric'
+
+export {
+  parseInterval
+} from './parsers/interval'
+
+export {
+  parseBigintRange,
+  parseBigintRangeArray,
+  parseFloatRange,
+  parseFloatRangeArray,
+  parseIntRange,
+  parseIntRangeArray,
+  parseRange,
+  parseRangeArray,
+  parseTimestampRange,
+  parseTimestampRangeArray,
+  parseTimestampTzRange,
+  parseTimestampTzRangeArray
+} from './parsers/range'

package/src/registry.ts

@@ -0,0 +1,168 @@
+import { PGOIDs } from './oids'
+import {
+  parseArray,
+  parseBigint,
+  parseBigintArray,
+  parseBigintRange,
+  parseBigintRangeArray,
+  parseBool,
+  parseBoolArray,
+  parseByteA,
+  parseByteAArray,
+  parseCircle,
+  parseCircleArray,
+  parseFloatArray,
+  parseFloatRange,
+  parseFloatRangeArray,
+  parseIntArray,
+  parseIntRange,
+  parseIntRangeArray,
+  parseInterval,
+  parseIntervalArray,
+  parseJson,
+  parseJsonArray,
+  parsePoint,
+  parsePointArray,
+  parseRange,
+  parseRangeArray,
+  parseString,
+  parseTimestamp,
+  parseTimestampArray,
+  parseTimestampRange,
+  parseTimestampRangeArray,
+  parseTimestampTz,
+  parseTimestampTzArray,
+  parseTimestampTzRange,
+  parseTimestampTzRangeArray,
+  parseVoid,
+} from './parsers'
+
+import type { PGParser } from './parsers'
+
+export interface Registry {
+  deregisterParser(oid: number): this
+  registerParser(oid: number, parser: PGParser<any>): this
+
+  getParser(oid: number): PGParser<any>
+}
+
+const oidParsers = {
+  /* Basic known types                                |_oid__|_typname______| */
+  [PGOIDs.bool]: parseBool, /*                        |   16 | bool         | */
+  [PGOIDs.bytea]: parseByteA, /*                      |   17 | bytea        | */
+  [PGOIDs.int8]: parseBigint, /*                      |   20 | int8         | */
+  [PGOIDs.int2]: parseInt, /*                         |   21 | int2         | */
+  [PGOIDs.int4]: parseInt, /*                         |   23 | int4         | */
+  [PGOIDs.oid]: parseInt, /*                          |   26 | oid          | */
+  [PGOIDs.json]: parseJson, /*                        |  114 | json         | */
+  [PGOIDs.point]: parsePoint, /*                      |  600 | point        | */
+  [PGOIDs.float4]: parseFloat, /*                     |  700 | float4       | */
+  [PGOIDs.float8]: parseFloat, /*                     |  701 | float8       | */
+  [PGOIDs.circle]: parseCircle, /*                    |  718 | circle       | */
+  [PGOIDs.varchar]: parseString, /*                   | 1043 | varchar      | */
+  [PGOIDs.timestamp]: parseTimestamp, /*              | 1114 | timestamp    | */
+  [PGOIDs.timestamptz]: parseTimestampTz, /*          | 1184 | timestamptz  | */
+  [PGOIDs.interval]: parseInterval, /*                | 1186 | interval     | */
+  [PGOIDs.numeric]: parseString, /*                   | 1700 | numeric      | */
+  [PGOIDs.jsonb]: parseJson, /*                       | 3802 | jsonb        | */
+
+  /* Special types                                    |_oid__|_typname______| */
+  [PGOIDs.void]: parseVoid, /*                        | 2278 | void         | */
+  [PGOIDs.xid]: parseInt, /*                          |   28 | xid          | */
+  [PGOIDs.xid8]: parseBigint, /*                      | 5069 | xid8         | */
+  [PGOIDs._xid]: parseIntArray, /*                    | 1011 | _xid         | */
+  [PGOIDs._xid8]: parseBigintArray, /*                |  271 | _xid8        | */
+
+  /* Native array types of the above                  |_oid__|_typname______| */
+  [PGOIDs._bool]: parseBoolArray, /*                  | 1000 | _bool        | */
+  [PGOIDs._bytea]: parseByteAArray, /*                | 1001 | _bytea       | */
+  [PGOIDs._int8]: parseBigintArray, /*                | 1016 | _int8        | */
+  [PGOIDs._int2]: parseIntArray, /*                   | 1005 | _int2        | */
+  [PGOIDs._int4]: parseIntArray, /*                   | 1007 | _int4        | */
+  [PGOIDs._oid]: parseIntArray, /*                    | 1028 | _oid         | */
+  [PGOIDs._json]: parseJsonArray, /*                  |  199 | _json        | */
+  [PGOIDs._point]: parsePointArray, /*                | 1017 | _point       | */
+  [PGOIDs._float4]: parseFloatArray, /*               | 1021 | _float4      | */
+  [PGOIDs._float8]: parseFloatArray, /*               | 1022 | _float8      | */
+  [PGOIDs._circle]: parseCircleArray, /*              |  719 | _circle      | */
+  [PGOIDs._timestamp]: parseTimestampArray, /*        | 1115 | _timestamp   | */
+  [PGOIDs._timestamptz]: parseTimestampTzArray, /*    | 1185 | _timestamptz | */
+  [PGOIDs._interval]: parseIntervalArray, /*          | 1187 | _interval    | */
+  [PGOIDs._numeric]: parseArray, /*                   | 1231 | _numeric     | */
+  [PGOIDs._jsonb]: parseJsonArray, /*                 | 3807 | _jsonb       | */
+
+  /* Other known array types                          |_oid__|_typname______| */
+  [PGOIDs._cidr]: parseArray, /*                      |  651 | _cidr        | */
+  [PGOIDs._money]: parseArray, /*                     |  791 | _money       | */
+  [PGOIDs._regproc]: parseArray, /*                   | 1008 | _regproc     | */
+  [PGOIDs._text]: parseArray, /*                      | 1009 | _text        | */
+  [PGOIDs._bpchar]: parseArray, /*                    | 1014 | _bpchar      | */
+  [PGOIDs._varchar]: parseArray, /*                   | 1015 | _varchar     | */
+  [PGOIDs._macaddr]: parseArray, /*                   | 1040 | _macaddr     | */
+  [PGOIDs._inet]: parseArray, /*                      | 1041 | _inet        | */
+  [PGOIDs._date]: parseArray, /*                      | 1182 | _date        | */
+  [PGOIDs._time]: parseArray, /*                      | 1183 | _time        | */
+  [PGOIDs._timetz]: parseArray, /*                    | 1270 | _timetz      | */
+  [PGOIDs._uuid]: parseArray, /*                      | 2951 | _uuid        | */
+
+  /* Range types                                      |_oid__|_typname______| */
+  [PGOIDs.int4range]: parseIntRange, /*               | 3904 | int4range    | */
+  [PGOIDs.numrange]: parseFloatRange, /*              | 3906 | numrange     | */
+  [PGOIDs.tsrange]: parseTimestampRange, /*           | 3908 | tsrange      | */
+  [PGOIDs.tstzrange]: parseTimestampTzRange, /*       | 3910 | tstzrange    | */
+  [PGOIDs.daterange]: parseRange, /*                  | 3912 | daterange    | */
+  [PGOIDs.int8range]: parseBigintRange, /*            | 3926 | int8range    | */
+
+  /* Array of range types                             |_oid__|_typname______| */
+  [PGOIDs._int4range]: parseIntRangeArray, /*         | 3905 | _int4range   | */
+  [PGOIDs._numrange]: parseFloatRangeArray, /*        | 3907 | _numrange    | */
+  [PGOIDs._tsrange]: parseTimestampRangeArray, /*     | 3909 | _tsrange     | */
+  [PGOIDs._tstzrange]: parseTimestampTzRangeArray, /* | 3911 | _tstzrange   | */
+  [PGOIDs._daterange]: parseRangeArray, /*            | 3913 | _daterange   | */
+  [PGOIDs._int8range]: parseBigintRangeArray, /*      | 3927 | _int8range   | */
+} satisfies Record<PGOIDs[keyof PGOIDs], PGParser<any>>
+
+export type RegistryTypes = {
+  [ key in keyof typeof oidParsers ] :
+    typeof oidParsers[key] extends PGParser<infer T> ? T : never
+}
+
+const defaultParsers: Record<number, PGParser<any>> = { ...oidParsers }
+
+class RegistryImpl implements Registry {
+  private _parsers: Record<number, PGParser<any>>
+
+  constructor() {
+    this._parsers = { ...oidParsers }
+  }
+
+  deregisterParser(oid: number): this {
+    delete this._parsers[oid]
+    return this
+  }
+
+  registerParser(oid: number, parser: PGParser<any>): this {
+    this._parsers[oid] = parser
+    return this
+  }
+
+  getParser(oid: number): PGParser<any> {
+    return this._parsers[oid] || defaultParsers[oid] || parseString
+  }
+
+  static deregisterDefaultParser(oid: number): void {
+    delete defaultParsers[oid]
+  }
+
+  static registerDefaultParser(oid: number, parser: PGParser<any>): void {
+    defaultParsers[oid] = parser
+  }
+}
+
+export interface RegistryConstructor {
+  new (): Registry,
+  deregisterDefaultParser(oid: number): void
+  registerDefaultParser(oid: number, parser: PGParser<any>): void
+}
+
+export const Registry: RegistryConstructor = RegistryImpl

package/src/serializers/bytea.ts

@@ -0,0 +1,67 @@
+/* ========================================================================== *
+ * INTERNALS                                                                  *
+ * ========================================================================== */
+
+/* Internal interface mimicking NodeJS's `Buffer` */
+interface NodeJSBuffer extends Uint8Array {
+  toString(format?: 'hex'): string
+}
+
+/* Internal interface mimicking NodeJS's `Buffer`'s constructor */
+interface NodeJSBufferConstructor {
+  isBuffer(value: any): value is NodeJSBuffer
+  from(source:Uint8Array): NodeJSBuffer
+}
+
+/* Return a {@link Uint8Array} from an {@link ArrayBufferView} */
+function getUint8Array(value: any): Uint8Array {
+  if (value instanceof Uint8Array) return value
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
+  }
+
+  throw new TypeError('Unsupported type for serialization as BYTEA')
+}
+
+/** All HEX values (from "00" to "ff" in order) */
+const hex = '0123456789abcdef'.split('') // [ '0', '1', '2', ... ]
+    .map((c1, _, a) => a.map((c2) => `${c1}${c2}`)) // [ [ '00', '01', ...], ...]
+    .flat() // [ '00', '01', '02', ... ]
+
+/* ========================================================================== *
+ * EXPORTED SERIALIZER                                                        *
+ * ========================================================================== */
+
+/**
+ * Serialize an {@link ArrayBufferView} (e.g. an {@link Uint8Array}, a NodeJS
+ * `Buffer`, ...) into a PostgreSQL _HEX-encoded_ `string` (e.g. `\\xdeadbeef`).
+ */
+export function serializeByteA(
+  value: ArrayBufferView,
+  Buffer?: NodeJSBufferConstructor | null | undefined,
+): string
+/* Overload */
+export function serializeByteA(
+    value: any, // we need _any_ for type guards to work properly
+    Buffer: NodeJSBufferConstructor | null | undefined = (globalThis as any).Buffer,
+): string {
+  /* In NodeJS we can use some shortcuts with buffers */
+  if (Buffer) {
+    /* Get a NodeJS buffer, either the value itself or wrapping a Uint8Array */
+    const buffer = Buffer.isBuffer(value) ? value : Buffer.from(getUint8Array(value))
+    return `\\x${buffer.toString('hex')}`
+  }
+
+  /* No support for NodeJS "Buffer"... Gotta do manually */
+  const array = getUint8Array(value)
+  const result = new Array<string>(array.length + 1)
+  result[0] = '\\x'
+
+  /* Run a tight loop over our Uint8Array, converting it to HEX */
+  for (let i = 0, c = array[0]!; i < array.length; c = array[i]!) {
+    result[++i] = hex[c]!
+  }
+
+  /* Join up and return */
+  return result.join('')
+}