durcno 1.0.0-alpha.0

package/dist/src/wkx/parser.mjs

@@ -0,0 +1,183 @@
+import { BinaryReader } from "./binaryreader.mjs";
+import { ZigZag, init_zigzag } from "./zigzag.mjs";
+import { Geometry, init_geometry } from "./geometry.mjs";
+import { Types, init_types } from "./types.mjs";
+import { GeometryCollection } from "./geometrycollection.mjs";
+import { Point, init_point } from "./point.mjs";
+import { LineString } from "./linestring.mjs";
+import { MultiLineString } from "./multilinestring.mjs";
+import { MultiPoint } from "./multipoint.mjs";
+import { Polygon } from "./polygon.mjs";
+import { MultiPolygon } from "./multipolygon.mjs";
+import { WktParser } from "./wktparser.mjs";
+//#region src/wkx/parser.ts
+init_geometry();
+init_point();
+init_types();
+init_zigzag();
+function parse(value, options) {
+	if (typeof value === "string" || value instanceof WktParser) return parseWkt(value);
+	else if (Buffer.isBuffer(value) || value instanceof BinaryReader) return parseWkb(value, options);
+	else throw new Error("first argument must be a string or Buffer");
+}
+function parseWkt(value) {
+	let wktParser;
+	let srid;
+	if (value instanceof WktParser) wktParser = value;
+	else wktParser = new WktParser(value);
+	const match = wktParser.matchRegex([/^SRID=(\d+);/]);
+	if (match) srid = parseInt(match[1], 10);
+	const geometryType = wktParser.matchType();
+	const dimension = wktParser.matchDimension();
+	const options = {
+		srid,
+		hasZ: dimension.hasZ,
+		hasM: dimension.hasM
+	};
+	switch (geometryType) {
+		case Types.wkt.Point: return Point._parseWkt(wktParser, options);
+		case Types.wkt.LineString: return LineString._parseWkt(wktParser, options);
+		case Types.wkt.Polygon: return Polygon._parseWkt(wktParser, options);
+		case Types.wkt.MultiPoint: return MultiPoint._parseWkt(wktParser, options);
+		case Types.wkt.MultiLineString: return MultiLineString._parseWkt(wktParser, options);
+		case Types.wkt.MultiPolygon: return MultiPolygon._parseWkt(wktParser, options);
+		case Types.wkt.GeometryCollection: return GeometryCollection._parseWkt(wktParser, options);
+		default: throw new Error("GeometryType " + geometryType + " not supported");
+	}
+}
+function parseWkb(value, parentOptions) {
+	let binaryReader;
+	let wkbType;
+	let geometryType;
+	const options = {};
+	if (value instanceof BinaryReader) binaryReader = value;
+	else binaryReader = new BinaryReader(value);
+	binaryReader.isBigEndian = !binaryReader.readInt8();
+	wkbType = binaryReader.readUInt32();
+	options.hasSrid = (wkbType & 536870912) === 536870912;
+	options.isEwkb = !!(wkbType & 536870912) || !!(wkbType & 1073741824) || !!(wkbType & 2147483648);
+	if (options.hasSrid) options.srid = binaryReader.readUInt32();
+	options.hasZ = false;
+	options.hasM = false;
+	if (!options.isEwkb && (!parentOptions || !parentOptions.isEwkb)) if (wkbType >= 1e3 && wkbType < 2e3) {
+		options.hasZ = true;
+		geometryType = wkbType - 1e3;
+	} else if (wkbType >= 2e3 && wkbType < 3e3) {
+		options.hasM = true;
+		geometryType = wkbType - 2e3;
+	} else if (wkbType >= 3e3 && wkbType < 4e3) {
+		options.hasZ = true;
+		options.hasM = true;
+		geometryType = wkbType - 3e3;
+	} else geometryType = wkbType;
+	else {
+		if (wkbType & 2147483648) options.hasZ = true;
+		if (wkbType & 1073741824) options.hasM = true;
+		geometryType = wkbType & 15;
+	}
+	switch (geometryType) {
+		case Types.wkb.Point: return Point._parseWkb(binaryReader, options);
+		case Types.wkb.LineString: return LineString._parseWkb(binaryReader, options);
+		case Types.wkb.Polygon: return Polygon._parseWkb(binaryReader, options);
+		case Types.wkb.MultiPoint: return MultiPoint._parseWkb(binaryReader, options);
+		case Types.wkb.MultiLineString: return MultiLineString._parseWkb(binaryReader, options);
+		case Types.wkb.MultiPolygon: return MultiPolygon._parseWkb(binaryReader, options);
+		case Types.wkb.GeometryCollection: return GeometryCollection._parseWkb(binaryReader, options);
+		default: throw new Error("GeometryType " + geometryType + " not supported");
+	}
+}
+function parseTwkb(value) {
+	let binaryReader;
+	const options = {};
+	if (value instanceof BinaryReader) binaryReader = value;
+	else binaryReader = new BinaryReader(value);
+	const type = binaryReader.readUInt8();
+	const metadataHeader = binaryReader.readUInt8();
+	const geometryType = type & 15;
+	options.precision = ZigZag.decode(type >> 4);
+	options.precisionFactor = 10 ** options.precision;
+	options.hasBoundingBox = metadataHeader >> 0 & 1;
+	options.hasSizeAttribute = metadataHeader >> 1 & 1;
+	options.hasIdList = metadataHeader >> 2 & 1;
+	options.hasExtendedPrecision = metadataHeader >> 3 & 1;
+	options.isEmpty = metadataHeader >> 4 & 1;
+	if (options.hasExtendedPrecision) {
+		const extendedPrecision = binaryReader.readUInt8();
+		options.hasZ = (extendedPrecision & 1) === 1;
+		options.hasM = (extendedPrecision & 2) === 2;
+		options.zPrecision = ZigZag.decode((extendedPrecision & 28) >> 2);
+		options.zPrecisionFactor = 10 ** options.zPrecision;
+		options.mPrecision = ZigZag.decode((extendedPrecision & 224) >> 5);
+		options.mPrecisionFactor = 10 ** options.mPrecision;
+	} else {
+		options.hasZ = false;
+		options.hasM = false;
+	}
+	if (options.hasSizeAttribute) binaryReader.readVarInt();
+	if (options.hasBoundingBox) {
+		let dimensions = 2;
+		if (options.hasZ) dimensions++;
+		if (options.hasM) dimensions++;
+		for (let i = 0; i < dimensions; i++) {
+			binaryReader.readVarInt();
+			binaryReader.readVarInt();
+		}
+	}
+	switch (geometryType) {
+		case Types.wkb.Point: return Point._parseTwkb(binaryReader, options);
+		case Types.wkb.LineString: return LineString._parseTwkb(binaryReader, options);
+		case Types.wkb.Polygon: return Polygon._parseTwkb(binaryReader, options);
+		case Types.wkb.MultiPoint: return MultiPoint._parseTwkb(binaryReader, options);
+		case Types.wkb.MultiLineString: return MultiLineString._parseTwkb(binaryReader, options);
+		case Types.wkb.MultiPolygon: return MultiPolygon._parseTwkb(binaryReader, options);
+		case Types.wkb.GeometryCollection: return GeometryCollection._parseTwkb(binaryReader, options);
+		default: throw new Error("GeometryType " + geometryType + " not supported");
+	}
+}
+function parseGeoJSON(value) {
+	return parseGeoJSONInternal(value);
+}
+function parseGeoJSONInternal(value, isSubGeometry = false) {
+	let geometry;
+	const geometryType = value.type;
+	switch (geometryType) {
+		case Types.geoJSON.Point:
+			geometry = Point._parseGeoJSON(value);
+			break;
+		case Types.geoJSON.LineString:
+			geometry = LineString._parseGeoJSON(value);
+			break;
+		case Types.geoJSON.Polygon:
+			geometry = Polygon._parseGeoJSON(value);
+			break;
+		case Types.geoJSON.MultiPoint:
+			geometry = MultiPoint._parseGeoJSON(value);
+			break;
+		case Types.geoJSON.MultiLineString:
+			geometry = MultiLineString._parseGeoJSON(value);
+			break;
+		case Types.geoJSON.MultiPolygon:
+			geometry = MultiPolygon._parseGeoJSON(value);
+			break;
+		case Types.geoJSON.GeometryCollection:
+			geometry = GeometryCollection._parseGeoJSON(value);
+			break;
+		default: throw new Error("GeometryType " + geometryType + " not supported");
+	}
+	const valueWithCrs = value;
+	if (valueWithCrs.crs && valueWithCrs.crs.type && valueWithCrs.crs.type === "name" && valueWithCrs.crs.properties && valueWithCrs.crs.properties.name) {
+		const crs = valueWithCrs.crs.properties.name;
+		if (crs.indexOf("EPSG:") === 0) geometry.srid = parseInt(crs.substring(5));
+		else if (crs.indexOf("urn:ogc:def:crs:EPSG::") === 0) geometry.srid = parseInt(crs.substring(22));
+		else throw new Error("Unsupported crs: " + crs);
+	} else if (!isSubGeometry) geometry.srid = 4326;
+	return geometry;
+}
+Geometry.parse = parse;
+Geometry.parseTwkb = parseTwkb;
+Geometry.parseGeoJSON = parseGeoJSON;
+Geometry._parseWkt = parseWkt;
+Geometry._parseWkb = parseWkb;
+Geometry._parseGeoJSON = parseGeoJSONInternal;
+//#endregion
+export {};

