@juit/pgproxy-types 1.0.0

package/dist/parsers/array.d.ts

@@ -0,0 +1,31 @@
+import type { PGParser } from '../parsers';
+import type { PGCircle, PGPoint } from './geometric';
+import type { PGInterval } from './interval';
+/** A parsed PostgreSQL `array` */
+export type PGArray<T = string> = (T | null)[];
+/** Parse a PostgreSQL array of string values */
+export declare function parseArray(source: string): PGArray;
+/** Parse a PostgreSQL array using the specified parser for its elements */
+export declare function parseArray<T>(source: string, parser: PGParser<T>): PGArray<T>;
+/** Parse a PostgreSQL array of _bigint_ values */
+export declare const parseBigintArray: PGParser<PGArray<bigint>>;
+/** Parse a PostgreSQL array of _boolean_ values */
+export declare const parseBoolArray: PGParser<PGArray<boolean>>;
+/** Parse a PostgreSQL array of _binary_ values */
+export declare const parseByteAArray: PGParser<PGArray<Uint8Array>>;
+/** Parse a PostgreSQL array of {@link PGCircle} values */
+export declare const parseCircleArray: PGParser<PGArray<PGCircle>>;
+/** Parse a PostgreSQL array of _float_ values */
+export declare const parseFloatArray: PGParser<PGArray<number>>;
+/** Parse a PostgreSQL array of _number_ values */
+export declare const parseIntArray: PGParser<PGArray<number>>;
+/** Parse a PostgreSQL array of {@link PGInterval} values */
+export declare const parseIntervalArray: PGParser<PGArray<PGInterval>>;
+/** Parse a PostgreSQL array of _JSON_ values */
+export declare const parseJsonArray: PGParser<PGArray<any[]>>;
+/** Parse a PostgreSQL array of {@link PGPoint} values */
+export declare const parsePointArray: PGParser<PGArray<PGPoint>>;
+/** Parse a PostgreSQL array of _timestamp without time zone_ values */
+export declare const parseTimestampArray: PGParser<PGArray<Date>>;
+/** Parse a PostgreSQL array of _timestamp with time zone_ values */
+export declare const parseTimestampTzArray: PGParser<PGArray<Date>>;

package/dist/parsers/array.mjs

@@ -0,0 +1,111 @@
+// parsers/array.ts
+import {
+  parseBigint,
+  parseBool,
+  parseJson,
+  parseString,
+  parseTimestamp,
+  parseTimestampTz
+} from "./basic.mjs";
+import { parseByteA } from "./bytea.mjs";
+import { parseCircle, parsePoint } from "./geometric.mjs";
+import { parseInterval } from "./interval.mjs";
+function parseArray(source, parser = parseString) {
+  return parseInternal(source, parser, false);
+}
+var parseBigintArray = (value) => parseArray(value, parseBigint);
+var parseBoolArray = (value) => parseArray(value, parseBool);
+var parseByteAArray = (value) => parseArray(value, parseByteA);
+var parseCircleArray = (value) => parseArray(value, parseCircle);
+var parseFloatArray = (value) => parseArray(value, parseFloat);
+var parseIntArray = (value) => parseArray(value, parseInt);
+var parseIntervalArray = (value) => parseArray(value, parseInterval);
+var parseJsonArray = (value) => parseArray(value, parseJson);
+var parsePointArray = (value) => parseArray(value, parsePoint);
+var parseTimestampArray = (value) => parseArray(value, parseTimestamp);
+var parseTimestampTzArray = (value) => parseArray(value, parseTimestampTz);
+function parseInternal(source, parser, nested) {
+  const entries = [];
+  let character = "";
+  let quote = false;
+  let position = 0;
+  let dimension = 0;
+  let recorded = "";
+  const newEntry = (includeEmpty) => {
+    let entry = recorded;
+    if (entry.length > 0 || includeEmpty) {
+      if (entry === "NULL" && !includeEmpty) {
+        entry = null;
+      }
+      if (entry !== null) {
+        entries.push(parser(entry));
+      } else {
+        entries.push(null);
+      }
+      recorded = "";
+    }
+  };
+  if (source[0] === "[") {
+    while (position < source.length) {
+      const char = source[position++];
+      if (char === "=") {
+        break;
+      }
+    }
+  }
+  while (position < source.length) {
+    let escaped = false;
+    character = source[position++];
+    if (character === "\\") {
+      character = source[position++];
+      escaped = true;
+    }
+    if (character === "{" && !quote) {
+      dimension++;
+      if (dimension > 1) {
+        const result = parseInternal(source.substring(position - 1), parser, true);
+        entries.push(result.entries);
+        position += result.position - 2;
+      }
+    } else if (character === "}" && !quote) {
+      dimension--;
+      if (!dimension) {
+        newEntry();
+        if (nested) {
+          return {
+            entries,
+            position
+          };
+        }
+      }
+    } else if (character === '"' && !escaped) {
+      if (quote) {
+        newEntry(true);
+      }
+      quote = !quote;
+    } else if (character === "," && !quote) {
+      newEntry();
+    } else {
+      recorded += character;
+    }
+  }
+  if (dimension !== 0) {
+    throw new Error("array dimension not balanced");
+  }
+  return entries;
+}
+export {
+  parseArray,
+  parseBigintArray,
+  parseBoolArray,
+  parseByteAArray,
+  parseCircleArray,
+  parseFloatArray,
+  parseIntArray,
+  parseIntervalArray,
+  parseJsonArray,
+  parsePointArray,
+  parseTimestampArray,
+  parseTimestampTzArray
+};
+//# sourceMappingURL=array.mjs.map

