durcno 1.0.0-alpha.0

package/dist/src/wkx/geometrycollection.mjs

@@ -0,0 +1,113 @@
+import { BinaryWriter, init_binarywriter } from "./binarywriter.mjs";
+import { Geometry, init_geometry } from "./geometry.mjs";
+import { Types, init_types } from "./types.mjs";
+//#region src/wkx/geometrycollection.ts
+init_geometry();
+init_types();
+init_binarywriter();
+var GeometryCollection = class GeometryCollection extends Geometry {
+	geometries;
+	constructor(geometries, srid) {
+		super();
+		this.geometries = geometries || [];
+		this.srid = srid;
+		if (this.geometries.length > 0) {
+			this.hasZ = this.geometries[0].hasZ;
+			this.hasM = this.geometries[0].hasM;
+		}
+	}
+	static Z(geometries, srid) {
+		const geometryCollection = new GeometryCollection(geometries, srid);
+		geometryCollection.hasZ = true;
+		return geometryCollection;
+	}
+	static M(geometries, srid) {
+		const geometryCollection = new GeometryCollection(geometries, srid);
+		geometryCollection.hasM = true;
+		return geometryCollection;
+	}
+	static ZM(geometries, srid) {
+		const geometryCollection = new GeometryCollection(geometries, srid);
+		geometryCollection.hasZ = true;
+		geometryCollection.hasM = true;
+		return geometryCollection;
+	}
+	static _parseWkt(value, options) {
+		const geometryCollection = new GeometryCollection();
+		geometryCollection.srid = options.srid;
+		geometryCollection.hasZ = options.hasZ;
+		geometryCollection.hasM = options.hasM;
+		if (value.isMatch(["EMPTY"])) return geometryCollection;
+		value.expectGroupStart();
+		do
+			geometryCollection.geometries.push(Geometry.parse(value));
+		while (value.isMatch([","]));
+		value.expectGroupEnd();
+		return geometryCollection;
+	}
+	static _parseWkb(value, options) {
+		const geometryCollection = new GeometryCollection();
+		geometryCollection.srid = options.srid;
+		geometryCollection.hasZ = options.hasZ || false;
+		geometryCollection.hasM = options.hasM || false;
+		const geometryCount = value.readUInt32();
+		for (let i = 0; i < geometryCount; i++) geometryCollection.geometries.push(Geometry.parse(value, options));
+		return geometryCollection;
+	}
+	static _parseTwkb(value, options) {
+		const geometryCollection = new GeometryCollection();
+		geometryCollection.hasZ = options.hasZ || false;
+		geometryCollection.hasM = options.hasM || false;
+		if (options.isEmpty) return geometryCollection;
+		const geometryCount = value.readVarInt();
+		for (let i = 0; i < geometryCount; i++) geometryCollection.geometries.push(Geometry.parseTwkb(value));
+		return geometryCollection;
+	}
+	static _parseGeoJSON(value) {
+		const geometryCollection = new GeometryCollection();
+		for (let i = 0; i < value.geometries.length; i++) geometryCollection.geometries.push(Geometry._parseGeoJSON(value.geometries[i], true));
+		if (geometryCollection.geometries.length > 0) geometryCollection.hasZ = geometryCollection.geometries[0].hasZ;
+		return geometryCollection;
+	}
+	toWkt() {
+		if (this.geometries.length === 0) return this._getWktType(Types.wkt.GeometryCollection, true);
+		let wkt = this._getWktType(Types.wkt.GeometryCollection, false) + "(";
+		for (let i = 0; i < this.geometries.length; i++) wkt += this.geometries[i].toWkt() + ",";
+		wkt = wkt.slice(0, -1);
+		wkt += ")";
+		return wkt;
+	}
+	toWkb() {
+		const wkb = new BinaryWriter(this._getWkbSize());
+		wkb.writeInt8(1);
+		this._writeWkbType(wkb, Types.wkb.GeometryCollection);
+		wkb.writeUInt32LE(this.geometries.length);
+		for (let i = 0; i < this.geometries.length; i++) wkb.writeBuffer(this.geometries[i].toWkb({ srid: this.srid }));
+		return wkb.buffer;
+	}
+	toTwkb() {
+		const twkb = new BinaryWriter(0, true);
+		const precision = Geometry.getTwkbPrecision(5, 0, 0);
+		const isEmpty = this.geometries.length === 0;
+		this._writeTwkbHeader(twkb, Types.wkb.GeometryCollection, precision, isEmpty);
+		if (this.geometries.length > 0) {
+			twkb.writeVarInt(this.geometries.length);
+			for (let i = 0; i < this.geometries.length; i++) twkb.writeBuffer(this.geometries[i].toTwkb());
+		}
+		return twkb.buffer;
+	}
+	_getWkbSize() {
+		let size = 9;
+		for (let i = 0; i < this.geometries.length; i++) size += this.geometries[i]._getWkbSize();
+		return size;
+	}
+	toGeoJSON(options) {
+		const geoJSON = super.toGeoJSON(options);
+		geoJSON.type = Types.geoJSON.GeometryCollection;
+		geoJSON.geometries = [];
+		for (let i = 0; i < this.geometries.length; i++) geoJSON.geometries.push(this.geometries[i].toGeoJSON());
+		return geoJSON;
+	}
+};
+//#endregion
+export { GeometryCollection };