package/dist/src/wkx/point.mjs

@@ -0,0 +1,159 @@
+import { __esmMin, __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { BinaryWriter, init_binarywriter } from "./binarywriter.mjs";
+import { ZigZag, init_zigzag } from "./zigzag.mjs";
+import { Geometry, init_geometry } from "./geometry.mjs";
+import { Types, init_types } from "./types.mjs";
+//#region src/wkx/point.ts
+var point_exports = /* @__PURE__ */ __exportAll({ Point: () => Point });
+var Point;
+var init_point = __esmMin((() => {
+	init_binarywriter();
+	init_geometry();
+	init_types();
+	init_zigzag();
+	Point = class Point extends Geometry {
+		x;
+		y;
+		z;
+		m;
+		constructor(x, y, z, m, srid) {
+			super();
+			this.x = x;
+			this.y = y;
+			this.z = z;
+			this.m = m;
+			this.srid = srid;
+			this.hasZ = z !== void 0;
+			this.hasM = m !== void 0;
+		}
+		static Z(x, y, z, srid) {
+			const point = new Point(x, y, z, void 0, srid);
+			point.hasZ = true;
+			return point;
+		}
+		static M(x, y, m, srid) {
+			const point = new Point(x, y, void 0, m, srid);
+			point.hasM = true;
+			return point;
+		}
+		static ZM(x, y, z, m, srid) {
+			const point = new Point(x, y, z, m, srid);
+			point.hasZ = true;
+			point.hasM = true;
+			return point;
+		}
+		static _parseWkt(value, options) {
+			const point = new Point();
+			point.srid = options.srid;
+			point.hasZ = options.hasZ;
+			point.hasM = options.hasM;
+			if (value.isMatch(["EMPTY"])) return point;
+			value.expectGroupStart();
+			const coordinate = value.matchCoordinate(options);
+			point.x = coordinate.x;
+			point.y = coordinate.y;
+			point.z = coordinate.z;
+			point.m = coordinate.m;
+			value.expectGroupEnd();
+			return point;
+		}
+		static _parseWkb(value, options) {
+			const point = Point._readWkbPoint(value, options);
+			point.srid = options.srid;
+			return point;
+		}
+		static _readWkbPoint(value, options) {
+			return new Point(value.readDouble(), value.readDouble(), options.hasZ ? value.readDouble() : void 0, options.hasM ? value.readDouble() : void 0);
+		}
+		static _parseTwkb(value, options) {
+			const point = new Point();
+			point.hasZ = options.hasZ || false;
+			point.hasM = options.hasM || false;
+			if (options.isEmpty) return point;
+			point.x = ZigZag.decode(value.readVarInt()) / (options.precisionFactor || 1);
+			point.y = ZigZag.decode(value.readVarInt()) / (options.precisionFactor || 1);
+			point.z = options.hasZ ? ZigZag.decode(value.readVarInt()) / (options.zPrecisionFactor || 1) : void 0;
+			point.m = options.hasM ? ZigZag.decode(value.readVarInt()) / (options.mPrecisionFactor || 1) : void 0;
+			return point;
+		}
+		static _readTwkbPoint(value, options, previousPoint) {
+			previousPoint.x = (previousPoint.x || 0) + ZigZag.decode(value.readVarInt()) / (options.precisionFactor || 1);
+			previousPoint.y = (previousPoint.y || 0) + ZigZag.decode(value.readVarInt()) / (options.precisionFactor || 1);
+			if (options.hasZ) previousPoint.z = (previousPoint.z || 0) + ZigZag.decode(value.readVarInt()) / (options.zPrecisionFactor || 1);
+			if (options.hasM) previousPoint.m = (previousPoint.m || 0) + ZigZag.decode(value.readVarInt()) / (options.mPrecisionFactor || 1);
+			return new Point(previousPoint.x, previousPoint.y, previousPoint.z, previousPoint.m);
+		}
+		static _parseGeoJSON(value) {
+			return Point._readGeoJSONPoint(value.coordinates);
+		}
+		static _readGeoJSONPoint(coordinates) {
+			if (coordinates.length === 0) return new Point();
+			return new Point(coordinates.at(0), coordinates.at(1), coordinates.at(2), coordinates.at(3));
+		}
+		toWkt() {
+			if (typeof this.x === "undefined" && typeof this.y === "undefined" && typeof this.z === "undefined" && typeof this.m === "undefined") return this._getWktType(Types.wkt.Point, true);
+			return this._getWktType(Types.wkt.Point, false) + "(" + this._getWktCoordinate(this) + ")";
+		}
+		toWkb(parentOptions) {
+			const wkb = new BinaryWriter(this._getWkbSize());
+			wkb.writeInt8(1);
+			this._writeWkbType(wkb, Types.wkb.Point, parentOptions);
+			if (typeof this.x === "undefined" && typeof this.y === "undefined") {
+				wkb.writeDoubleLE(NaN);
+				wkb.writeDoubleLE(NaN);
+				if (this.hasZ) wkb.writeDoubleLE(NaN);
+				if (this.hasM) wkb.writeDoubleLE(NaN);
+			} else this._writeWkbPoint(wkb);
+			return wkb.buffer;
+		}
+		_writeWkbPoint(wkb) {
+			wkb.writeDoubleLE(this.x);
+			wkb.writeDoubleLE(this.y);
+			if (this.hasZ) wkb.writeDoubleLE(this.z);
+			if (this.hasM) wkb.writeDoubleLE(this.m);
+		}
+		toTwkb() {
+			const twkb = new BinaryWriter(0, true);
+			const precision = Geometry.getTwkbPrecision(5, 0, 0);
+			const isEmpty = typeof this.x === "undefined" && typeof this.y === "undefined";
+			this._writeTwkbHeader(twkb, Types.wkb.Point, precision, isEmpty);
+			if (!isEmpty) this._writeTwkbPoint(twkb, precision, new Point(0, 0, 0, 0));
+			return twkb.buffer;
+		}
+		_writeTwkbPoint(twkb, precision, previousPoint) {
+			const x = (this.x || 0) * precision.xyFactor;
+			const y = (this.y || 0) * precision.xyFactor;
+			const z = (this.z || 0) * precision.zFactor;
+			const m = (this.m || 0) * precision.mFactor;
+			twkb.writeVarInt(ZigZag.encode(x - (previousPoint.x || 0)));
+			twkb.writeVarInt(ZigZag.encode(y - (previousPoint.y || 0)));
+			if (this.hasZ) twkb.writeVarInt(ZigZag.encode(z - (previousPoint.z || 0)));
+			if (this.hasM) twkb.writeVarInt(ZigZag.encode(m - (previousPoint.m || 0)));
+			previousPoint.x = x;
+			previousPoint.y = y;
+			previousPoint.z = z;
+			previousPoint.m = m;
+		}
+		_getWkbSize() {
+			let size = 21;
+			if (this.hasZ) size += 8;
+			if (this.hasM) size += 8;
+			return size;
+		}
+		toGeoJSON(options) {
+			const geoJSON = super.toGeoJSON(options);
+			geoJSON.type = Types.geoJSON.Point;
+			if (typeof this.x === "undefined" && typeof this.y === "undefined") geoJSON.coordinates = [];
+			else if (typeof this.z !== "undefined") geoJSON.coordinates = [
+				this.x,
+				this.y,
+				this.z
+			];
+			else geoJSON.coordinates = [this.x, this.y];
+			return geoJSON;
+		}
+	};
+}));
+//#endregion
+init_point();
+export { Point, init_point, point_exports };

package/dist/src/wkx/polygon.mjs

@@ -0,0 +1,189 @@
+import { BinaryWriter, init_binarywriter } from "./binarywriter.mjs";
+import { Geometry, init_geometry } from "./geometry.mjs";
+import { Types, init_types } from "./types.mjs";
+import { Point, init_point } from "./point.mjs";
+//#region src/wkx/polygon.ts
+init_binarywriter();
+init_geometry();
+init_point();
+init_types();
+var Polygon = class Polygon extends Geometry {
+	exteriorRing;
+	interiorRings;
+	constructor(exteriorRing, interiorRings, srid) {
+		super();
+		this.exteriorRing = exteriorRing || [];
+		this.interiorRings = interiorRings || [];
+		this.srid = srid;
+		if (this.exteriorRing.length > 0) {
+			this.hasZ = this.exteriorRing[0].hasZ;
+			this.hasM = this.exteriorRing[0].hasM;
+		}
+	}
+	static Z(exteriorRing, interiorRings, srid) {
+		const polygon = new Polygon(exteriorRing, interiorRings, srid);
+		polygon.hasZ = true;
+		return polygon;
+	}
+	static M(exteriorRing, interiorRings, srid) {
+		const polygon = new Polygon(exteriorRing, interiorRings, srid);
+		polygon.hasM = true;
+		return polygon;
+	}
+	static ZM(exteriorRing, interiorRings, srid) {
+		const polygon = new Polygon(exteriorRing, interiorRings, srid);
+		polygon.hasZ = true;
+		polygon.hasM = true;
+		return polygon;
+	}
+	static _parseWkt(value, options) {
+		const polygon = new Polygon();
+		polygon.srid = options.srid;
+		polygon.hasZ = options.hasZ;
+		polygon.hasM = options.hasM;
+		if (value.isMatch(["EMPTY"])) return polygon;
+		value.expectGroupStart();
+		value.expectGroupStart();
+		polygon.exteriorRing = polygon.exteriorRing.concat(value.matchCoordinates(options));
+		value.expectGroupEnd();
+		while (value.isMatch([","])) {
+			value.expectGroupStart();
+			polygon.interiorRings.push(value.matchCoordinates(options));
+			value.expectGroupEnd();
+		}
+		value.expectGroupEnd();
+		return polygon;
+	}
+	static _parseWkb(value, options) {
+		const polygon = new Polygon();
+		polygon.srid = options.srid;
+		polygon.hasZ = options.hasZ || false;
+		polygon.hasM = options.hasM || false;
+		const ringCount = value.readUInt32();
+		if (ringCount > 0) {
+			const exteriorRingCount = value.readUInt32();
+			for (let i = 0; i < exteriorRingCount; i++) polygon.exteriorRing.push(Point._readWkbPoint(value, options));
+			for (let i = 1; i < ringCount; i++) {
+				const interiorRing = [];
+				const interiorRingCount = value.readUInt32();
+				for (let j = 0; j < interiorRingCount; j++) interiorRing.push(Point._readWkbPoint(value, options));
+				polygon.interiorRings.push(interiorRing);
+			}
+		}
+		return polygon;
+	}
+	static _parseTwkb(value, options) {
+		const polygon = new Polygon();
+		polygon.hasZ = options.hasZ || false;
+		polygon.hasM = options.hasM || false;
+		if (options.isEmpty) return polygon;
+		const previousPoint = new Point(0, 0, options.hasZ ? 0 : void 0, options.hasM ? 0 : void 0);
+		const ringCount = value.readVarInt();
+		const exteriorRingCount = value.readVarInt();
+		for (let i = 0; i < exteriorRingCount; i++) polygon.exteriorRing.push(Point._readTwkbPoint(value, options, previousPoint));
+		for (let i = 1; i < ringCount; i++) {
+			const interiorRing = [];
+			const interiorRingCount = value.readVarInt();
+			for (let j = 0; j < interiorRingCount; j++) interiorRing.push(Point._readTwkbPoint(value, options, previousPoint));
+			polygon.interiorRings.push(interiorRing);
+		}
+		return polygon;
+	}
+	static _parseGeoJSON(value) {
+		const polygon = new Polygon();
+		if (value.coordinates.length > 0 && value.coordinates[0].length > 0) polygon.hasZ = value.coordinates[0][0].length > 2;
+		for (let i = 0; i < value.coordinates.length; i++) {
+			if (i > 0) polygon.interiorRings.push([]);
+			for (let j = 0; j < value.coordinates[i].length; j++) if (i === 0) polygon.exteriorRing.push(Point._readGeoJSONPoint(value.coordinates[i][j]));
+			else polygon.interiorRings[i - 1].push(Point._readGeoJSONPoint(value.coordinates[i][j]));
+		}
+		return polygon;
+	}
+	toWkt() {
+		if (this.exteriorRing.length === 0) return this._getWktType(Types.wkt.Polygon, true);
+		return this._getWktType(Types.wkt.Polygon, false) + this._toInnerWkt();
+	}
+	_toInnerWkt() {
+		let innerWkt = "((";
+		for (let i = 0; i < this.exteriorRing.length; i++) innerWkt += this._getWktCoordinate(this.exteriorRing[i]) + ",";
+		innerWkt = innerWkt.slice(0, -1);
+		innerWkt += ")";
+		for (let i = 0; i < this.interiorRings.length; i++) {
+			innerWkt += ",(";
+			for (let j = 0; j < this.interiorRings[i].length; j++) innerWkt += this._getWktCoordinate(this.interiorRings[i][j]) + ",";
+			innerWkt = innerWkt.slice(0, -1);
+			innerWkt += ")";
+		}
+		innerWkt += ")";
+		return innerWkt;
+	}
+	toWkb(parentOptions) {
+		const wkb = new BinaryWriter(this._getWkbSize());
+		wkb.writeInt8(1);
+		this._writeWkbType(wkb, Types.wkb.Polygon, parentOptions);
+		if (this.exteriorRing.length > 0) {
+			wkb.writeUInt32LE(1 + this.interiorRings.length);
+			wkb.writeUInt32LE(this.exteriorRing.length);
+		} else wkb.writeUInt32LE(0);
+		for (let i = 0; i < this.exteriorRing.length; i++) this.exteriorRing[i]._writeWkbPoint(wkb);
+		for (let i = 0; i < this.interiorRings.length; i++) {
+			wkb.writeUInt32LE(this.interiorRings[i].length);
+			for (let j = 0; j < this.interiorRings[i].length; j++) this.interiorRings[i][j]._writeWkbPoint(wkb);
+		}
+		return wkb.buffer;
+	}
+	toTwkb() {
+		const twkb = new BinaryWriter(0, true);
+		const precision = Geometry.getTwkbPrecision(5, 0, 0);
+		const isEmpty = this.exteriorRing.length === 0;
+		this._writeTwkbHeader(twkb, Types.wkb.Polygon, precision, isEmpty);
+		if (this.exteriorRing.length > 0) {
+			twkb.writeVarInt(1 + this.interiorRings.length);
+			twkb.writeVarInt(this.exteriorRing.length);
+			const previousPoint = new Point(0, 0, 0, 0);
+			for (let i = 0; i < this.exteriorRing.length; i++) this.exteriorRing[i]._writeTwkbPoint(twkb, precision, previousPoint);
+			for (let i = 0; i < this.interiorRings.length; i++) {
+				twkb.writeVarInt(this.interiorRings[i].length);
+				for (let j = 0; j < this.interiorRings[i].length; j++) this.interiorRings[i][j]._writeTwkbPoint(twkb, precision, previousPoint);
+			}
+		}
+		return twkb.buffer;
+	}
+	_getWkbSize() {
+		let coordinateSize = 16;
+		if (this.hasZ) coordinateSize += 8;
+		if (this.hasM) coordinateSize += 8;
+		let size = 9;
+		if (this.exteriorRing.length > 0) size += 4 + this.exteriorRing.length * coordinateSize;
+		for (let i = 0; i < this.interiorRings.length; i++) size += 4 + this.interiorRings[i].length * coordinateSize;
+		return size;
+	}
+	toGeoJSON(options) {
+		const geoJSON = super.toGeoJSON(options);
+		geoJSON.type = Types.geoJSON.Polygon;
+		geoJSON.coordinates = [];
+		if (this.exteriorRing.length > 0) {
+			const exteriorRing = [];
+			for (let i = 0; i < this.exteriorRing.length; i++) if (this.hasZ) exteriorRing.push([
+				this.exteriorRing[i].x,
+				this.exteriorRing[i].y,
+				this.exteriorRing[i].z
+			]);
+			else exteriorRing.push([this.exteriorRing[i].x, this.exteriorRing[i].y]);
+			geoJSON.coordinates.push(exteriorRing);
+		}
+		for (let j = 0; j < this.interiorRings.length; j++) {
+			const interiorRing = [];
+			for (let k = 0; k < this.interiorRings[j].length; k++) if (this.hasZ) interiorRing.push([
+				this.interiorRings[j][k].x,
+				this.interiorRings[j][k].y,
+				this.interiorRings[j][k].z
+			]);
+			else interiorRing.push([this.interiorRings[j][k].x, this.interiorRings[j][k].y]);
+			geoJSON.coordinates.push(interiorRing);
+		}
+		return geoJSON;
+	}
+};
+//#endregion
+export { Polygon };

package/dist/src/wkx/types.mjs

@@ -0,0 +1,37 @@
+import { __esmMin } from "../_virtual/_rolldown/runtime.mjs";
+//#region src/wkx/types.ts
+var Types;
+var init_types = __esmMin((() => {
+	Types = {
+		wkt: {
+			Point: "POINT",
+			LineString: "LINESTRING",
+			Polygon: "POLYGON",
+			MultiPoint: "MULTIPOINT",
+			MultiLineString: "MULTILINESTRING",
+			MultiPolygon: "MULTIPOLYGON",
+			GeometryCollection: "GEOMETRYCOLLECTION"
+		},
+		wkb: {
+			Point: 1,
+			LineString: 2,
+			Polygon: 3,
+			MultiPoint: 4,
+			MultiLineString: 5,
+			MultiPolygon: 6,
+			GeometryCollection: 7
+		},
+		geoJSON: {
+			Point: "Point",
+			LineString: "LineString",
+			Polygon: "Polygon",
+			MultiPoint: "MultiPoint",
+			MultiLineString: "MultiLineString",
+			MultiPolygon: "MultiPolygon",
+			GeometryCollection: "GeometryCollection"
+		}
+	};
+}));
+//#endregion
+init_types();
+export { Types, init_types };

package/dist/src/wkx/wktparser.mjs

@@ -0,0 +1,109 @@
+import { __toCommonJS } from "../_virtual/_rolldown/runtime.mjs";
+import { Types, init_types } from "./types.mjs";
+import { init_point, point_exports } from "./point.mjs";
+//#region src/wkx/wktparser.ts
+init_types();
+var WktParser = class {
+	value;
+	position;
+	constructor(value) {
+		this.value = value;
+		this.position = 0;
+	}
+	match(tokens) {
+		this.skipWhitespaces();
+		for (let i = 0; i < tokens.length; i++) if (this.value.substring(this.position).indexOf(tokens[i]) === 0) {
+			this.position += tokens[i].length;
+			return tokens[i];
+		}
+		return null;
+	}
+	matchRegex(tokens) {
+		this.skipWhitespaces();
+		for (let i = 0; i < tokens.length; i++) {
+			const match = this.value.substring(this.position).match(tokens[i]);
+			if (match) {
+				this.position += match[0].length;
+				return match;
+			}
+		}
+		return null;
+	}
+	isMatch(tokens) {
+		this.skipWhitespaces();
+		for (let i = 0; i < tokens.length; i++) if (this.value.substring(this.position).indexOf(tokens[i]) === 0) {
+			this.position += tokens[i].length;
+			return true;
+		}
+		return false;
+	}
+	matchType() {
+		const geometryType = this.match([
+			Types.wkt.Point,
+			Types.wkt.LineString,
+			Types.wkt.Polygon,
+			Types.wkt.MultiPoint,
+			Types.wkt.MultiLineString,
+			Types.wkt.MultiPolygon,
+			Types.wkt.GeometryCollection
+		]);
+		if (!geometryType) throw new Error("Expected geometry type");
+		return geometryType;
+	}
+	matchDimension() {
+		switch (this.match([
+			"ZM",
+			"Z",
+			"M"
+		])) {
+			case "ZM": return {
+				hasZ: true,
+				hasM: true
+			};
+			case "Z": return {
+				hasZ: true,
+				hasM: false
+			};
+			case "M": return {
+				hasZ: false,
+				hasM: true
+			};
+			default: return {
+				hasZ: false,
+				hasM: false
+			};
+		}
+	}
+	expectGroupStart() {
+		if (!this.isMatch(["("])) throw new Error("Expected group start");
+	}
+	expectGroupEnd() {
+		if (!this.isMatch([")"])) throw new Error("Expected group end");
+	}
+	matchCoordinate(options) {
+		const { Point } = (init_point(), __toCommonJS(point_exports));
+		let match;
+		if (options.hasZ && options.hasM) match = this.matchRegex([/^(\S*)\s+(\S*)\s+(\S*)\s+([^\s,)]*)/]);
+		else if (options.hasZ || options.hasM) match = this.matchRegex([/^(\S*)\s+(\S*)\s+([^\s,)]*)/]);
+		else match = this.matchRegex([/^(\S*)\s+([^\s,)]*)/]);
+		if (!match) throw new Error("Expected coordinates");
+		if (options.hasZ && options.hasM) return new Point(parseFloat(match[1]), parseFloat(match[2]), parseFloat(match[3]), parseFloat(match[4]));
+		else if (options.hasZ) return new Point(parseFloat(match[1]), parseFloat(match[2]), parseFloat(match[3]));
+		else if (options.hasM) return new Point(parseFloat(match[1]), parseFloat(match[2]), void 0, parseFloat(match[3]));
+		else return new Point(parseFloat(match[1]), parseFloat(match[2]));
+	}
+	matchCoordinates(options) {
+		const coordinates = [];
+		do {
+			const startsWithBracket = this.isMatch(["("]);
+			coordinates.push(this.matchCoordinate(options));
+			if (startsWithBracket) this.expectGroupEnd();
+		} while (this.isMatch([","]));
+		return coordinates;
+	}
+	skipWhitespaces() {
+		while (this.position < this.value.length && this.value[this.position] === " ") this.position++;
+	}
+};
+//#endregion
+export { WktParser };

package/dist/src/wkx/zigzag.mjs

@@ -0,0 +1,18 @@
+import { __esmMin } from "../_virtual/_rolldown/runtime.mjs";
+//#region src/wkx/zigzag.ts
+function encode(value) {
+	return value << 1 ^ value >> 31;
+}
+function decode(value) {
+	return value >> 1 ^ -(value & 1);
+}
+var ZigZag;
+var init_zigzag = __esmMin((() => {
+	ZigZag = {
+		encode,
+		decode
+	};
+}));
+//#endregion
+init_zigzag();
+export { ZigZag, init_zigzag };