package/dist/parsers/array.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/parsers/array.ts"],
+  "mappings": ";AAEA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,kBAAkB;AAC3B,SAAS,aAAa,kBAAkB;AACxC,SAAS,qBAAqB;AAcvB,SAAS,WACZ,QACA,SAAS,aACF;AACT,SAAO,cAAc,QAAQ,QAAQ,KAAK;AAC5C;AAKO,IAAM,mBACX,CAAC,UAAkB,WAAW,OAAO,WAAW;AAG3C,IAAM,iBACX,CAAC,UAAkB,WAAW,OAAO,SAAS;AAGzC,IAAM,kBACX,CAAC,UAAkB,WAAW,OAAO,UAAU;AAG1C,IAAM,mBACX,CAAC,UAAkB,WAAW,OAAO,WAAW;AAG3C,IAAM,kBACX,CAAC,UAAkB,WAAW,OAAO,UAAU;AAG1C,IAAM,gBACX,CAAC,UAAkB,WAAW,OAAO,QAAQ;AAGxC,IAAM,qBACX,CAAC,UAAkB,WAAW,OAAO,aAAa;AAG7C,IAAM,iBACX,CAAC,UAAkB,WAAW,OAAO,SAAS;AAGzC,IAAM,kBACX,CAAC,UAAkB,WAAW,OAAO,UAAU;AAG1C,IAAM,sBACX,CAAC,UAAkB,WAAW,OAAO,cAAc;AAG9C,IAAM,wBACX,CAAC,UAAkB,WAAW,OAAO,gBAAgB;AAcvD,SAAS,cAAc,QAAgB,QAAuB,QAAyC;AACrG,QAAM,UAAU,CAAC;AACjB,MAAI,YAAY;AAChB,MAAI,QAAQ;AACZ,MAAI,WAAW;AACf,MAAI,YAAY;AAChB,MAAI,WAAW;AAEf,QAAM,WAAW,CAAC,iBAAiC;AACjD,QAAI,QAAuB;AAE3B,QAAI,MAAM,SAAS,KAAK,cAAc;AACpC,UAAI,UAAU,UAAU,CAAC,cAAc;AACrC,gBAAQ;AAAA,MACV;AAEA,UAAI,UAAU,MAAM;AAClB,gBAAQ,KAAK,OAAO,KAAK,CAAC;AAAA,MAC5B,OAAO;AACL,gBAAQ,KAAK,IAAI;AAAA,MACnB;AAEA,iBAAW;AAAA,IACb;AAAA,EACF;AAEA,MAAI,OAAO,CAAC,MAAM,KAAK;AACrB,WAAO,WAAW,OAAO,QAAQ;AAC/B,YAAM,OAAO,OAAO,UAAU;AAE9B,UAAI,SAAS,KAAK;AAChB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO,WAAW,OAAO,QAAQ;AAC/B,QAAI,UAAU;AACd,gBAAY,OAAO,UAAU;AAE7B,QAAI,cAAc,MAAM;AACtB,kBAAY,OAAO,UAAU;AAC7B,gBAAU;AAAA,IACZ;AAEA,QAAI,cAAc,OAAO,CAAC,OAAO;AAC/B;AAEA,UAAI,YAAY,GAAG;AACjB,cAAM,SAAS,cAAc,OAAO,UAAU,WAAW,CAAC,GAAG,QAAQ,IAAI;AACzE,gBAAQ,KAAK,OAAO,OAAO;AAC3B,oBAAY,OAAO,WAAW;AAAA,MAChC;AAAA,IACF,WAAW,cAAc,OAAO,CAAC,OAAO;AACtC;AAEA,UAAI,CAAC,WAAW;AACd,iBAAS;AAET,YAAI,QAAQ;AACV,iBAAO;AAAA,YACL;AAAA,YACA;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF,WAAW,cAAc,OAAO,CAAC,SAAS;AACxC,UAAI,OAAO;AACT,iBAAS,IAAI;AAAA,MACf;AAEA,cAAQ,CAAC;AAAA,IACX,WAAW,cAAc,OAAO,CAAC,OAAO;AACtC,eAAS;AAAA,IACX,OAAO;AACL,kBAAY;AAAA,IACd;AAAA,EACF;AAEA,MAAI,cAAc,GAAG;AACnB,UAAM,IAAI,MAAM,8BAA8B;AAAA,EAChD;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/parsers/basic.cjs