package/dist/src/wkx/index.mjs

@@ -0,0 +1,18 @@
+import "./binaryreader.mjs";
+import "./binarywriter.mjs";
+import "./zigzag.mjs";
+import "./geometry.mjs";
+import "./types.mjs";
+import "./geometrycollection.mjs";
+import { init_point } from "./point.mjs";
+import "./linestring.mjs";
+import "./multilinestring.mjs";
+import "./multipoint.mjs";
+import "./polygon.mjs";
+import "./multipolygon.mjs";
+import "./wktparser.mjs";
+import "./parser.mjs";
+//#region src/wkx/index.ts
+init_point();
+//#endregion
+export {};

package/dist/src/wkx/linestring.mjs

@@ -0,0 +1,124 @@
+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/linestring.ts
+init_binarywriter();
+init_geometry();
+init_point();
+init_types();
+var LineString = class LineString extends Geometry {
+	points;
+	constructor(points, srid) {
+		super();
+		this.points = points || [];
+		this.srid = srid;
+		if (this.points.length > 0) {
+			this.hasZ = this.points[0].hasZ;
+			this.hasM = this.points[0].hasM;
+		}
+	}
+	static Z(points, srid) {
+		const lineString = new LineString(points, srid);
+		lineString.hasZ = true;
+		return lineString;
+	}
+	static M(points, srid) {
+		const lineString = new LineString(points, srid);
+		lineString.hasM = true;
+		return lineString;
+	}
+	static ZM(points, srid) {
+		const lineString = new LineString(points, srid);
+		lineString.hasZ = true;
+		lineString.hasM = true;
+		return lineString;
+	}
+	static _parseWkt(value, options) {
+		const lineString = new LineString();
+		lineString.srid = options.srid;
+		lineString.hasZ = options.hasZ;
+		lineString.hasM = options.hasM;
+		if (value.isMatch(["EMPTY"])) return lineString;
+		value.expectGroupStart();
+		lineString.points = lineString.points.concat(value.matchCoordinates(options));
+		value.expectGroupEnd();
+		return lineString;
+	}
+	static _parseWkb(value, options) {
+		const lineString = new LineString();
+		lineString.srid = options.srid;
+		lineString.hasZ = options.hasZ || false;
+		lineString.hasM = options.hasM || false;
+		const pointCount = value.readUInt32();
+		for (let i = 0; i < pointCount; i++) lineString.points.push(Point._readWkbPoint(value, options));
+		return lineString;
+	}
+	static _parseTwkb(value, options) {
+		const lineString = new LineString();
+		lineString.hasZ = options.hasZ || false;
+		lineString.hasM = options.hasM || false;
+		if (options.isEmpty) return lineString;
+		const previousPoint = new Point(0, 0, options.hasZ ? 0 : void 0, options.hasM ? 0 : void 0);
+		const pointCount = value.readVarInt();
+		for (let i = 0; i < pointCount; i++) lineString.points.push(Point._readTwkbPoint(value, options, previousPoint));
+		return lineString;
+	}
+	static _parseGeoJSON(value) {
+		const lineString = new LineString();
+		if (value.coordinates.length > 0) lineString.hasZ = value.coordinates[0].length > 2;
+		for (let i = 0; i < value.coordinates.length; i++) lineString.points.push(Point._readGeoJSONPoint(value.coordinates[i]));
+		return lineString;
+	}
+	toWkt() {
+		if (this.points.length === 0) return this._getWktType(Types.wkt.LineString, true);
+		return this._getWktType(Types.wkt.LineString, false) + this._toInnerWkt();
+	}
+	_toInnerWkt() {
+		let innerWkt = "(";
+		for (let i = 0; i < this.points.length; i++) innerWkt += this._getWktCoordinate(this.points[i]) + ",";
+		innerWkt = innerWkt.slice(0, -1);
+		innerWkt += ")";
+		return innerWkt;
+	}
+	toWkb(parentOptions) {
+		const wkb = new BinaryWriter(this._getWkbSize());
+		wkb.writeInt8(1);
+		this._writeWkbType(wkb, Types.wkb.LineString, parentOptions);
+		wkb.writeUInt32LE(this.points.length);
+		for (let i = 0; i < this.points.length; i++) this.points[i]._writeWkbPoint(wkb);
+		return wkb.buffer;
+	}
+	toTwkb() {
+		const twkb = new BinaryWriter(0, true);
+		const precision = Geometry.getTwkbPrecision(5, 0, 0);
+		const isEmpty = this.points.length === 0;
+		this._writeTwkbHeader(twkb, Types.wkb.LineString, precision, isEmpty);
+		if (this.points.length > 0) {
+			twkb.writeVarInt(this.points.length);
+			const previousPoint = new Point(0, 0, 0, 0);
+			for (let i = 0; i < this.points.length; i++) this.points[i]._writeTwkbPoint(twkb, precision, previousPoint);
+		}
+		return twkb.buffer;
+	}
+	_getWkbSize() {
+		let coordinateSize = 16;
+		if (this.hasZ) coordinateSize += 8;
+		if (this.hasM) coordinateSize += 8;
+		return 9 + this.points.length * coordinateSize;
+	}
+	toGeoJSON(options) {
+		const geoJSON = super.toGeoJSON(options);
+		geoJSON.type = Types.geoJSON.LineString;
+		geoJSON.coordinates = [];
+		for (let i = 0; i < this.points.length; i++) if (this.hasZ) geoJSON.coordinates.push([
+			this.points[i].x,
+			this.points[i].y,
+			this.points[i].z
+		]);
+		else geoJSON.coordinates.push([this.points[i].x, this.points[i].y]);
+		return geoJSON;
+	}
+};
+//#endregion
+export { LineString };

