@prisma-next/extension-postgis 0.0.1

package/dist/descriptor-meta-DUKzIH9c.mjs

@@ -0,0 +1,516 @@
+import { t as POSTGIS_GEOMETRY_CODEC_ID } from "./constants-dLvIWSgv.mjs";
+import { buildOperation, codecOf, toExpr } from "@prisma-next/sql-relational-core/expression";
+import { buildCodecDescriptorRegistry } from "@prisma-next/sql-relational-core/codec-descriptor-registry";
+import { CodecDescriptorImpl, CodecImpl } from "@prisma-next/framework-components/codec";
+import { type } from "arktype";
+//#region src/core/authoring.ts
+const postgisAuthoringTypes = { postgis: { Geometry: {
+	kind: "typeConstructor",
+	args: [{
+		kind: "number",
+		name: "srid",
+		integer: true,
+		minimum: 0
+	}],
+	output: {
+		codecId: POSTGIS_GEOMETRY_CODEC_ID,
+		nativeType: "geometry",
+		typeParams: { srid: {
+			kind: "arg",
+			index: 0
+		} }
+	}
+} } };
+//#endregion
+//#region src/core/ewkb.ts
+const FLAG_Z = 2147483648;
+const FLAG_M = 1073741824;
+const FLAG_SRID = 536870912;
+const TYPE_MASK = 536870911;
+const TYPE_POINT = 1;
+const TYPE_LINESTRING = 2;
+const TYPE_POLYGON = 3;
+const TYPE_MULTIPOINT = 4;
+const TYPE_MULTILINESTRING = 5;
+const TYPE_MULTIPOLYGON = 6;
+const HEX_PAIR_RE = /^[0-9a-fA-F]{2}$/;
+function hexToBytes(hex) {
+	if (hex.length % 2 !== 0) throw new Error("Geometry wire value: odd-length hex string");
+	const bytes = new Uint8Array(hex.length / 2);
+	for (let i = 0; i < bytes.length; i++) {
+		const pair = hex.slice(i * 2, i * 2 + 2);
+		if (!HEX_PAIR_RE.test(pair)) throw new Error(`Geometry wire value: invalid hex byte at offset ${i * 2}`);
+		bytes[i] = Number.parseInt(pair, 16);
+	}
+	return bytes;
+}
+var Reader = class {
+	offset = 0;
+	view;
+	constructor(bytes) {
+		this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	}
+	requireBytes(needed) {
+		if (this.offset + needed > this.view.byteLength) throw new Error(`Geometry wire value: unexpected end of buffer (need ${needed} bytes at offset ${this.offset}, ${this.view.byteLength - this.offset} available)`);
+	}
+	readUint8() {
+		this.requireBytes(1);
+		const v = this.view.getUint8(this.offset);
+		this.offset += 1;
+		return v;
+	}
+	readUint32(littleEndian) {
+		this.requireBytes(4);
+		const v = this.view.getUint32(this.offset, littleEndian);
+		this.offset += 4;
+		return v >>> 0;
+	}
+	readFloat64(littleEndian) {
+		this.requireBytes(8);
+		const v = this.view.getFloat64(this.offset, littleEndian);
+		this.offset += 8;
+		return v;
+	}
+	hasRemaining() {
+		return this.offset !== this.view.byteLength;
+	}
+	remainingBytes() {
+		return this.view.byteLength - this.offset;
+	}
+};
+function readHeader(reader) {
+	const byteOrder = reader.readUint8();
+	if (byteOrder !== 0 && byteOrder !== 1) throw new Error(`Geometry wire value: invalid byte order ${byteOrder}`);
+	const littleEndian = byteOrder === 1;
+	const typeCode = reader.readUint32(littleEndian);
+	if ((typeCode & FLAG_Z) !== 0 || (typeCode & FLAG_M) !== 0) throw new Error("Geometry wire value: Z/M coordinates are not supported");
+	const geomType = typeCode & TYPE_MASK;
+	if ((typeCode & FLAG_SRID) !== 0) return {
+		geomType,
+		littleEndian,
+		srid: reader.readUint32(littleEndian)
+	};
+	return {
+		geomType,
+		littleEndian
+	};
+}
+function readPosition(reader, littleEndian) {
+	return [reader.readFloat64(littleEndian), reader.readFloat64(littleEndian)];
+}
+function readPoint(reader, header) {
+	const coords = readPosition(reader, header.littleEndian);
+	return header.srid !== void 0 ? {
+		type: "Point",
+		coordinates: coords,
+		srid: header.srid
+	} : {
+		type: "Point",
+		coordinates: coords
+	};
+}
+function readLineString(reader, header) {
+	const n = reader.readUint32(header.littleEndian);
+	const coords = [];
+	for (let i = 0; i < n; i++) coords.push(readPosition(reader, header.littleEndian));
+	return header.srid !== void 0 ? {
+		type: "LineString",
+		coordinates: coords,
+		srid: header.srid
+	} : {
+		type: "LineString",
+		coordinates: coords
+	};
+}
+function readPolygon(reader, header) {
+	const numRings = reader.readUint32(header.littleEndian);
+	const rings = [];
+	for (let r = 0; r < numRings; r++) {
+		const n = reader.readUint32(header.littleEndian);
+		const ring = [];
+		for (let i = 0; i < n; i++) ring.push(readPosition(reader, header.littleEndian));
+		rings.push(ring);
+	}
+	return header.srid !== void 0 ? {
+		type: "Polygon",
+		coordinates: rings,
+		srid: header.srid
+	} : {
+		type: "Polygon",
+		coordinates: rings
+	};
+}
+function readSubGeometry(reader) {
+	const header = readHeader(reader);
+	switch (header.geomType) {
+		case TYPE_POINT: return readPoint(reader, header);
+		case TYPE_LINESTRING: return readLineString(reader, header);
+		case TYPE_POLYGON: return readPolygon(reader, header);
+		default: throw new Error(`Geometry wire value: unsupported sub-type ${header.geomType}`);
+	}
+}
+function readMultiPoint(reader, header) {
+	const n = reader.readUint32(header.littleEndian);
+	const coords = [];
+	for (let i = 0; i < n; i++) {
+		const sub = readSubGeometry(reader);
+		if (sub.type !== "Point") throw new Error("Geometry wire value: MultiPoint contains non-Point sub-geometry");
+		coords.push(sub.coordinates);
+	}
+	return header.srid !== void 0 ? {
+		type: "MultiPoint",
+		coordinates: coords,
+		srid: header.srid
+	} : {
+		type: "MultiPoint",
+		coordinates: coords
+	};
+}
+function readMultiLineString(reader, header) {
+	const n = reader.readUint32(header.littleEndian);
+	const lines = [];
+	for (let i = 0; i < n; i++) {
+		const sub = readSubGeometry(reader);
+		if (sub.type !== "LineString") throw new Error("Geometry wire value: MultiLineString contains non-LineString sub-geometry");
+		lines.push(sub.coordinates);
+	}
+	return header.srid !== void 0 ? {
+		type: "MultiLineString",
+		coordinates: lines,
+		srid: header.srid
+	} : {
+		type: "MultiLineString",
+		coordinates: lines
+	};
+}
+function readMultiPolygon(reader, header) {
+	const n = reader.readUint32(header.littleEndian);
+	const polys = [];
+	for (let i = 0; i < n; i++) {
+		const sub = readSubGeometry(reader);
+		if (sub.type !== "Polygon") throw new Error("Geometry wire value: MultiPolygon contains non-Polygon sub-geometry");
+		polys.push(sub.coordinates);
+	}
+	return header.srid !== void 0 ? {
+		type: "MultiPolygon",
+		coordinates: polys,
+		srid: header.srid
+	} : {
+		type: "MultiPolygon",
+		coordinates: polys
+	};
+}
+function decodeEWKBHex(hex) {
+	const reader = new Reader(hexToBytes(hex));
+	const geometry = readGeometryBody(reader, readHeader(reader));
+	if (reader.hasRemaining()) throw new Error(`Geometry wire value: trailing data after geometry (${reader.remainingBytes()} bytes)`);
+	return geometry;
+}
+function readGeometryBody(reader, header) {
+	switch (header.geomType) {
+		case TYPE_POINT: return readPoint(reader, header);
+		case TYPE_LINESTRING: return readLineString(reader, header);
+		case TYPE_POLYGON: return readPolygon(reader, header);
+		case TYPE_MULTIPOINT: return readMultiPoint(reader, header);
+		case TYPE_MULTILINESTRING: return readMultiLineString(reader, header);
+		case TYPE_MULTIPOLYGON: return readMultiPolygon(reader, header);
+		default: throw new Error(`Geometry wire value: unsupported geometry type ${header.geomType}`);
+	}
+}
+/**
+* Encode a GeoJSON-shaped geometry to an EWKT string PostGIS understands
+* via `'<ewkt>'::geometry`. We use EWKT (not EWKB) on the way in so the
+* generated SQL stays human-readable.
+*/
+function encodeEWKT(value) {
+	const sridPrefix = value.srid !== void 0 ? `SRID=${value.srid};` : "";
+	switch (value.type) {
+		case "Point": return `${sridPrefix}POINT(${formatPosition(value.coordinates)})`;
+		case "LineString": return `${sridPrefix}LINESTRING(${value.coordinates.map(formatPosition).join(",")})`;
+		case "Polygon": return `${sridPrefix}POLYGON(${formatRings(value.coordinates)})`;
+		case "MultiPoint": return `${sridPrefix}MULTIPOINT(${value.coordinates.map(formatPosition).join(",")})`;
+		case "MultiLineString": return `${sridPrefix}MULTILINESTRING(${value.coordinates.map((line) => `(${line.map(formatPosition).join(",")})`).join(",")})`;
+		case "MultiPolygon": return `${sridPrefix}MULTIPOLYGON(${value.coordinates.map((poly) => `(${formatRings(poly)})`).join(",")})`;
+	}
+}
+function formatPosition(p) {
+	if (!Number.isFinite(p[0]) || !Number.isFinite(p[1])) throw new Error("Geometry encode: coordinates must be finite numbers");
+	return `${p[0]} ${p[1]}`;
+}
+function formatRings(rings) {
+	return rings.map((ring) => `(${ring.map(formatPosition).join(",")})`).join(",");
+}
+//#endregion
+//#region src/core/codecs.ts
+const geometryParamsSchema = type({ srid: "number" }).narrow((params, ctx) => {
+	const { srid } = params;
+	if (!Number.isInteger(srid)) return ctx.mustBe("an integer");
+	if (srid < 0) return ctx.mustBe("a non-negative integer");
+	return true;
+});
+const POSTGIS_GEOMETRY_META = { db: { sql: { postgres: { nativeType: "geometry" } } } };
+const allowedGeometryTypes = new Set([
+	"Point",
+	"LineString",
+	"Polygon",
+	"MultiPoint",
+	"MultiLineString",
+	"MultiPolygon"
+]);
+function assertGeometry(value) {
+	if (!value || typeof value !== "object") throw new Error("Geometry value must be a GeoJSON-shaped object");
+	const type = value.type;
+	if (typeof type !== "string" || !allowedGeometryTypes.has(type)) throw new Error(`Geometry value: unsupported type "${String(type)}" (expected Point, LineString, Polygon, MultiPoint, MultiLineString, or MultiPolygon)`);
+	if (!Array.isArray(value.coordinates)) throw new Error("Geometry value: \"coordinates\" must be an array");
+}
+var PostgisGeometryCodec = class extends CodecImpl {
+	constructor(descriptor) {
+		super(descriptor);
+	}
+	async encode(value, _ctx) {
+		assertGeometry(value);
+		return encodeEWKT(value);
+	}
+	async decode(wire, _ctx) {
+		if (typeof wire !== "string") throw new Error("Geometry wire value must be a string");
+		return decodeEWKBHex(wire);
+	}
+	encodeJson(value) {
+		assertGeometry(value);
+		return value;
+	}
+	decodeJson(json) {
+		assertGeometry(json);
+		return json;
+	}
+};
+var PostgisGeometryDescriptor = class extends CodecDescriptorImpl {
+	codecId = POSTGIS_GEOMETRY_CODEC_ID;
+	traits = ["equality"];
+	targetTypes = ["geometry"];
+	meta = POSTGIS_GEOMETRY_META;
+	paramsSchema = geometryParamsSchema;
+	renderOutputType(params) {
+		const srid = params?.srid;
+		if (srid === void 0) return "Geometry";
+		return `Geometry<${srid}>`;
+	}
+	/**
+	* The runtime calls `factory(undefined)(ctx)` to materialize a
+	* representative codec for parameterised descriptors that ship a
+	* no-params column variant (here, `geometryColumn` vs `geometry({ srid })`).
+	* The runtime cast widens `params` to `unknown`, so guarding with an
+	* optional read keeps the typed call site (`factory({ srid })`)
+	* strict while still producing an SRID-agnostic codec for
+	* representative use. Encode/decode for an unparameterised column
+	* runs through this representative; the wire format already carries
+	* SRID inside the EWKT/EWKB payload, so it's dimension-independent.
+	*/
+	factory(_params) {
+		return () => new PostgisGeometryCodec(this);
+	}
+};
+const codecDescriptorMap = { geometry: new PostgisGeometryDescriptor() };
+//#endregion
+//#region src/core/registry.ts
+/**
+* Registry of every codec descriptor shipped by `@prisma-next/extension-postgis`.
+*
+* Public consumer surface for the postgis codec set. Currently a single
+* entry (`pg/geometry@1`); the registry shape stays consistent with
+* the other codec-shipping packages so consumers don't need to
+* special-case extensions.
+*/
+const postgisCodecRegistry = buildCodecDescriptorRegistry(Object.values(codecDescriptorMap));
+//#endregion
+//#region src/core/descriptor-meta.ts
+const postgisTypeId = "pg/geometry@1";
+/**
+* Build the PostGIS query operations exposed on `geometry` columns.
+*
+* Each operation lowers to a function-template that the SQL renderer
+* stitches into the surrounding statement (`{{self}}` is the receiver,
+* `{{argN}}` are the call arguments). All templates rely on the implicit
+* `geometry`/`float8`/`bool` casts already wired up by the SQL family —
+* we only add the PostGIS-specific function names.
+*/
+function postgisQueryOperations() {
+	return {
+		distance: {
+			self: { codecId: postgisTypeId },
+			impl: (self, other) => {
+				const selfCodec = codecOf(self);
+				return buildOperation({
+					method: "distance",
+					args: [toExpr(self, selfCodec), toExpr(other, selfCodec)],
+					returns: {
+						codecId: "pg/float8@1",
+						nullable: false
+					},
+					lowering: {
+						targetFamily: "sql",
+						strategy: "function",
+						template: "ST_Distance({{self}}, {{arg0}})"
+					}
+				});
+			}
+		},
+		distanceSphere: {
+			self: { codecId: postgisTypeId },
+			impl: (self, other) => {
+				const selfCodec = codecOf(self);
+				return buildOperation({
+					method: "distanceSphere",
+					args: [toExpr(self, selfCodec), toExpr(other, selfCodec)],
+					returns: {
+						codecId: "pg/float8@1",
+						nullable: false
+					},
+					lowering: {
+						targetFamily: "sql",
+						strategy: "function",
+						template: "ST_DistanceSphere({{self}}, {{arg0}})"
+					}
+				});
+			}
+		},
+		dwithin: {
+			self: { codecId: postgisTypeId },
+			impl: (self, other, distance) => {
+				const selfCodec = codecOf(self);
+				return buildOperation({
+					method: "dwithin",
+					args: [
+						toExpr(self, selfCodec),
+						toExpr(other, selfCodec),
+						toExpr(distance, { codecId: "pg/float8@1" })
+					],
+					returns: {
+						codecId: "pg/bool@1",
+						nullable: false
+					},
+					lowering: {
+						targetFamily: "sql",
+						strategy: "function",
+						template: "ST_DWithin({{self}}, {{arg0}}, {{arg1}})"
+					}
+				});
+			}
+		},
+		contains: {
+			self: { codecId: postgisTypeId },
+			impl: (self, other) => {
+				const selfCodec = codecOf(self);
+				return buildOperation({
+					method: "contains",
+					args: [toExpr(self, selfCodec), toExpr(other, selfCodec)],
+					returns: {
+						codecId: "pg/bool@1",
+						nullable: false
+					},
+					lowering: {
+						targetFamily: "sql",
+						strategy: "function",
+						template: "ST_Contains({{self}}, {{arg0}})"
+					}
+				});
+			}
+		},
+		within: {
+			self: { codecId: postgisTypeId },
+			impl: (self, other) => {
+				const selfCodec = codecOf(self);
+				return buildOperation({
+					method: "within",
+					args: [toExpr(self, selfCodec), toExpr(other, selfCodec)],
+					returns: {
+						codecId: "pg/bool@1",
+						nullable: false
+					},
+					lowering: {
+						targetFamily: "sql",
+						strategy: "function",
+						template: "ST_Within({{self}}, {{arg0}})"
+					}
+				});
+			}
+		},
+		intersects: {
+			self: { codecId: postgisTypeId },
+			impl: (self, other) => {
+				const selfCodec = codecOf(self);
+				return buildOperation({
+					method: "intersects",
+					args: [toExpr(self, selfCodec), toExpr(other, selfCodec)],
+					returns: {
+						codecId: "pg/bool@1",
+						nullable: false
+					},
+					lowering: {
+						targetFamily: "sql",
+						strategy: "function",
+						template: "ST_Intersects({{self}}, {{arg0}})"
+					}
+				});
+			}
+		},
+		intersectsBbox: {
+			self: { codecId: postgisTypeId },
+			impl: (self, other) => {
+				const selfCodec = codecOf(self);
+				return buildOperation({
+					method: "intersectsBbox",
+					args: [toExpr(self, selfCodec), toExpr(other, selfCodec)],
+					returns: {
+						codecId: "pg/bool@1",
+						nullable: false
+					},
+					lowering: {
+						targetFamily: "sql",
+						strategy: "function",
+						template: "({{self}} && {{arg0}})"
+					}
+				});
+			}
+		}
+	};
+}
+const postgisPackMeta = {
+	kind: "extension",
+	id: "postgis",
+	familyId: "sql",
+	targetId: "postgres",
+	version: "0.0.1",
+	capabilities: { postgres: { "postgis.geometry": true } },
+	authoring: { type: postgisAuthoringTypes },
+	types: {
+		codecTypes: {
+			codecDescriptors: Array.from(postgisCodecRegistry.values()),
+			import: {
+				package: "@prisma-next/extension-postgis/codec-types",
+				named: "CodecTypes",
+				alias: "PostgisTypes"
+			},
+			typeImports: [{
+				package: "@prisma-next/extension-postgis/codec-types",
+				named: "Geometry",
+				alias: "Geometry"
+			}]
+		},
+		queryOperationTypes: { import: {
+			package: "@prisma-next/extension-postgis/operation-types",
+			named: "QueryOperationTypes",
+			alias: "PostgisQueryOperationTypes"
+		} },
+		storage: [{
+			typeId: postgisTypeId,
+			familyId: "sql",
+			targetId: "postgres",
+			nativeType: "geometry"
+		}]
+	}
+};
+//#endregion
+export { postgisQueryOperations as n, postgisCodecRegistry as r, postgisPackMeta as t };
+
+//# sourceMappingURL=descriptor-meta-DUKzIH9c.mjs.map