@@ -0,0 +1,69 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// parsers/basic.ts
+var basic_exports = {};
+__export(basic_exports, {
+  parseBigint: () => parseBigint,
+  parseBool: () => parseBool,
+  parseJson: () => parseJson,
+  parseString: () => parseString,
+  parseTimestamp: () => parseTimestamp,
+  parseTimestampTz: () => parseTimestampTz,
+  parseVoid: () => parseVoid
+});
+module.exports = __toCommonJS(basic_exports);
+var import_postgres_date = __toESM(require("postgres-date"));
+var INVALID_DATE = /* @__PURE__ */ new Date(NaN);
+var parseBigint = BigInt;
+var parseJson = JSON.parse;
+var parseBool = (value) => {
+  return value === "TRUE" || value === "t" || value === "true" || value === "y" || value === "yes" || value === "on" || value === "1";
+};
+var parseString = (value) => value;
+var parseVoid = () => null;
+var parseTimestamp = (value) => {
+  const utc = value.endsWith(" BC") ? value.slice(0, -3) + "Z BC" : value + "Z";
+  return parseTimestampTz(utc);
+};
+var parseTimestampTz = (value) => {
+  const date = (0, import_postgres_date.default)(value);
+  return date instanceof Date ? date : INVALID_DATE;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseBigint,
+  parseBool,
+  parseJson,
+  parseString,
+  parseTimestamp,
+  parseTimestampTz,
+  parseVoid
+});
+//# sourceMappingURL=basic.cjs.map

package/dist/parsers/basic.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/parsers/basic.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,2BAAyB;AAMzB,IAAM,eAAe,oBAAI,KAAK,GAAG;AAO1B,IAAM,cAAgC;AAGtC,IAAM,YAA2B,KAAK;AAGtC,IAAM,YAA+B,CAAC,UAA2B;AACtE,SAAO,UAAU,UACV,UAAU,OACV,UAAU,UACV,UAAU,OACV,UAAU,SACV,UAAU,QACV,UAAU;AACnB;AAGO,IAAM,cAAgC,CAAC,UAA0B;AAGjE,IAAM,YAA4B,MAAY;AAK9C,IAAM,iBAAiC,CAAC,UAAwB;AACrE,QAAM,MAAM,MAAM,SAAS,KAAK,IAC9B,MAAM,MAAM,GAAG,EAAE,IAAI,SACrB,QAAQ;AAEV,SAAO,iBAAiB,GAAG;AAC7B;AAGO,IAAM,mBAAmC,CAAC,UAAwB;AACvE,QAAM,WAAO,qBAAAA,SAAa,KAAK;AAC/B,SAAO,gBAAgB,OAAO,OAAO;AACvC;",
+  "names": ["postgresDate"]
+}