package/dist/src/wkx/multilinestring.mjs

@@ -0,0 +1,133 @@
+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";
+import { LineString } from "./linestring.mjs";
+//#region src/wkx/multilinestring.ts
+init_geometry();
+init_types();
+init_point();
+init_binarywriter();
+var MultiLineString = class MultiLineString extends Geometry {
+	lineStrings;
+	constructor(lineStrings, srid) {
+		super();
+		this.lineStrings = lineStrings || [];
+		this.srid = srid;
+		if (this.lineStrings.length > 0) {
+			this.hasZ = this.lineStrings[0].hasZ;
+			this.hasM = this.lineStrings[0].hasM;
+		}
+	}
+	static Z(lineStrings, srid) {
+		const multiLineString = new MultiLineString(lineStrings, srid);
+		multiLineString.hasZ = true;
+		return multiLineString;
+	}
+	static M(lineStrings, srid) {
+		const multiLineString = new MultiLineString(lineStrings, srid);
+		multiLineString.hasM = true;
+		return multiLineString;
+	}
+	static ZM(lineStrings, srid) {
+		const multiLineString = new MultiLineString(lineStrings, srid);
+		multiLineString.hasZ = true;
+		multiLineString.hasM = true;
+		return multiLineString;
+	}
+	static _parseWkt(value, options) {
+		const multiLineString = new MultiLineString();
+		multiLineString.srid = options.srid;
+		multiLineString.hasZ = options.hasZ;
+		multiLineString.hasM = options.hasM;
+		if (value.isMatch(["EMPTY"])) return multiLineString;
+		value.expectGroupStart();
+		do {
+			value.expectGroupStart();
+			multiLineString.lineStrings.push(new LineString(value.matchCoordinates(options)));
+			value.expectGroupEnd();
+		} while (value.isMatch([","]));
+		value.expectGroupEnd();
+		return multiLineString;
+	}
+	static _parseWkb(value, options) {
+		const multiLineString = new MultiLineString();
+		multiLineString.srid = options.srid;
+		multiLineString.hasZ = options.hasZ || false;
+		multiLineString.hasM = options.hasM || false;
+		const lineStringCount = value.readUInt32();
+		for (let i = 0; i < lineStringCount; i++) multiLineString.lineStrings.push(Geometry.parse(value, options));
+		return multiLineString;
+	}
+	static _parseTwkb(value, options) {
+		const multiLineString = new MultiLineString();
+		multiLineString.hasZ = options.hasZ || false;
+		multiLineString.hasM = options.hasM || false;
+		if (options.isEmpty) return multiLineString;
+		const previousPoint = new Point(0, 0, options.hasZ ? 0 : void 0, options.hasM ? 0 : void 0);
+		const lineStringCount = value.readVarInt();
+		for (let i = 0; i < lineStringCount; i++) {
+			const lineString = new LineString();
+			lineString.hasZ = options.hasZ || false;
+			lineString.hasM = options.hasM || false;
+			const pointCount = value.readVarInt();
+			for (let j = 0; j < pointCount; j++) lineString.points.push(Point._readTwkbPoint(value, options, previousPoint));
+			multiLineString.lineStrings.push(lineString);
+		}
+		return multiLineString;
+	}
+	static _parseGeoJSON(value) {
+		const multiLineString = new MultiLineString();
+		if (value.coordinates.length > 0 && value.coordinates[0].length > 0) multiLineString.hasZ = value.coordinates[0][0].length > 2;
+		for (let i = 0; i < value.coordinates.length; i++) multiLineString.lineStrings.push(LineString._parseGeoJSON({
+			type: "LineString",
+			coordinates: value.coordinates[i]
+		}));
+		return multiLineString;
+	}
+	toWkt() {
+		if (this.lineStrings.length === 0) return this._getWktType(Types.wkt.MultiLineString, true);
+		let wkt = this._getWktType(Types.wkt.MultiLineString, false) + "(";
+		for (let i = 0; i < this.lineStrings.length; i++) wkt += this.lineStrings[i]._toInnerWkt() + ",";
+		wkt = wkt.slice(0, -1);
+		wkt += ")";
+		return wkt;
+	}
+	toWkb() {
+		const wkb = new BinaryWriter(this._getWkbSize());
+		wkb.writeInt8(1);
+		this._writeWkbType(wkb, Types.wkb.MultiLineString);
+		wkb.writeUInt32LE(this.lineStrings.length);
+		for (let i = 0; i < this.lineStrings.length; i++) wkb.writeBuffer(this.lineStrings[i].toWkb({ srid: this.srid }));
+		return wkb.buffer;
+	}
+	toTwkb() {
+		const twkb = new BinaryWriter(0, true);
+		const precision = Geometry.getTwkbPrecision(5, 0, 0);
+		const isEmpty = this.lineStrings.length === 0;
+		this._writeTwkbHeader(twkb, Types.wkb.MultiLineString, precision, isEmpty);
+		if (this.lineStrings.length > 0) {
+			twkb.writeVarInt(this.lineStrings.length);
+			const previousPoint = new Point(0, 0, 0, 0);
+			for (let i = 0; i < this.lineStrings.length; i++) {
+				twkb.writeVarInt(this.lineStrings[i].points.length);
+				for (let j = 0; j < this.lineStrings[i].points.length; j++) this.lineStrings[i].points[j]._writeTwkbPoint(twkb, precision, previousPoint);
+			}
+		}
+		return twkb.buffer;
+	}
+	_getWkbSize() {
+		let size = 9;
+		for (let i = 0; i < this.lineStrings.length; i++) size += this.lineStrings[i]._getWkbSize();
+		return size;
+	}
+	toGeoJSON(options) {
+		const geoJSON = super.toGeoJSON(options);
+		geoJSON.type = Types.geoJSON.MultiLineString;
+		geoJSON.coordinates = [];
+		for (let i = 0; i < this.lineStrings.length; i++) geoJSON.coordinates.push(this.lineStrings[i].toGeoJSON().coordinates);
+		return geoJSON;
+	}
+};
+//#endregion
+export { MultiLineString };