package/dist/descriptor-meta-DUKzIH9c.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-DUKzIH9c.mjs","names":["arktype"],"sources":["../src/core/authoring.ts","../src/core/ewkb.ts","../src/core/codecs.ts","../src/core/registry.ts","../src/core/descriptor-meta.ts"],"sourcesContent":["import type { AuthoringTypeNamespace } from '@prisma-next/framework-components/authoring';\nimport { POSTGIS_GEOMETRY_CODEC_ID } from './constants';\n\nexport const postgisAuthoringTypes = {\n  postgis: {\n    Geometry: {\n      kind: 'typeConstructor',\n      args: [{ kind: 'number', name: 'srid', integer: true, minimum: 0 }],\n      output: {\n        codecId: POSTGIS_GEOMETRY_CODEC_ID,\n        nativeType: 'geometry',\n        typeParams: {\n          srid: { kind: 'arg', index: 0 },\n        },\n      },\n    },\n  },\n} as const satisfies AuthoringTypeNamespace;\n","/**\n * Minimal EWKB (Extended Well-Known Binary) reader for the PostGIS codec.\n *\n * `node-postgres` returns geometry columns as hex-encoded EWKB strings by\n * default. This reader parses the subset we ship with the extension —\n * Point, LineString, Polygon, and the Multi* counterparts — into GeoJSON\n * objects. Z and M coordinates are not supported; if a wire value carries\n * them, decoding throws so the caller can detect the mismatch instead of\n * silently dropping data.\n */\n\nimport type {\n  Geometry,\n  GeometryLineString,\n  GeometryMultiLineString,\n  GeometryMultiPoint,\n  GeometryMultiPolygon,\n  GeometryPoint,\n  GeometryPolygon,\n  Position,\n} from './geojson';\n\nconst FLAG_Z = 0x80000000;\nconst FLAG_M = 0x40000000;\nconst FLAG_SRID = 0x20000000;\nconst TYPE_MASK = 0x1fffffff;\n\nconst TYPE_POINT = 1;\nconst TYPE_LINESTRING = 2;\nconst TYPE_POLYGON = 3;\nconst TYPE_MULTIPOINT = 4;\nconst TYPE_MULTILINESTRING = 5;\nconst TYPE_MULTIPOLYGON = 6;\n\nconst HEX_PAIR_RE = /^[0-9a-fA-F]{2}$/;\n\nfunction hexToBytes(hex: string): Uint8Array {\n  if (hex.length % 2 !== 0) {\n    throw new Error('Geometry wire value: odd-length hex string');\n  }\n  const bytes = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < bytes.length; i++) {\n    const pair = hex.slice(i * 2, i * 2 + 2);\n    if (!HEX_PAIR_RE.test(pair)) {\n      throw new Error(`Geometry wire value: invalid hex byte at offset ${i * 2}`);\n    }\n    bytes[i] = Number.parseInt(pair, 16);\n  }\n  return bytes;\n}\n\nclass Reader {\n  private offset = 0;\n  private readonly view: DataView;\n\n  constructor(bytes: Uint8Array) {\n    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n  }\n\n  private requireBytes(needed: number): void {\n    if (this.offset + needed > this.view.byteLength) {\n      throw new Error(\n        `Geometry wire value: unexpected end of buffer (need ${needed} bytes at offset ${this.offset}, ${this.view.byteLength - this.offset} available)`,\n      );\n    }\n  }\n\n  readUint8(): number {\n    this.requireBytes(1);\n    const v = this.view.getUint8(this.offset);\n    this.offset += 1;\n    return v;\n  }\n\n  readUint32(littleEndian: boolean): number {\n    this.requireBytes(4);\n    const v = this.view.getUint32(this.offset, littleEndian);\n    this.offset += 4;\n    return v >>> 0;\n  }\n\n  readFloat64(littleEndian: boolean): number {\n    this.requireBytes(8);\n    const v = this.view.getFloat64(this.offset, littleEndian);\n    this.offset += 8;\n    return v;\n  }\n\n  hasRemaining(): boolean {\n    return this.offset !== this.view.byteLength;\n  }\n\n  remainingBytes(): number {\n    return this.view.byteLength - this.offset;\n  }\n}\n\ntype Header = {\n  readonly geomType: number;\n  readonly littleEndian: boolean;\n  readonly srid?: number;\n};\n\nfunction readHeader(reader: Reader): Header {\n  const byteOrder = reader.readUint8();\n  if (byteOrder !== 0 && byteOrder !== 1) {\n    throw new Error(`Geometry wire value: invalid byte order ${byteOrder}`);\n  }\n  const littleEndian = byteOrder === 1;\n  const typeCode = reader.readUint32(littleEndian);\n  if ((typeCode & FLAG_Z) !== 0 || (typeCode & FLAG_M) !== 0) {\n    throw new Error('Geometry wire value: Z/M coordinates are not supported');\n  }\n  const geomType = typeCode & TYPE_MASK;\n  if ((typeCode & FLAG_SRID) !== 0) {\n    return { geomType, littleEndian, srid: reader.readUint32(littleEndian) };\n  }\n  return { geomType, littleEndian };\n}\n\nfunction readPosition(reader: Reader, littleEndian: boolean): Position {\n  const x = reader.readFloat64(littleEndian);\n  const y = reader.readFloat64(littleEndian);\n  return [x, y];\n}\n\nfunction readPoint(reader: Reader, header: Header): GeometryPoint {\n  const coords = readPosition(reader, header.littleEndian);\n  return header.srid !== undefined\n    ? { type: 'Point', coordinates: coords, srid: header.srid }\n    : { type: 'Point', coordinates: coords };\n}\n\nfunction readLineString(reader: Reader, header: Header): GeometryLineString {\n  const n = reader.readUint32(header.littleEndian);\n  const coords: Position[] = [];\n  for (let i = 0; i < n; i++) coords.push(readPosition(reader, header.littleEndian));\n  return header.srid !== undefined\n    ? { type: 'LineString', coordinates: coords, srid: header.srid }\n    : { type: 'LineString', coordinates: coords };\n}\n\nfunction readPolygon(reader: Reader, header: Header): GeometryPolygon {\n  const numRings = reader.readUint32(header.littleEndian);\n  const rings: Position[][] = [];\n  for (let r = 0; r < numRings; r++) {\n    const n = reader.readUint32(header.littleEndian);\n    const ring: Position[] = [];\n    for (let i = 0; i < n; i++) ring.push(readPosition(reader, header.littleEndian));\n    rings.push(ring);\n  }\n  return header.srid !== undefined\n    ? { type: 'Polygon', coordinates: rings, srid: header.srid }\n    : { type: 'Polygon', coordinates: rings };\n}\n\nfunction readSubGeometry(reader: Reader): Geometry {\n  // Multi* geometries embed sub-WKB records; each carries its own header.\n  const header = readHeader(reader);\n  switch (header.geomType) {\n    case TYPE_POINT:\n      return readPoint(reader, header);\n    case TYPE_LINESTRING:\n      return readLineString(reader, header);\n    case TYPE_POLYGON:\n      return readPolygon(reader, header);\n    default:\n      throw new Error(`Geometry wire value: unsupported sub-type ${header.geomType}`);\n  }\n}\n\nfunction readMultiPoint(reader: Reader, header: Header): GeometryMultiPoint {\n  const n = reader.readUint32(header.littleEndian);\n  const coords: Position[] = [];\n  for (let i = 0; i < n; i++) {\n    const sub = readSubGeometry(reader);\n    if (sub.type !== 'Point') {\n      throw new Error('Geometry wire value: MultiPoint contains non-Point sub-geometry');\n    }\n    coords.push(sub.coordinates);\n  }\n  return header.srid !== undefined\n    ? { type: 'MultiPoint', coordinates: coords, srid: header.srid }\n    : { type: 'MultiPoint', coordinates: coords };\n}\n\nfunction readMultiLineString(reader: Reader, header: Header): GeometryMultiLineString {\n  const n = reader.readUint32(header.littleEndian);\n  const lines: ReadonlyArray<Position>[] = [];\n  for (let i = 0; i < n; i++) {\n    const sub = readSubGeometry(reader);\n    if (sub.type !== 'LineString') {\n      throw new Error('Geometry wire value: MultiLineString contains non-LineString sub-geometry');\n    }\n    lines.push(sub.coordinates);\n  }\n  return header.srid !== undefined\n    ? { type: 'MultiLineString', coordinates: lines, srid: header.srid }\n    : { type: 'MultiLineString', coordinates: lines };\n}\n\nfunction readMultiPolygon(reader: Reader, header: Header): GeometryMultiPolygon {\n  const n = reader.readUint32(header.littleEndian);\n  const polys: ReadonlyArray<ReadonlyArray<Position>>[] = [];\n  for (let i = 0; i < n; i++) {\n    const sub = readSubGeometry(reader);\n    if (sub.type !== 'Polygon') {\n      throw new Error('Geometry wire value: MultiPolygon contains non-Polygon sub-geometry');\n    }\n    polys.push(sub.coordinates);\n  }\n  return header.srid !== undefined\n    ? { type: 'MultiPolygon', coordinates: polys, srid: header.srid }\n    : { type: 'MultiPolygon', coordinates: polys };\n}\n\nexport function decodeEWKBHex(hex: string): Geometry {\n  const reader = new Reader(hexToBytes(hex));\n  const header = readHeader(reader);\n  const geometry = readGeometryBody(reader, header);\n  if (reader.hasRemaining()) {\n    throw new Error(\n      `Geometry wire value: trailing data after geometry (${reader.remainingBytes()} bytes)`,\n    );\n  }\n  return geometry;\n}\n\nfunction readGeometryBody(reader: Reader, header: Header): Geometry {\n  switch (header.geomType) {\n    case TYPE_POINT:\n      return readPoint(reader, header);\n    case TYPE_LINESTRING:\n      return readLineString(reader, header);\n    case TYPE_POLYGON:\n      return readPolygon(reader, header);\n    case TYPE_MULTIPOINT:\n      return readMultiPoint(reader, header);\n    case TYPE_MULTILINESTRING:\n      return readMultiLineString(reader, header);\n    case TYPE_MULTIPOLYGON:\n      return readMultiPolygon(reader, header);\n    default:\n      throw new Error(`Geometry wire value: unsupported geometry type ${header.geomType}`);\n  }\n}\n\n/**\n * Encode a GeoJSON-shaped geometry to an EWKT string PostGIS understands\n * via `'<ewkt>'::geometry`. We use EWKT (not EWKB) on the way in so the\n * generated SQL stays human-readable.\n */\nexport function encodeEWKT(value: Geometry): string {\n  const sridPrefix = value.srid !== undefined ? `SRID=${value.srid};` : '';\n  switch (value.type) {\n    case 'Point':\n      return `${sridPrefix}POINT(${formatPosition(value.coordinates)})`;\n    case 'LineString':\n      return `${sridPrefix}LINESTRING(${value.coordinates.map(formatPosition).join(',')})`;\n    case 'Polygon':\n      return `${sridPrefix}POLYGON(${formatRings(value.coordinates)})`;\n    case 'MultiPoint':\n      return `${sridPrefix}MULTIPOINT(${value.coordinates.map(formatPosition).join(',')})`;\n    case 'MultiLineString':\n      return `${sridPrefix}MULTILINESTRING(${value.coordinates\n        .map((line) => `(${line.map(formatPosition).join(',')})`)\n        .join(',')})`;\n    case 'MultiPolygon':\n      return `${sridPrefix}MULTIPOLYGON(${value.coordinates\n        .map((poly) => `(${formatRings(poly)})`)\n        .join(',')})`;\n  }\n}\n\nfunction formatPosition(p: Position): string {\n  if (!Number.isFinite(p[0]) || !Number.isFinite(p[1])) {\n    throw new Error('Geometry encode: coordinates must be finite numbers');\n  }\n  return `${p[0]} ${p[1]}`;\n}\n\nfunction formatRings(rings: ReadonlyArray<ReadonlyArray<Position>>): string {\n  return rings.map((ring) => `(${ring.map(formatPosition).join(',')})`).join(',');\n}\n","/**\n * Geometry codec for the PostGIS extension.\n *\n * Mirrors the descriptor + class pattern used by other codec-shipping\n * packages (e.g. pgvector). Three artefacts:\n *\n * 1. `PostgisGeometryCodec` extends {@link CodecImpl} with the runtime\n *    encode/decode conversions. Wire formats:\n *    - encode: EWKT (`'SRID=4326;POINT(...)'`) — PostgreSQL parses\n *      this when cast to `::geometry`.\n *    - decode: hex EWKB — the default representation `node-postgres`\n *      hands back for `geometry` columns. We parse it into a\n *      GeoJSON-shaped object so callers see structured data, not\n *      opaque hex.\n * 2. `PostgisGeometryDescriptor` extends {@link CodecDescriptorImpl}\n *    with the codec id, traits, target types, params schema\n *    (`{ srid: number }`, validated as a non-negative integer), and\n *    the emit-path `renderOutputType` producing `Geometry<${srid}>` /\n *    `Geometry` when no SRID is supplied.\n * 3. `pgGeometryColumn({ srid })` per-codec column helper invoking\n *    `descriptor.factory({ srid })` and passing the bare\n *    `nativeType: 'geometry'`. The family-layer `expandNativeType`\n *    hook renders the parameterised form\n *    (`geometry(Geometry,${srid})`) at emit/verify time from\n *    `nativeType` + `typeParams`.\n *\n * The geometry codec's encode/decode is parameter-independent — the\n * wire format already carries SRID inside the EWKT/EWKB payload, so the\n * resolved codec for every `(srid)` instance is the same shared codec\n * today. The factory threads the closure for future per-instance state\n * (e.g. SRID cross-checks) without rewriting the constructor.\n */\n\nimport type { JsonValue } from '@prisma-next/contract/types';\nimport {\n  type AnyCodecDescriptor,\n  type CodecCallContext,\n  CodecDescriptorImpl,\n  CodecImpl,\n  type CodecInstanceContext,\n  type ColumnHelperFor,\n  type ColumnHelperForStrict,\n  column,\n} from '@prisma-next/framework-components/codec';\nimport type { ExtractCodecTypes } from '@prisma-next/sql-relational-core/ast';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport { type as arktype } from 'arktype';\nimport { POSTGIS_GEOMETRY_CODEC_ID } from './constants';\nimport { decodeEWKBHex, encodeEWKT } from './ewkb';\nimport type { Geometry } from './geojson';\n\ntype GeometryParams = { readonly srid: number };\n\nconst geometryParamsSchema = arktype({\n  srid: 'number',\n}).narrow((params, ctx) => {\n  const { srid } = params;\n  if (!Number.isInteger(srid)) {\n    return ctx.mustBe('an integer');\n  }\n  if (srid < 0) {\n    return ctx.mustBe('a non-negative integer');\n  }\n  return true;\n}) satisfies StandardSchemaV1<GeometryParams>;\n\nconst POSTGIS_GEOMETRY_META = {\n  db: { sql: { postgres: { nativeType: 'geometry' } } },\n} as const;\n\nconst allowedGeometryTypes = new Set([\n  'Point',\n  'LineString',\n  'Polygon',\n  'MultiPoint',\n  'MultiLineString',\n  'MultiPolygon',\n]);\n\nfunction assertGeometry(value: unknown): asserts value is Geometry {\n  if (!value || typeof value !== 'object') {\n    throw new Error('Geometry value must be a GeoJSON-shaped object');\n  }\n  const type = (value as { type?: unknown }).type;\n  if (typeof type !== 'string' || !allowedGeometryTypes.has(type)) {\n    throw new Error(\n      `Geometry value: unsupported type \"${String(type)}\" (expected Point, LineString, Polygon, MultiPoint, MultiLineString, or MultiPolygon)`,\n    );\n  }\n  if (!Array.isArray((value as { coordinates?: unknown }).coordinates)) {\n    throw new Error('Geometry value: \"coordinates\" must be an array');\n  }\n}\n\nexport class PostgisGeometryCodec extends CodecImpl<\n  typeof POSTGIS_GEOMETRY_CODEC_ID,\n  readonly ['equality'],\n  string,\n  Geometry\n> {\n  constructor(descriptor: AnyCodecDescriptor) {\n    super(descriptor);\n  }\n\n  async encode(value: Geometry, _ctx: CodecCallContext): Promise<string> {\n    assertGeometry(value);\n    return encodeEWKT(value);\n  }\n\n  async decode(wire: string, _ctx: CodecCallContext): Promise<Geometry> {\n    if (typeof wire !== 'string') {\n      throw new Error('Geometry wire value must be a string');\n    }\n    return decodeEWKBHex(wire);\n  }\n\n  encodeJson(value: Geometry): JsonValue {\n    assertGeometry(value);\n    return value as unknown as JsonValue;\n  }\n\n  decodeJson(json: JsonValue): Geometry {\n    assertGeometry(json);\n    return json;\n  }\n}\n\nexport class PostgisGeometryDescriptor extends CodecDescriptorImpl<GeometryParams> {\n  override readonly codecId = POSTGIS_GEOMETRY_CODEC_ID;\n  override readonly traits = ['equality'] as const;\n  override readonly targetTypes = ['geometry'] as const;\n  override readonly meta = POSTGIS_GEOMETRY_META;\n  override readonly paramsSchema: StandardSchemaV1<GeometryParams> = geometryParamsSchema;\n  override renderOutputType(params: GeometryParams): string {\n    const srid = (params as GeometryParams | undefined)?.srid;\n    if (srid === undefined) return 'Geometry';\n    return `Geometry<${srid}>`;\n  }\n  /**\n   * The runtime calls `factory(undefined)(ctx)` to materialize a\n   * representative codec for parameterised descriptors that ship a\n   * no-params column variant (here, `geometryColumn` vs `geometry({ srid })`).\n   * The runtime cast widens `params` to `unknown`, so guarding with an\n   * optional read keeps the typed call site (`factory({ srid })`)\n   * strict while still producing an SRID-agnostic codec for\n   * representative use. Encode/decode for an unparameterised column\n   * runs through this representative; the wire format already carries\n   * SRID inside the EWKT/EWKB payload, so it's dimension-independent.\n   */\n  override factory(_params: GeometryParams): (ctx: CodecInstanceContext) => PostgisGeometryCodec {\n    return () => new PostgisGeometryCodec(this);\n  }\n}\n\nexport const postgisGeometryDescriptor = new PostgisGeometryDescriptor();\n\n/**\n * Per-codec column helper for `pg/geometry@1` with an SRID constraint.\n *\n * Generic over `S extends number` so the column site preserves the\n * SRID literal in `typeParams` (e.g. `pgGeometryColumn({ srid: 4326 })`\n * packs `typeParams: { srid: 4326 }`).\n *\n * Passes the bare `nativeType: 'geometry'`; the family-layer\n * `expandNativeType` hook renders the parameterised form\n * (`geometry(Geometry,${srid})`) at emit/verify time from `nativeType`\n * + `typeParams`.\n *\n * @throws {RangeError} If `srid` is not a non-negative integer.\n */\nexport const pgGeometryColumn = <S extends number>(options: { readonly srid: S }) => {\n  const { srid } = options;\n  if (!Number.isInteger(srid) || srid < 0) {\n    throw new RangeError(`postgis: srid must be a non-negative integer, got ${srid}`);\n  }\n  return column(\n    postgisGeometryDescriptor.factory({ srid }),\n    postgisGeometryDescriptor.codecId,\n    { srid },\n    'geometry',\n  );\n};\n\npgGeometryColumn satisfies ColumnHelperFor<PostgisGeometryDescriptor>;\npgGeometryColumn satisfies ColumnHelperForStrict<PostgisGeometryDescriptor>;\n\nconst codecDescriptorMap = {\n  geometry: postgisGeometryDescriptor,\n} as const;\n\nexport type CodecTypes = ExtractCodecTypes<typeof codecDescriptorMap>;\n\nexport const codecDescriptors: readonly AnyCodecDescriptor[] = Object.values(codecDescriptorMap);\n","import { buildCodecDescriptorRegistry } from '@prisma-next/sql-relational-core/codec-descriptor-registry';\nimport type { CodecDescriptorRegistry } from '@prisma-next/sql-relational-core/query-lane-context';\nimport { codecDescriptors } from './codecs';\n\n/**\n * Registry of every codec descriptor shipped by `@prisma-next/extension-postgis`.\n *\n * Public consumer surface for the postgis codec set. Currently a single\n * entry (`pg/geometry@1`); the registry shape stays consistent with\n * the other codec-shipping packages so consumers don't need to\n * special-case extensions.\n */\nexport const postgisCodecRegistry: CodecDescriptorRegistry =\n  buildCodecDescriptorRegistry(codecDescriptors);\n","import { buildOperation, codecOf, toExpr } from '@prisma-next/sql-relational-core/expression';\nimport type { CodecTypes } from '../types/codec-types';\nimport type { QueryOperationTypes } from '../types/operation-types';\nimport { postgisAuthoringTypes } from './authoring';\nimport { postgisCodecRegistry } from './registry';\n\nconst postgisTypeId = 'pg/geometry@1' as const;\n\ntype CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;\n\n/**\n * Build the PostGIS query operations exposed on `geometry` columns.\n *\n * Each operation lowers to a function-template that the SQL renderer\n * stitches into the surrounding statement (`{{self}}` is the receiver,\n * `{{argN}}` are the call arguments). All templates rely on the implicit\n * `geometry`/`float8`/`bool` casts already wired up by the SQL family —\n * we only add the PostGIS-specific function names.\n */\nexport function postgisQueryOperations<CT extends CodecTypesBase>(): QueryOperationTypes<CT> {\n  return {\n    distance: {\n      self: { codecId: postgisTypeId },\n      impl: (self, other) => {\n        const selfCodec = codecOf(self);\n        return buildOperation({\n          method: 'distance',\n          args: [toExpr(self, selfCodec), toExpr(other, selfCodec)],\n          returns: { codecId: 'pg/float8@1', nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: 'ST_Distance({{self}}, {{arg0}})',\n          },\n        });\n      },\n    },\n    distanceSphere: {\n      self: { codecId: postgisTypeId },\n      impl: (self, other) => {\n        const selfCodec = codecOf(self);\n        return buildOperation({\n          method: 'distanceSphere',\n          args: [toExpr(self, selfCodec), toExpr(other, selfCodec)],\n          returns: { codecId: 'pg/float8@1', nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: 'ST_DistanceSphere({{self}}, {{arg0}})',\n          },\n        });\n      },\n    },\n    dwithin: {\n      self: { codecId: postgisTypeId },\n      impl: (self, other, distance) => {\n        const selfCodec = codecOf(self);\n        return buildOperation({\n          method: 'dwithin',\n          args: [\n            toExpr(self, selfCodec),\n            toExpr(other, selfCodec),\n            toExpr(distance, { codecId: 'pg/float8@1' }),\n          ],\n          returns: { codecId: 'pg/bool@1', nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: 'ST_DWithin({{self}}, {{arg0}}, {{arg1}})',\n          },\n        });\n      },\n    },\n    contains: {\n      self: { codecId: postgisTypeId },\n      impl: (self, other) => {\n        const selfCodec = codecOf(self);\n        return buildOperation({\n          method: 'contains',\n          args: [toExpr(self, selfCodec), toExpr(other, selfCodec)],\n          returns: { codecId: 'pg/bool@1', nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: 'ST_Contains({{self}}, {{arg0}})',\n          },\n        });\n      },\n    },\n    within: {\n      self: { codecId: postgisTypeId },\n      impl: (self, other) => {\n        const selfCodec = codecOf(self);\n        return buildOperation({\n          method: 'within',\n          args: [toExpr(self, selfCodec), toExpr(other, selfCodec)],\n          returns: { codecId: 'pg/bool@1', nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: 'ST_Within({{self}}, {{arg0}})',\n          },\n        });\n      },\n    },\n    intersects: {\n      self: { codecId: postgisTypeId },\n      impl: (self, other) => {\n        const selfCodec = codecOf(self);\n        return buildOperation({\n          method: 'intersects',\n          args: [toExpr(self, selfCodec), toExpr(other, selfCodec)],\n          returns: { codecId: 'pg/bool@1', nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: 'ST_Intersects({{self}}, {{arg0}})',\n          },\n        });\n      },\n    },\n    intersectsBbox: {\n      self: { codecId: postgisTypeId },\n      impl: (self, other) => {\n        const selfCodec = codecOf(self);\n        return buildOperation({\n          method: 'intersectsBbox',\n          args: [toExpr(self, selfCodec), toExpr(other, selfCodec)],\n          returns: { codecId: 'pg/bool@1', nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '({{self}} && {{arg0}})',\n          },\n        });\n      },\n    },\n  };\n}\n\nconst postgisPackMetaBase = {\n  kind: 'extension',\n  id: 'postgis',\n  familyId: 'sql',\n  targetId: 'postgres',\n  version: '0.0.1',\n  capabilities: {\n    postgres: {\n      'postgis.geometry': true,\n    },\n  },\n  authoring: {\n    type: postgisAuthoringTypes,\n  },\n  types: {\n    codecTypes: {\n      codecDescriptors: Array.from(postgisCodecRegistry.values()),\n      import: {\n        package: '@prisma-next/extension-postgis/codec-types',\n        named: 'CodecTypes',\n        alias: 'PostgisTypes',\n      },\n      typeImports: [\n        {\n          package: '@prisma-next/extension-postgis/codec-types',\n          named: 'Geometry',\n          alias: 'Geometry',\n        },\n      ],\n    },\n    queryOperationTypes: {\n      import: {\n        package: '@prisma-next/extension-postgis/operation-types',\n        named: 'QueryOperationTypes',\n        alias: 'PostgisQueryOperationTypes',\n      },\n    },\n    storage: [\n      { typeId: postgisTypeId, familyId: 'sql', targetId: 'postgres', nativeType: 'geometry' },\n    ],\n  },\n} as const;\n\nexport const postgisPackMeta: typeof postgisPackMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n} = postgisPackMetaBase;\n"],"mappings":"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"}

package/dist/geojson-Cj4ldHQ0.d.mts

@@ -0,0 +1,61 @@
+//#region src/core/geojson.d.ts
+/**
+ * GeoJSON-shaped value types used by the PostGIS codec.
+ *
+ * The codec speaks GeoJSON-style objects to JavaScript callers and
+ * EWKT/EWKB on the wire. This file is the single source of truth for the
+ * value shapes; the public type re-export lives in `exports/geojson.ts`.
+ */
+type Position = readonly [number, number];
+type GeometryPoint = {
+  readonly type: 'Point';
+  readonly coordinates: Position;
+  readonly srid?: number;
+};
+type GeometryLineString = {
+  readonly type: 'LineString';
+  readonly coordinates: ReadonlyArray<Position>;
+  readonly srid?: number;
+};
+type GeometryPolygon = {
+  readonly type: 'Polygon';
+  readonly coordinates: ReadonlyArray<ReadonlyArray<Position>>;
+  readonly srid?: number;
+};
+type GeometryMultiPoint = {
+  readonly type: 'MultiPoint';
+  readonly coordinates: ReadonlyArray<Position>;
+  readonly srid?: number;
+};
+type GeometryMultiLineString = {
+  readonly type: 'MultiLineString';
+  readonly coordinates: ReadonlyArray<ReadonlyArray<Position>>;
+  readonly srid?: number;
+};
+type GeometryMultiPolygon = {
+  readonly type: 'MultiPolygon';
+  readonly coordinates: ReadonlyArray<ReadonlyArray<ReadonlyArray<Position>>>;
+  readonly srid?: number;
+};
+type Geometry = GeometryPoint | GeometryLineString | GeometryPolygon | GeometryMultiPoint | GeometryMultiLineString | GeometryMultiPolygon;
+/**
+ * Construct a Point. Convenience for the common "lng/lat" case.
+ *
+ * @example
+ *   point(-122.4194, 37.7749, 4326)
+ */
+declare function point(longitude: number, latitude: number, srid?: number): GeometryPoint;
+/**
+ * Construct a Polygon from a single outer ring of `[lng, lat]` pairs.
+ * If the first and last positions differ, the ring is closed automatically.
+ */
+declare function polygon(ring: ReadonlyArray<Position>, srid?: number): GeometryPolygon;
+/**
+ * Construct a rectangular Polygon from a bounding box.
+ *
+ * @param bbox - `[minLng, minLat, maxLng, maxLat]`
+ */
+declare function bboxPolygon(bbox: readonly [number, number, number, number], srid?: number): GeometryPolygon;
+//#endregion
+export { GeometryMultiPolygon as a, Position as c, polygon as d, GeometryMultiPoint as i, bboxPolygon as l, GeometryLineString as n, GeometryPoint as o, GeometryMultiLineString as r, GeometryPolygon as s, Geometry as t, point as u };
+//# sourceMappingURL=geojson-Cj4ldHQ0.d.mts.map

package/dist/geojson-Cj4ldHQ0.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geojson-Cj4ldHQ0.d.mts","names":[],"sources":["../src/core/geojson.ts"],"mappings":";;AAQA;;;;;AAEA;KAFY,QAAA;AAAA,KAEA,aAAA;EAAA,SACD,IAAA;EAAA,SACA,WAAA,EAAa,QAAA;EAAA,SACb,IAAA;AAAA;AAAA,KAGC,kBAAA;EAAA,SACD,IAAA;EAAA,SACA,WAAA,EAAa,aAAA,CAAc,QAAA;EAAA,SAC3B,IAAA;AAAA;AAAA,KAGC,eAAA;EAAA,SACD,IAAA;EAAA,SACA,WAAA,EAAa,aAAA,CAAc,aAAA,CAAc,QAAA;EAAA,SACzC,IAAA;AAAA;AAAA,KAGC,kBAAA;EAAA,SACD,IAAA;EAAA,SACA,WAAA,EAAa,aAAA,CAAc,QAAA;EAAA,SAC3B,IAAA;AAAA;AAAA,KAGC,uBAAA;EAAA,SACD,IAAA;EAAA,SACA,WAAA,EAAa,aAAA,CAAc,aAAA,CAAc,QAAA;EAAA,SACzC,IAAA;AAAA;AAAA,KAGC,oBAAA;EAAA,SACD,IAAA;EAAA,SACA,WAAA,EAAa,aAAA,CAAc,aAAA,CAAc,aAAA,CAAc,QAAA;EAAA,SACvD,IAAA;AAAA;AAAA,KAGC,QAAA,GACR,aAAA,GACA,kBAAA,GACA,eAAA,GACA,kBAAA,GACA,uBAAA,GACA,oBAAA;;;;;AAxBJ;;iBAgCgB,KAAA,CAAM,SAAA,UAAmB,QAAA,UAAkB,IAAA,YAAgB,aAAA;;;;;iBAa3D,OAAA,CAAQ,IAAA,EAAM,aAAA,CAAc,QAAA,GAAW,IAAA,YAAgB,eAAA;;;;AAvCvE;;iBAoEgB,WAAA,CACd,IAAA,6CACA,IAAA,YACC,eAAA"}

package/dist/geojson.d.mts

@@ -0,0 +1,2 @@
+import { a as GeometryMultiPolygon, c as Position, d as polygon, i as GeometryMultiPoint, l as bboxPolygon, n as GeometryLineString, o as GeometryPoint, r as GeometryMultiLineString, s as GeometryPolygon, t as Geometry, u as point } from "./geojson-Cj4ldHQ0.mjs";
+export { type Geometry, type GeometryLineString, type GeometryMultiLineString, type GeometryMultiPoint, type GeometryMultiPolygon, type GeometryPoint, type GeometryPolygon, type Position, bboxPolygon, point, polygon };