package/dist/parsers/basic.d.ts

@@ -0,0 +1,15 @@
+import type { PGParser } from '../parsers';
+/** Parse a `bigint` */
+export declare const parseBigint: PGParser<bigint>;
+/** Parse some JSON */
+export declare const parseJson: PGParser<any>;
+/** Parse a `boolean` */
+export declare const parseBool: PGParser<boolean>;
+/** Parse a `string` (identity transformation) */
+export declare const parseString: PGParser<string>;
+/** Parse anything into `null` (normally used only for `void` types) */
+export declare const parseVoid: PGParser<null>;
+/** Parse a PostgreSQL timestamp _without_ time zone */
+export declare const parseTimestamp: PGParser<Date>;
+/** Parse a PostgreSQL timestamp _with_ time zone */
+export declare const parseTimestampTz: PGParser<Date>;

package/dist/parsers/basic.mjs

@@ -0,0 +1,28 @@
+// parsers/basic.ts
+import postgresDate from "postgres-date";
+var INVALID_DATE = /* @__PURE__ */ new Date(NaN);
+var parseBigint = BigInt;
+var parseJson = JSON.parse;
+var parseBool = (value) => {
+  return value === "TRUE" || value === "t" || value === "true" || value === "y" || value === "yes" || value === "on" || value === "1";
+};
+var parseString = (value) => value;
+var parseVoid = () => null;
+var parseTimestamp = (value) => {
+  const utc = value.endsWith(" BC") ? value.slice(0, -3) + "Z BC" : value + "Z";
+  return parseTimestampTz(utc);
+};
+var parseTimestampTz = (value) => {
+  const date = postgresDate(value);
+  return date instanceof Date ? date : INVALID_DATE;
+};
+export {
+  parseBigint,
+  parseBool,
+  parseJson,
+  parseString,
+  parseTimestamp,
+  parseTimestampTz,
+  parseVoid
+};
+//# sourceMappingURL=basic.mjs.map

package/dist/parsers/basic.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/parsers/basic.ts"],
+  "mappings": ";AAIA,OAAO,kBAAkB;AAMzB,IAAM,eAAe,oBAAI,KAAK,GAAG;AAO1B,IAAM,cAAgC;AAGtC,IAAM,YAA2B,KAAK;AAGtC,IAAM,YAA+B,CAAC,UAA2B;AACtE,SAAO,UAAU,UACV,UAAU,OACV,UAAU,UACV,UAAU,OACV,UAAU,SACV,UAAU,QACV,UAAU;AACnB;AAGO,IAAM,cAAgC,CAAC,UAA0B;AAGjE,IAAM,YAA4B,MAAY;AAK9C,IAAM,iBAAiC,CAAC,UAAwB;AACrE,QAAM,MAAM,MAAM,SAAS,KAAK,IAC9B,MAAM,MAAM,GAAG,EAAE,IAAI,SACrB,QAAQ;AAEV,SAAO,iBAAiB,GAAG;AAC7B;AAGO,IAAM,mBAAmC,CAAC,UAAwB;AACvE,QAAM,OAAO,aAAa,KAAK;AAC/B,SAAO,gBAAgB,OAAO,OAAO;AACvC;",
+  "names": []
+}

package/dist/parsers/bytea.cjs