package/dist/src/wkx/multipoint.mjs

@@ -0,0 +1,120 @@
+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/multipoint.ts
+init_geometry();
+init_types();
+init_point();
+init_binarywriter();
+var MultiPoint = class MultiPoint extends Geometry {
+	points;
+	constructor(points, srid) {
+		super();
+		this.points = points || [];
+		this.srid = srid;
+		if (this.points.length > 0) {
+			this.hasZ = this.points[0].hasZ;
+			this.hasM = this.points[0].hasM;
+		}
+	}
+	static Z(points, srid) {
+		const multiPoint = new MultiPoint(points, srid);
+		multiPoint.hasZ = true;
+		return multiPoint;
+	}
+	static M(points, srid) {
+		const multiPoint = new MultiPoint(points, srid);
+		multiPoint.hasM = true;
+		return multiPoint;
+	}
+	static ZM(points, srid) {
+		const multiPoint = new MultiPoint(points, srid);
+		multiPoint.hasZ = true;
+		multiPoint.hasM = true;
+		return multiPoint;
+	}
+	static _parseWkt(value, options) {
+		const multiPoint = new MultiPoint();
+		multiPoint.srid = options.srid;
+		multiPoint.hasZ = options.hasZ;
+		multiPoint.hasM = options.hasM;
+		if (value.isMatch(["EMPTY"])) return multiPoint;
+		value.expectGroupStart();
+		multiPoint.points = multiPoint.points.concat(value.matchCoordinates(options));
+		value.expectGroupEnd();
+		return multiPoint;
+	}
+	static _parseWkb(value, options) {
+		const multiPoint = new MultiPoint();
+		multiPoint.srid = options.srid;
+		multiPoint.hasZ = options.hasZ || false;
+		multiPoint.hasM = options.hasM || false;
+		const pointCount = value.readUInt32();
+		for (let i = 0; i < pointCount; i++) multiPoint.points.push(Geometry.parse(value, options));
+		return multiPoint;
+	}
+	static _parseTwkb(value, options) {
+		const multiPoint = new MultiPoint();
+		multiPoint.hasZ = options.hasZ || false;
+		multiPoint.hasM = options.hasM || false;
+		if (options.isEmpty) return multiPoint;
+		const previousPoint = new Point(0, 0, options.hasZ ? 0 : void 0, options.hasM ? 0 : void 0);
+		const pointCount = value.readVarInt();
+		for (let i = 0; i < pointCount; i++) multiPoint.points.push(Point._readTwkbPoint(value, options, previousPoint));
+		return multiPoint;
+	}
+	static _parseGeoJSON(value) {
+		const multiPoint = new MultiPoint();
+		if (value.coordinates.length > 0) multiPoint.hasZ = value.coordinates[0].length > 2;
+		for (let i = 0; i < value.coordinates.length; i++) multiPoint.points.push(Point._parseGeoJSON({
+			type: "Point",
+			coordinates: value.coordinates[i]
+		}));
+		return multiPoint;
+	}
+	toWkt() {
+		if (this.points.length === 0) return this._getWktType(Types.wkt.MultiPoint, true);
+		let wkt = this._getWktType(Types.wkt.MultiPoint, false) + "(";
+		for (let i = 0; i < this.points.length; i++) wkt += this._getWktCoordinate(this.points[i]) + ",";
+		wkt = wkt.slice(0, -1);
+		wkt += ")";
+		return wkt;
+	}
+	toWkb() {
+		const wkb = new BinaryWriter(this._getWkbSize());
+		wkb.writeInt8(1);
+		this._writeWkbType(wkb, Types.wkb.MultiPoint);
+		wkb.writeUInt32LE(this.points.length);
+		for (let i = 0; i < this.points.length; i++) wkb.writeBuffer(this.points[i].toWkb({ srid: this.srid }));
+		return wkb.buffer;
+	}
+	toTwkb() {
+		const twkb = new BinaryWriter(0, true);
+		const precision = Geometry.getTwkbPrecision(5, 0, 0);
+		const isEmpty = this.points.length === 0;
+		this._writeTwkbHeader(twkb, Types.wkb.MultiPoint, precision, isEmpty);
+		if (this.points.length > 0) {
+			twkb.writeVarInt(this.points.length);
+			const previousPoint = new Point(0, 0, 0, 0);
+			for (let i = 0; i < this.points.length; i++) this.points[i]._writeTwkbPoint(twkb, precision, previousPoint);
+		}
+		return twkb.buffer;
+	}
+	_getWkbSize() {
+		let coordinateSize = 16;
+		if (this.hasZ) coordinateSize += 8;
+		if (this.hasM) coordinateSize += 8;
+		coordinateSize += 5;
+		return 9 + this.points.length * coordinateSize;
+	}
+	toGeoJSON(options) {
+		const geoJSON = super.toGeoJSON(options);
+		geoJSON.type = Types.geoJSON.MultiPoint;
+		geoJSON.coordinates = [];
+		for (let i = 0; i < this.points.length; i++) geoJSON.coordinates.push(this.points[i].toGeoJSON().coordinates);
+		return geoJSON;
+	}
+};
+//#endregion
+export { MultiPoint };

