@pgxsinkit/pgwasm/dist/chunk-d82gg1hx.js

// @bun
import {
  __export
} from "./chunk-kb3rsr7n.js";

// packages/pgwasm/src/types.ts
var exports_types = {};
__export(exports_types, {
  ABSTIME: () => ABSTIME,
  ACLITEM: () => ACLITEM,
  BIT: () => BIT,
  BOOL: () => BOOL,
  BPCHAR: () => BPCHAR,
  BYTEA: () => BYTEA,
  CHAR: () => CHAR,
  CID: () => CID,
  CIDR: () => CIDR,
  CIRCLE: () => CIRCLE,
  DATE: () => DATE,
  FLOAT4: () => FLOAT4,
  FLOAT8: () => FLOAT8,
  GTSVECTOR: () => GTSVECTOR,
  INET: () => INET,
  INT2: () => INT2,
  INT4: () => INT4,
  INT8: () => INT8,
  INTERVAL: () => INTERVAL,
  JSON: () => JSON,
  JSONB: () => JSONB,
  MACADDR: () => MACADDR,
  MACADDR8: () => MACADDR8,
  MONEY: () => MONEY,
  NUMERIC: () => NUMERIC,
  OID: () => OID,
  PATH: () => PATH,
  PG_DEPENDENCIES: () => PG_DEPENDENCIES,
  PG_LSN: () => PG_LSN,
  PG_NDISTINCT: () => PG_NDISTINCT,
  PG_NODE_TREE: () => PG_NODE_TREE,
  POLYGON: () => POLYGON,
  REFCURSOR: () => REFCURSOR,
  REGCLASS: () => REGCLASS,
  REGCONFIG: () => REGCONFIG,
  REGDICTIONARY: () => REGDICTIONARY,
  REGNAMESPACE: () => REGNAMESPACE,
  REGOPER: () => REGOPER,
  REGOPERATOR: () => REGOPERATOR,
  REGPROC: () => REGPROC,
  REGPROCEDURE: () => REGPROCEDURE,
  REGROLE: () => REGROLE,
  REGTYPE: () => REGTYPE,
  RELTIME: () => RELTIME,
  SMGR: () => SMGR,
  TEXT: () => TEXT,
  TID: () => TID,
  TIME: () => TIME,
  TIMESTAMP: () => TIMESTAMP,
  TIMESTAMPTZ: () => TIMESTAMPTZ,
  TIMETZ: () => TIMETZ,
  TINTERVAL: () => TINTERVAL,
  TSQUERY: () => TSQUERY,
  TSVECTOR: () => TSVECTOR,
  TXID_SNAPSHOT: () => TXID_SNAPSHOT,
  UUID: () => UUID,
  VARBIT: () => VARBIT,
  VARCHAR: () => VARCHAR,
  XID: () => XID,
  XML: () => XML,
  arrayParser: () => arrayParser,
  arraySerializer: () => arraySerializer,
  parseType: () => parseType,
  parsers: () => parsers,
  serializers: () => serializers,
  toText: () => toText,
  types: () => types
});
var JSON_parse = globalThis.JSON.parse;
var JSON_stringify = globalThis.JSON.stringify;
var BOOL = 16;
var BYTEA = 17;
var CHAR = 18;
var INT8 = 20;
var INT2 = 21;
var INT4 = 23;
var REGPROC = 24;
var TEXT = 25;
var OID = 26;
var TID = 27;
var XID = 28;
var CID = 29;
var JSON = 114;
var XML = 142;
var PG_NODE_TREE = 194;
var SMGR = 210;
var PATH = 602;
var POLYGON = 604;
var CIDR = 650;
var FLOAT4 = 700;
var FLOAT8 = 701;
var ABSTIME = 702;
var RELTIME = 703;
var TINTERVAL = 704;
var CIRCLE = 718;
var MACADDR8 = 774;
var MONEY = 790;
var MACADDR = 829;
var INET = 869;
var ACLITEM = 1033;
var BPCHAR = 1042;
var VARCHAR = 1043;
var DATE = 1082;
var TIME = 1083;
var TIMESTAMP = 1114;
var TIMESTAMPTZ = 1184;
var INTERVAL = 1186;
var TIMETZ = 1266;
var BIT = 1560;
var VARBIT = 1562;
var NUMERIC = 1700;
var REFCURSOR = 1790;
var REGPROCEDURE = 2202;
var REGOPER = 2203;
var REGOPERATOR = 2204;
var REGCLASS = 2205;
var REGTYPE = 2206;
var UUID = 2950;
var TXID_SNAPSHOT = 2970;
var PG_LSN = 3220;
var PG_NDISTINCT = 3361;
var PG_DEPENDENCIES = 3402;
var TSVECTOR = 3614;
var TSQUERY = 3615;
var GTSVECTOR = 3642;
var REGCONFIG = 3734;
var REGDICTIONARY = 3769;
var JSONB = 3802;
var REGNAMESPACE = 4089;
var REGROLE = 4096;
function serializeString(value) {
  if (value instanceof Date)
    return value.toISOString();
  return String(value);
}
function serializeBoolean(value) {
  if (typeof value === "boolean")
    return value ? "t" : "f";
  if (typeof value === "number") {
    if (value === 1)
      return "t";
    if (value === 0)
      return "f";
  } else if (typeof value === "string") {
    const s = value.trim().toLowerCase();
    if (["true", "t", "yes", "y", "on", "1"].includes(s))
      return "t";
    if (["false", "f", "no", "n", "off", "0"].includes(s))
      return "f";
  }
  throw new Error("Invalid input for boolean type");
}
function serializeDate(value) {
  if (typeof value === "string")
    return value;
  if (typeof value === "number")
    return new Date(value).toISOString();
  if (value instanceof Date)
    return value.toISOString();
  throw new Error("Invalid input for date type");
}
function serializeBytea(value) {
  if (!(value instanceof Uint8Array)) {
    throw new Error("Invalid input for bytea type");
  }
  return `\\x${Array.from(value, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
}
function parseBytea(value) {
  const hexString = value.slice(2);
  return Uint8Array.from({ length: hexString.length / 2 }, (_, idx) => Number.parseInt(hexString.substring(idx * 2, (idx + 1) * 2), 16));
}
function parseBigint(value) {
  const n = BigInt(value);
  return n < Number.MIN_SAFE_INTEGER || n > Number.MAX_SAFE_INTEGER ? n : Number(n);
}
function serializeJson(value) {
  if (typeof value === "string")
    return value;
  return JSON_stringify(value, (_, inner) => typeof inner === "bigint" ? inner.toString() : inner);
}
var types = {
  string: { to: TEXT, from: [TEXT, VARCHAR, BPCHAR], serialize: serializeString, parse: (x) => x },
  number: {
    to: 0,
    from: [INT2, INT4, OID, FLOAT4, FLOAT8],
    serialize: toText,
    parse: (x) => +x
  },
  bigint: { to: INT8, from: [INT8], serialize: toText, parse: parseBigint },
  json: { to: JSON, from: [JSON, JSONB], serialize: serializeJson, parse: (x) => JSON_parse(x) },
  boolean: { to: BOOL, from: [BOOL], serialize: serializeBoolean, parse: (x) => x === "t" },
  date: {
    to: TIMESTAMPTZ,
    from: [DATE, TIMESTAMP, TIMESTAMPTZ],
    serialize: serializeDate,
    parse: (x) => new Date(x)
  },
  bytea: { to: BYTEA, from: [BYTEA], serialize: serializeBytea, parse: parseBytea }
};
function typeHandlers(handlers) {
  const parsers2 = {};
  const serializers2 = {};
  for (const [name, { to, from, serialize, parse }] of Object.entries(handlers)) {
    serializers2[to] = serialize;
    serializers2[name] = serialize;
    parsers2[name] = parse;
    for (const oid of from) {
      parsers2[oid] = parse;
      serializers2[oid] = serialize;
    }
  }
  return { parsers: parsers2, serializers: serializers2 };
}
var defaultHandlers = typeHandlers(types);
var parsers = defaultHandlers.parsers;
var serializers = defaultHandlers.serializers;
function toText(value) {
  if (typeof value === "string")
    return value;
  return value.toString();
}
function parseType(value, type, overrides) {
  if (value === null)
    return null;
  const handler = overrides?.[type] ?? defaultHandlers.parsers[type];
  return handler ? handler(value, type) : value;
}
var escapeBackslash = /\\/g;
var escapeQuote = /"/g;
function arrayEscape(x) {
  return x.replace(escapeBackslash, "\\\\").replace(escapeQuote, "\\\"");
}
function arraySerializer(xs, serializer, typarray) {
  if (!Array.isArray(xs))
    return toText(xs);
  if (xs.length === 0)
    return "{}";
  const delimiter = typarray === 1020 ? ";" : ",";
  const first = xs[0];
  if (Array.isArray(first)) {
    return `{${xs.map((x) => arraySerializer(x, serializer, typarray)).join(delimiter)}}`;
  }
  return `{${xs.map((x) => {
    if (x === undefined || x === null)
      return "null";
    return `"${arrayEscape(serializer ? serializer(x) : toText(x))}"`;
  }).join(delimiter)}}`;
}
function arrayParser(x, parser, typarray) {
  const state = { i: 0, char: null, str: "", quoted: false, last: 0, p: null };
  return arrayParserLoop(state, x, parser, typarray)[0];
}
function arrayParserLoop(s, x, parser, typarray) {
  const xs = [];
  const delimiter = typarray === 1020 ? ";" : ",";
  for (;s.i < x.length; s.i++) {
    s.char = x[s.i] ?? null;
    if (s.quoted) {
      if (s.char === "\\") {
        s.str += x[++s.i] ?? "";
      } else if (s.char === '"') {
        xs.push(parser ? parser(s.str) : s.str);
        s.str = "";
        s.quoted = x[s.i + 1] === '"';
        s.last = s.i + 2;
      } else {
        s.str += s.char;
      }
    } else if (s.char === '"') {
      s.quoted = true;
    } else if (s.char === "{") {
      s.last = ++s.i;
      xs.push(arrayParserLoop(s, x, parser, typarray));
    } else if (s.char === "}") {
      if (s.last < s.i) {
        const el = x.slice(s.last, s.i);
        xs.push(el === "NULL" && !s.quoted ? null : parser ? parser(el) : el);
      }
      s.quoted = false;
      s.last = s.i + 1;
      break;
    } else if (s.char === delimiter && s.p !== "}" && s.p !== '"') {
      const el = x.slice(s.last, s.i);
      xs.push(el === "NULL" && !s.quoted ? null : parser ? parser(el) : el);
      s.last = s.i + 1;
    }
    s.p = s.char;
  }
  if (s.last < s.i) {
    const el = x.slice(s.last, s.i + 1);
    xs.push(parser ? parser(el) : el);
  }
  return xs;
}

export { TEXT, DATE, TIMESTAMP, TIMESTAMPTZ, INTERVAL, parsers, serializers, toText, parseType, arraySerializer, arrayParser, exports_types };

//# debugId=0AA7B8948EA60DD964756E2164756E21