@@ -0,0 +1,68 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// parsers/bytea.ts
+var bytea_exports = {};
+__export(bytea_exports, {
+  parseByteA: () => parseByteA
+});
+module.exports = __toCommonJS(bytea_exports);
+function parseEncoded(input) {
+  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;
+}
+function parseEscaped(input, Buffer2) {
+  const result = new Uint8Array(input.length);
+  let pos = 0;
+  for (let i = 0; i < input.length; i++) {
+    const code = input.charCodeAt(i);
+    if (code !== 92) {
+      result[pos++] = code;
+    } else {
+      const token = input.substring(i + 1, i + 4);
+      if (/[0-7]{3}/.test(token)) {
+        result[pos++] = parseInt(token, 8);
+        i += 3;
+      } else {
+        let backslashes = 1;
+        for (let char = input[++i]; i < input.length && char === "\\"; char = input[++i])
+          backslashes++;
+        result.fill(92, pos, pos += backslashes >>> 1);
+        i--;
+      }
+    }
+  }
+  return Buffer2 ? Buffer2.from(result.subarray(0, pos)) : result.slice(0, pos);
+}
+function parseByteA(input, Buffer2 = globalThis.Buffer) {
+  if (input.startsWith("\\x")) {
+    return Buffer2 ? Buffer2.from(input.substring(2), "hex") : parseEncoded(input);
+  } else {
+    return parseEscaped(input, Buffer2);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseByteA
+});
+//# sourceMappingURL=bytea.cjs.map

package/dist/parsers/bytea.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/parsers/bytea.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,SAAS,aAAa,OAA2B;AAC/C,QAAM,QAAQ,IAAI,YAAY,MAAM,SAAS,KAAK,CAAC;AACnD,MAAI,QAAQ;AACZ,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,GAAG;AACxC,UAAM,OAAQ,IAAI,SAAS,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE;AAAA,EAC1D;AACA,SAAO;AACT;AAGA,SAAS,aAAa,OAAeA,SAA0C;AAC7E,QAAM,SAAS,IAAI,WAAW,MAAM,MAAM;AAC1C,MAAI,MAAM;AAEV,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAM;AACtC,UAAM,OAAO,MAAM,WAAW,CAAC;AAC/B,QAAI,SAAS,IAAM;AAEjB,aAAO,KAAM,IAAI;AAAA,IACnB,OAAO;AAEL,YAAM,QAAQ,MAAM,UAAU,IAAI,GAAG,IAAI,CAAC;AAC1C,UAAI,WAAW,KAAK,KAAK,GAAG;AAC1B,eAAO,KAAM,IAAI,SAAS,OAAO,CAAC;AAClC,aAAK;AAAA,MACP,OAAO;AAEL,YAAI,cAAc;AAElB,iBACM,OAAO,MAAM,EAAE,CAAC,GACnB,IAAI,MAAM,UAAY,SAAS,MAChC,OAAO,MAAM,EAAE,CAAC;AAChB;AAGF,eAAO,KAAK,IAAM,KAAK,OAAO,gBAAgB,CAAC;AAG/C;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAGA,SAAOA,UAASA,QAAO,KAAK,OAAO,SAAS,GAAG,GAAG,CAAC,IAAI,OAAO,MAAM,GAAG,GAAG;AAC5E;AASO,SAAS,WACZ,OACAA,UAA2C,WAAmB,QACpD;AACZ,MAAI,MAAM,WAAW,KAAK,GAAG;AAE3B,WAAOA,UAASA,QAAO,KAAK,MAAM,UAAU,CAAC,GAAG,KAAK,IAAI,aAAa,KAAK;AAAA,EAC7E,OAAO;AACL,WAAO,aAAa,OAAOA,OAAM;AAAA,EACnC;AACF;",
+  "names": ["Buffer"]
+}

package/dist/parsers/bytea.d.ts

@@ -0,0 +1,7 @@
+interface NodeJSBuffer {
+    from(source: string, format: 'hex'): Uint8Array;
+    from(source: Uint8Array): Uint8Array;
+}
+/** Parse a PostgreSQL `BYTEA` string (escaped or encoded in hexadecimal) */
+export declare function parseByteA(input: string, Buffer?: NodeJSBuffer | null): Uint8Array;
+export {};

package/dist/parsers/bytea.mjs