package/dist/src/wkx/multipolygon.mjs

@@ -0,0 +1,155 @@
+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";
+import { Polygon } from "./polygon.mjs";
+//#region src/wkx/multipolygon.ts
+init_geometry();
+init_types();
+init_point();
+init_binarywriter();
+var MultiPolygon = class MultiPolygon extends Geometry {
+	polygons;
+	constructor(polygons, srid) {
+		super();
+		this.polygons = polygons || [];
+		this.srid = srid;
+		if (this.polygons.length > 0) {
+			this.hasZ = this.polygons[0].hasZ;
+			this.hasM = this.polygons[0].hasM;
+		}
+	}
+	static Z(polygons, srid) {
+		const multiPolygon = new MultiPolygon(polygons, srid);
+		multiPolygon.hasZ = true;
+		return multiPolygon;
+	}
+	static M(polygons, srid) {
+		const multiPolygon = new MultiPolygon(polygons, srid);
+		multiPolygon.hasM = true;
+		return multiPolygon;
+	}
+	static ZM(polygons, srid) {
+		const multiPolygon = new MultiPolygon(polygons, srid);
+		multiPolygon.hasZ = true;
+		multiPolygon.hasM = true;
+		return multiPolygon;
+	}
+	static _parseWkt(value, options) {
+		const multiPolygon = new MultiPolygon();
+		multiPolygon.srid = options.srid;
+		multiPolygon.hasZ = options.hasZ;
+		multiPolygon.hasM = options.hasM;
+		if (value.isMatch(["EMPTY"])) return multiPolygon;
+		value.expectGroupStart();
+		do {
+			value.expectGroupStart();
+			let exteriorRing = [];
+			const interiorRings = [];
+			value.expectGroupStart();
+			exteriorRing = exteriorRing.concat(value.matchCoordinates(options));
+			value.expectGroupEnd();
+			while (value.isMatch([","])) {
+				value.expectGroupStart();
+				interiorRings.push(value.matchCoordinates(options));
+				value.expectGroupEnd();
+			}
+			multiPolygon.polygons.push(new Polygon(exteriorRing, interiorRings));
+			value.expectGroupEnd();
+		} while (value.isMatch([","]));
+		value.expectGroupEnd();
+		return multiPolygon;
+	}
+	static _parseWkb(value, options) {
+		const multiPolygon = new MultiPolygon();
+		multiPolygon.srid = options.srid;
+		multiPolygon.hasZ = options.hasZ || false;
+		multiPolygon.hasM = options.hasM || false;
+		const polygonCount = value.readUInt32();
+		for (let i = 0; i < polygonCount; i++) multiPolygon.polygons.push(Geometry.parse(value, options));
+		return multiPolygon;
+	}
+	static _parseTwkb(value, options) {
+		const multiPolygon = new MultiPolygon();
+		multiPolygon.hasZ = options.hasZ || false;
+		multiPolygon.hasM = options.hasM || false;
+		if (options.isEmpty) return multiPolygon;
+		const previousPoint = new Point(0, 0, options.hasZ ? 0 : void 0, options.hasM ? 0 : void 0);
+		const polygonCount = value.readVarInt();
+		for (let i = 0; i < polygonCount; i++) {
+			const polygon = new Polygon();
+			polygon.hasZ = options.hasZ || false;
+			polygon.hasM = options.hasM || false;
+			const ringCount = value.readVarInt();
+			const exteriorRingCount = value.readVarInt();
+			for (let j = 0; j < exteriorRingCount; j++) polygon.exteriorRing.push(Point._readTwkbPoint(value, options, previousPoint));
+			for (let j = 1; j < ringCount; j++) {
+				const interiorRing = [];
+				const interiorRingCount = value.readVarInt();
+				for (let k = 0; k < interiorRingCount; k++) interiorRing.push(Point._readTwkbPoint(value, options, previousPoint));
+				polygon.interiorRings.push(interiorRing);
+			}
+			multiPolygon.polygons.push(polygon);
+		}
+		return multiPolygon;
+	}
+	static _parseGeoJSON(value) {
+		const multiPolygon = new MultiPolygon();
+		if (value.coordinates.length > 0 && value.coordinates[0].length > 0 && value.coordinates[0][0].length > 0) multiPolygon.hasZ = value.coordinates[0][0][0].length > 2;
+		for (let i = 0; i < value.coordinates.length; i++) multiPolygon.polygons.push(Polygon._parseGeoJSON({
+			type: "Polygon",
+			coordinates: value.coordinates[i]
+		}));
+		return multiPolygon;
+	}
+	toWkt() {
+		if (this.polygons.length === 0) return this._getWktType(Types.wkt.MultiPolygon, true);
+		let wkt = this._getWktType(Types.wkt.MultiPolygon, false) + "(";
+		for (let i = 0; i < this.polygons.length; i++) wkt += this.polygons[i]._toInnerWkt() + ",";
+		wkt = wkt.slice(0, -1);
+		wkt += ")";
+		return wkt;
+	}
+	toWkb() {
+		const wkb = new BinaryWriter(this._getWkbSize());
+		wkb.writeInt8(1);
+		this._writeWkbType(wkb, Types.wkb.MultiPolygon);
+		wkb.writeUInt32LE(this.polygons.length);
+		for (let i = 0; i < this.polygons.length; i++) wkb.writeBuffer(this.polygons[i].toWkb({ srid: this.srid }));
+		return wkb.buffer;
+	}
+	toTwkb() {
+		const twkb = new BinaryWriter(0, true);
+		const precision = Geometry.getTwkbPrecision(5, 0, 0);
+		const isEmpty = this.polygons.length === 0;
+		this._writeTwkbHeader(twkb, Types.wkb.MultiPolygon, precision, isEmpty);
+		if (this.polygons.length > 0) {
+			twkb.writeVarInt(this.polygons.length);
+			const previousPoint = new Point(0, 0, 0, 0);
+			for (let i = 0; i < this.polygons.length; i++) {
+				twkb.writeVarInt(1 + this.polygons[i].interiorRings.length);
+				twkb.writeVarInt(this.polygons[i].exteriorRing.length);
+				for (let j = 0; j < this.polygons[i].exteriorRing.length; j++) this.polygons[i].exteriorRing[j]._writeTwkbPoint(twkb, precision, previousPoint);
+				for (let j = 0; j < this.polygons[i].interiorRings.length; j++) {
+					twkb.writeVarInt(this.polygons[i].interiorRings[j].length);
+					for (let k = 0; k < this.polygons[i].interiorRings[j].length; k++) this.polygons[i].interiorRings[j][k]._writeTwkbPoint(twkb, precision, previousPoint);
+				}
+			}
+		}
+		return twkb.buffer;
+	}
+	_getWkbSize() {
+		let size = 9;
+		for (let i = 0; i < this.polygons.length; i++) size += this.polygons[i]._getWkbSize();
+		return size;
+	}
+	toGeoJSON(options) {
+		const geoJSON = super.toGeoJSON(options);
+		geoJSON.type = Types.geoJSON.MultiPolygon;
+		geoJSON.coordinates = [];
+		for (let i = 0; i < this.polygons.length; i++) geoJSON.coordinates.push(this.polygons[i].toGeoJSON().coordinates);
+		return geoJSON;
+	}
+};
+//#endregion
+export { MultiPolygon };