@@ -0,0 +1,43 @@
+// parsers/bytea.ts
+function parseEncoded(input) {
+  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;
+}
+function parseEscaped(input, Buffer) {
+  const result = new Uint8Array(input.length);
+  let pos = 0;
+  for (let i = 0; i < input.length; i++) {
+    const code = input.charCodeAt(i);
+    if (code !== 92) {
+      result[pos++] = code;
+    } else {
+      const token = input.substring(i + 1, i + 4);
+      if (/[0-7]{3}/.test(token)) {
+        result[pos++] = parseInt(token, 8);
+        i += 3;
+      } else {
+        let backslashes = 1;
+        for (let char = input[++i]; i < input.length && char === "\\"; char = input[++i])
+          backslashes++;
+        result.fill(92, pos, pos += backslashes >>> 1);
+        i--;
+      }
+    }
+  }
+  return Buffer ? Buffer.from(result.subarray(0, pos)) : result.slice(0, pos);
+}
+function parseByteA(input, Buffer = globalThis.Buffer) {
+  if (input.startsWith("\\x")) {
+    return Buffer ? Buffer.from(input.substring(2), "hex") : parseEncoded(input);
+  } else {
+    return parseEscaped(input, Buffer);
+  }
+}
+export {
+  parseByteA
+};
+//# sourceMappingURL=bytea.mjs.map

package/dist/parsers/bytea.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/parsers/bytea.ts"],
+  "mappings": ";AAWA,SAAS,aAAa,OAA2B;AAC/C,QAAM,QAAQ,IAAI,YAAY,MAAM,SAAS,KAAK,CAAC;AACnD,MAAI,QAAQ;AACZ,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,GAAG;AACxC,UAAM,OAAQ,IAAI,SAAS,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE;AAAA,EAC1D;AACA,SAAO;AACT;AAGA,SAAS,aAAa,OAAe,QAA0C;AAC7E,QAAM,SAAS,IAAI,WAAW,MAAM,MAAM;AAC1C,MAAI,MAAM;AAEV,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAM;AACtC,UAAM,OAAO,MAAM,WAAW,CAAC;AAC/B,QAAI,SAAS,IAAM;AAEjB,aAAO,KAAM,IAAI;AAAA,IACnB,OAAO;AAEL,YAAM,QAAQ,MAAM,UAAU,IAAI,GAAG,IAAI,CAAC;AAC1C,UAAI,WAAW,KAAK,KAAK,GAAG;AAC1B,eAAO,KAAM,IAAI,SAAS,OAAO,CAAC;AAClC,aAAK;AAAA,MACP,OAAO;AAEL,YAAI,cAAc;AAElB,iBACM,OAAO,MAAM,EAAE,CAAC,GACnB,IAAI,MAAM,UAAY,SAAS,MAChC,OAAO,MAAM,EAAE,CAAC;AAChB;AAGF,eAAO,KAAK,IAAM,KAAK,OAAO,gBAAgB,CAAC;AAG/C;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAGA,SAAO,SAAS,OAAO,KAAK,OAAO,SAAS,GAAG,GAAG,CAAC,IAAI,OAAO,MAAM,GAAG,GAAG;AAC5E;AASO,SAAS,WACZ,OACA,SAA2C,WAAmB,QACpD;AACZ,MAAI,MAAM,WAAW,KAAK,GAAG;AAE3B,WAAO,SAAS,OAAO,KAAK,MAAM,UAAU,CAAC,GAAG,KAAK,IAAI,aAAa,KAAK;AAAA,EAC7E,OAAO;AACL,WAAO,aAAa,OAAO,MAAM;AAAA,EACnC;AACF;",
+  "names": []
+}

package/dist/parsers/geometric.cjs

@@ -0,0 +1,86 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// parsers/geometric.ts
+var geometric_exports = {};
+__export(geometric_exports, {
+  PGCircle: () => PGCircle,
+  PGPoint: () => PGPoint,
+  parseCircle: () => parseCircle,
+  parsePoint: () => parsePoint
+});
+module.exports = __toCommonJS(geometric_exports);
+var PGPoint = class PGPointImpl {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+  toPostgres() {
+    return `(${this.x},${this.y})`;
+  }
+};
+var PGCircle = class PGCircleImpl extends PGPoint {
+  constructor(x, y, radius) {
+    super(x, y);
+    this.radius = radius;
+  }
+  toPostgres() {
+    return `<(${this.x},${this.y}),${this.radius}>`;
+  }
+};
+var INVALID_POINT = new PGPoint(NaN, NaN);
+var INVALID_CIRCLE = new PGCircle(NaN, NaN, NaN);
+var parsePoint = (value) => {
+  if (value[0] !== "(")
+    return INVALID_POINT;
+  const values = value.substring(1, value.length - 1).split(",");
+  return new PGPoint(parseFloat(values[0]), parseFloat(values[1]));
+};
+var parseCircle = (value) => {
+  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));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PGCircle,
+  PGPoint,
+  parseCircle,
+  parsePoint
+});
+//# sourceMappingURL=geometric.cjs.map

package/dist/parsers/geometric.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/parsers/geometric.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA8BO,IAAM,UAA8B,MAAM,YAA+B;AAAA,EAC9E,YAA4B,GAA2B,GAAW;AAAtC;AAA2B;AAAA,EAAY;AAAA,EAEnE,aAAqB;AACnB,WAAO,IAAI,KAAK,CAAC,IAAI,KAAK,CAAC;AAAA,EAC7B;AACF;AAGO,IAAM,WAAgC,MAAM,qBAAqB,QAA4B;AAAA,EAClG,YAAY,GAAW,GAA2B,QAAgB;AAChE,UAAM,GAAG,CAAC;AADsC;AAAA,EAElD;AAAA,EAEA,aAAqB;AACnB,WAAO,KAAK,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,KAAK,MAAM;AAAA,EAC9C;AACF;AAIA,IAAM,gBAAgB,IAAI,QAAQ,KAAK,GAAG;AAC1C,IAAM,iBAAiB,IAAI,SAAS,KAAK,KAAK,GAAG;AAO1C,IAAM,aAAgC,CAAC,UAA2B;AACvE,MAAI,MAAM,CAAC,MAAM;AAAK,WAAO;AAE7B,QAAM,SAAS,MAAM,UAAU,GAAG,MAAM,SAAS,CAAC,EAAE,MAAM,GAAG;AAE7D,SAAO,IAAI,QAAQ,WAAW,OAAO,CAAC,CAAE,GAAG,WAAW,OAAO,CAAC,CAAE,CAAC;AACnE;AAGO,IAAM,cAAkC,CAAC,UAA4B;AAC1E,MAAI,MAAM,CAAC,MAAM,OAAO,MAAM,CAAC,MAAM;AAAK,WAAO;AAEjD,MAAI,QAAQ;AACZ,MAAI,SAAS;AACb,MAAI,cAAc;AAClB,WAAS,IAAI,GAAG,IAAI,MAAM,SAAS,GAAG,KAAK;AACzC,QAAI,CAAC,aAAa;AAChB,eAAS,MAAM,CAAC;AAAA,IAClB;AAEA,QAAI,MAAM,CAAC,MAAM,KAAK;AACpB,oBAAc;AACd;AAAA,IACF,WAAW,CAAC,aAAa;AACvB;AAAA,IACF;AAEA,QAAI,MAAM,CAAC,MAAM,KAAK;AACpB;AAAA,IACF;AAEA,cAAU,MAAM,CAAC;AAAA,EACnB;AAEA,QAAM,EAAE,GAAG,EAAE,IAAI,WAAW,KAAK;AACjC,SAAO,IAAI,SAAS,GAAG,GAAG,WAAW,MAAM,CAAC;AAC9C;",
+  "names": []
+}

package/dist/parsers/geometric.d.ts

@@ -0,0 +1,27 @@
+import type { PGParser } from '../parsers';
+import type { PGSerializable } from '../serializers';
+/** 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 declare const PGPoint: PGPointConstructor;
+/** Create a new {@link PGCircle} instance */
+export declare const PGCircle: PGCircleConstructor;
+/** Parse a PostgreSQL `point` */
+export declare const parsePoint: PGParser<PGPoint>;
+/** Parse a PostgreSQL `circle` */
+export declare const parseCircle: PGParser<PGCircle>;

package/dist/parsers/geometric.mjs

@@ -0,0 +1,58 @@
+// parsers/geometric.ts
+var PGPoint = class PGPointImpl {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+  toPostgres() {
+    return `(${this.x},${this.y})`;
+  }
+};
+var PGCircle = class PGCircleImpl extends PGPoint {
+  constructor(x, y, radius) {
+    super(x, y);
+    this.radius = radius;
+  }
+  toPostgres() {
+    return `<(${this.x},${this.y}),${this.radius}>`;
+  }
+};
+var INVALID_POINT = new PGPoint(NaN, NaN);
+var INVALID_CIRCLE = new PGCircle(NaN, NaN, NaN);
+var parsePoint = (value) => {
+  if (value[0] !== "(")
+    return INVALID_POINT;
+  const values = value.substring(1, value.length - 1).split(",");
+  return new PGPoint(parseFloat(values[0]), parseFloat(values[1]));
+};
+var parseCircle = (value) => {
+  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));
+};
+export {
+  PGCircle,
+  PGPoint,
+  parseCircle,
+  parsePoint
+};
+//# sourceMappingURL=geometric.mjs.map

package/dist/parsers/geometric.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/parsers/geometric.ts"],
+  "mappings": ";AA8BO,IAAM,UAA8B,MAAM,YAA+B;AAAA,EAC9E,YAA4B,GAA2B,GAAW;AAAtC;AAA2B;AAAA,EAAY;AAAA,EAEnE,aAAqB;AACnB,WAAO,IAAI,KAAK,CAAC,IAAI,KAAK,CAAC;AAAA,EAC7B;AACF;AAGO,IAAM,WAAgC,MAAM,qBAAqB,QAA4B;AAAA,EAClG,YAAY,GAAW,GAA2B,QAAgB;AAChE,UAAM,GAAG,CAAC;AADsC;AAAA,EAElD;AAAA,EAEA,aAAqB;AACnB,WAAO,KAAK,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,KAAK,MAAM;AAAA,EAC9C;AACF;AAIA,IAAM,gBAAgB,IAAI,QAAQ,KAAK,GAAG;AAC1C,IAAM,iBAAiB,IAAI,SAAS,KAAK,KAAK,GAAG;AAO1C,IAAM,aAAgC,CAAC,UAA2B;AACvE,MAAI,MAAM,CAAC,MAAM;AAAK,WAAO;AAE7B,QAAM,SAAS,MAAM,UAAU,GAAG,MAAM,SAAS,CAAC,EAAE,MAAM,GAAG;AAE7D,SAAO,IAAI,QAAQ,WAAW,OAAO,CAAC,CAAE,GAAG,WAAW,OAAO,CAAC,CAAE,CAAC;AACnE;AAGO,IAAM,cAAkC,CAAC,UAA4B;AAC1E,MAAI,MAAM,CAAC,MAAM,OAAO,MAAM,CAAC,MAAM;AAAK,WAAO;AAEjD,MAAI,QAAQ;AACZ,MAAI,SAAS;AACb,MAAI,cAAc;AAClB,WAAS,IAAI,GAAG,IAAI,MAAM,SAAS,GAAG,KAAK;AACzC,QAAI,CAAC,aAAa;AAChB,eAAS,MAAM,CAAC;AAAA,IAClB;AAEA,QAAI,MAAM,CAAC,MAAM,KAAK;AACpB,oBAAc;AACd;AAAA,IACF,WAAW,CAAC,aAAa;AACvB;AAAA,IACF;AAEA,QAAI,MAAM,CAAC,MAAM,KAAK;AACpB;AAAA,IACF;AAEA,cAAU,MAAM,CAAC;AAAA,EACnB;AAEA,QAAM,EAAE,GAAG,EAAE,IAAI,WAAW,KAAK;AACjC,SAAO,IAAI,SAAS,GAAG,GAAG,WAAW,MAAM,CAAC;AAC9C;",
+  "names": []
+}

package/dist/parsers/interval.cjs

@@ -0,0 +1,50 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// parsers/interval.ts
+var interval_exports = {};
+__export(interval_exports, {
+  PGInterval: () => PGInterval,
+  parseInterval: () => parseInterval
+});
+module.exports = __toCommonJS(interval_exports);
+var import_postgres_interval = __toESM(require("postgres-interval"));
+var PostgresInterval = import_postgres_interval.default;
+var PGInterval = class PGIntervalImpl extends PostgresInterval {
+  constructor(value) {
+    super(value);
+  }
+};
+var parseInterval = (value) => new PGInterval(value);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PGInterval,
+  parseInterval
+});
+//# sourceMappingURL=interval.cjs.map