@maplibre/geojson-vt 6.1.2 → 6.3.0

package/dist/geojson-vt-dev.js

@@ -134,6 +134,51 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		}
 	}
 
+//#endregion
+//#region src/world-coordinate-helper.ts
+/**
+	* Longitude and latitude, which spherical mercator puts in the world square.
+	*/
+	var MercatorWorldCoordinateHelper = class {
+		projectX(lng) {
+			return lng / 360 + .5;
+		}
+		projectY(lat) {
+			const sin = Math.sin(lat * Math.PI / 180);
+			const y = .5 - .25 * Math.log((1 + sin) / (1 - sin)) / Math.PI;
+			return y < 0 ? 0 : y > 1 ? 1 : y;
+		}
+		unprojectX(x) {
+			return (x - .5) * 360;
+		}
+		unprojectY(y) {
+			const y2 = (180 - y * 360) * Math.PI / 180;
+			return 360 * Math.atan(Math.exp(y2)) / Math.PI - 90;
+		}
+	};
+	/**
+	* Positions in the unit square already, see `coordinates` in {@link GeoJSONVTOptions}.
+	*/
+	var IdentityWorldCoordinateHelper = class {
+		projectX(x) {
+			return x;
+		}
+		projectY(y) {
+			return y;
+		}
+		unprojectX(x) {
+			return x;
+		}
+		unprojectY(y) {
+			return y;
+		}
+	};
+	const mercatorWorldCoordinateHelper = new MercatorWorldCoordinateHelper();
+	const identityWorldCoordinateHelper = new IdentityWorldCoordinateHelper();
+	function getWorldCoordinateHelper(coordinates) {
+		return coordinates === "unitSquare" ? identityWorldCoordinateHelper : mercatorWorldCoordinateHelper;
+	}
+
 //#endregion
 //#region src/convert.ts
 	const MAX_GEOMETRY_COLLECTION_DEPTH = 1024;
@@ -141,25 +186,38 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	* converts GeoJSON to internal source features (an intermediate projected JSON vector format with simplification data)
 	* @param data
 	* @param options
+	* @param unlocated - the features without coordinates, by id: a feature with an id that converts to nothing is set in it, and one that converts to something is deleted from it
 	* @returns
 	*/
-	function convertToInternal(data, options) {
+	function convertToInternal(data, options, unlocated) {
 		const features = [];
 		switch (data.type) {
 			case "FeatureCollection":
-				for (let i = 0; i < data.features.length; i++) featureToInternal(features, data.features[i], options, i);
+				for (let i = 0; i < data.features.length; i++) convertFeature(features, data.features[i], options, unlocated, i);
 				break;
 			case "Feature":
-				featureToInternal(features, data, options);
+				convertFeature(features, data, options, unlocated);
 				break;
-			default: featureToInternal(features, {
+			default: convertFeature(features, {
 				type: "Feature",
 				geometry: data,
 				properties: void 0
-			}, options);
+			}, options, unlocated);
 		}
 		return features;
 	}
+	function convertFeature(features, geojson, options, unlocated, index) {
+		const count = features.length;
+		featureToInternal(features, geojson, options, index);
+		if (!unlocated) return;
+		const id = getFeatureId(geojson, options, index);
+		if (id == null) return;
+		if (features.length > count) unlocated.delete(id);
+		else unlocated.set(id, {
+			...geojson,
+			id
+		});
+	}
 	function featureToInternal(features, geojson, options, index, depth = 0) {
 		if (!geojson.geometry) return;
 		if (depth > MAX_GEOMETRY_COLLECTION_DEPTH) throw new Error("GeometryCollection nesting exceeds supported depth: 1024");
@@ -170,24 +228,25 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		if (!geojson.geometry.coordinates?.length) return;
 		const id = getFeatureId(geojson, options, index);
 		const tolerance = Math.pow(options.tolerance / ((1 << options.maxZoom) * options.extent), 2);
+		const worldCoordinateHelper = getWorldCoordinateHelper(options.coordinates);
 		switch (geojson.geometry.type) {
 			case "Point":
-				convertPointFeature(features, id, geojson.geometry, geojson.properties);
+				convertPointFeature(features, id, geojson.geometry, worldCoordinateHelper, geojson.properties);
 				return;
 			case "MultiPoint":
-				convertMultiPointFeature(features, id, geojson.geometry, geojson.properties);
+				convertMultiPointFeature(features, id, geojson.geometry, worldCoordinateHelper, geojson.properties);
 				return;
 			case "LineString":
-				convertLineStringFeature(features, id, geojson.geometry, tolerance, geojson.properties);
+				convertLineStringFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, geojson.properties);
 				return;
 			case "MultiLineString":
-				convertMultiLineStringFeature(features, id, geojson.geometry, tolerance, options, geojson.properties);
+				convertMultiLineStringFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, options, geojson.properties);
 				return;
 			case "Polygon":
-				convertPolygonFeature(features, id, geojson.geometry, tolerance, geojson.properties);
+				convertPolygonFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, geojson.properties);
 				return;
 			case "MultiPolygon":
-				convertMultiPolygonFeature(features, id, geojson.geometry, tolerance, geojson.properties);
+				convertMultiPolygonFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, geojson.properties);
 				return;
 			default: throw new Error("Input data is not a valid GeoJSON object.");
 		}
@@ -205,53 +264,55 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			properties: geojson.properties
 		}, options, index, depth);
 	}
-	function convertPointFeature(features, id, geom, properties) {
+	function convertPointFeature(features, id, geom, worldCoordinateHelper, properties) {
 		const out = [];
-		out.push(projectX(geom.coordinates[0]), projectY(geom.coordinates[1]), 0);
+		out.push(worldCoordinateHelper.projectX(geom.coordinates[0]), worldCoordinateHelper.projectY(geom.coordinates[1]), 0);
 		features.push(createFeature(id, "Point", out, properties));
 	}
-	function convertMultiPointFeature(features, id, geom, properties) {
+	function convertMultiPointFeature(features, id, geom, worldCoordinateHelper, properties) {
 		const out = [];
-		for (const coords of geom.coordinates) out.push(projectX(coords[0]), projectY(coords[1]), 0);
+		for (const coords of geom.coordinates) out.push(worldCoordinateHelper.projectX(coords[0]), worldCoordinateHelper.projectY(coords[1]), 0);
 		features.push(createFeature(id, "MultiPoint", out, properties));
 	}
-	function convertLineStringFeature(features, id, geom, tolerance, properties) {
+	function convertLineStringFeature(features, id, geom, tolerance, worldCoordinateHelper, properties) {
 		const out = { points: [] };
-		convertLine(geom.coordinates, out, tolerance, false);
+		convertLine(geom.coordinates, out, tolerance, false, worldCoordinateHelper);
 		features.push(createFeature(id, "LineString", out, properties));
 	}
-	function convertMultiLineStringFeature(features, id, geom, tolerance, options, properties) {
+	function convertMultiLineStringFeature(features, id, geom, tolerance, worldCoordinateHelper, options, properties) {
 		if (options.lineMetrics) for (const line of geom.coordinates) {
 			const out = { points: [] };
-			convertLine(line, out, tolerance, false);
+			convertLine(line, out, tolerance, false, worldCoordinateHelper);
 			features.push(createFeature(id, "LineString", out, properties));
 		}
 		else {
 			const out = [];
-			convertLines(geom.coordinates, out, tolerance, false);
+			convertLines(geom.coordinates, out, tolerance, false, worldCoordinateHelper);
 			features.push(createFeature(id, "MultiLineString", out, properties));
 		}
 	}
-	function convertPolygonFeature(features, id, geom, tolerance, properties) {
+	function convertPolygonFeature(features, id, geom, tolerance, worldCoordinateHelper, properties) {
 		const out = [];
-		convertLines(geom.coordinates, out, tolerance, true);
+		convertLines(geom.coordinates, out, tolerance, true, worldCoordinateHelper);
 		features.push(createFeature(id, "Polygon", out, properties));
 	}
-	function convertMultiPolygonFeature(features, id, geom, tolerance, properties) {
+	function convertMultiPolygonFeature(features, id, geom, tolerance, worldCoordinateHelper, properties) {
 		const out = [];
 		for (const polygon of geom.coordinates) {
 			const polygonOut = [];
-			convertLines(polygon, polygonOut, tolerance, true);
+			convertLines(polygon, polygonOut, tolerance, true, worldCoordinateHelper);
+			if (!polygonOut.length) continue;
 			out.push(polygonOut);
 		}
+		if (!out.length) return;
 		features.push(createFeature(id, "MultiPolygon", out, properties));
 	}
-	function convertLine(ring, out, tolerance, isPolygon) {
+	function convertLine(ring, out, tolerance, isPolygon, worldCoordinateHelper) {
 		let x0, y0;
 		let size = 0;
 		for (let j = 0; j < ring.length; j++) {
-			const x = projectX(ring[j][0]);
-			const y = projectY(ring[j][1]);
+			const x = worldCoordinateHelper.projectX(ring[j][0]);
+			const y = worldCoordinateHelper.projectY(ring[j][1]);
 			out.points.push(x, y, 0);
 			if (j > 0) {
 				if (isPolygon) size += (x0 * y - x * y0) / 2;
@@ -269,46 +330,32 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		out.start = 0;
 		out.end = out.size;
 	}
-	function convertLines(rings, out, tolerance, isPolygon) {
+	function convertLines(rings, out, tolerance, isPolygon, worldCoordinateHelper) {
 		for (let i = 0; i < rings.length; i++) {
 			const geom = { points: [] };
-			convertLine(rings[i], geom, tolerance, isPolygon);
+			convertLine(rings[i], geom, tolerance, isPolygon, worldCoordinateHelper);
 			out.push(geom);
 		}
 	}
-	/**
-	* Convert longitude to spherical mercator in [0..1] range
-	*/
-	function projectX(x) {
-		return x / 360 + .5;
-	}
-	/**
-	* Convert latitude to spherical mercator in [0..1] range
-	*/
-	function projectY(y) {
-		const sin = Math.sin(y * Math.PI / 180);
-		const y2 = .5 - .25 * Math.log((1 + sin) / (1 - sin)) / Math.PI;
-		return y2 < 0 ? 0 : y2 > 1 ? 1 : y2;
-	}
 
 //#endregion
 //#region src/deconvert.ts
 /**
 	* Converts internal source features back to GeoJSON format.
 	*/
-	function convertToGeoJSON(source) {
+	function convertToGeoJSON(source, worldCoordinateHelper = mercatorWorldCoordinateHelper) {
 		return {
 			type: "FeatureCollection",
-			features: source.map((feature) => featureToGeoJSON(feature))
+			features: source.map((feature) => featureToGeoJSON(feature, worldCoordinateHelper))
 		};
 	}
 	/**
 	* Converts a single internal feature to GeoJSON format.
 	*/
-	function featureToGeoJSON(feature) {
+	function featureToGeoJSON(feature, worldCoordinateHelper = mercatorWorldCoordinateHelper) {
 		const geojsonFeature = {
 			type: "Feature",
-			geometry: geometryToGeoJSON(feature),
+			geometry: geometryToGeoJSON(feature, worldCoordinateHelper),
 			properties: feature.tags
 		};
 		if (feature.id != null) geojsonFeature.id = feature.id;
@@ -317,52 +364,39 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	/**
 	* Converts a single internal feature geometry to GeoJSON format.
 	*/
-	function geometryToGeoJSON(feature) {
+	function geometryToGeoJSON(feature, worldCoordinateHelper) {
 		const { type, geometry } = feature;
 		switch (type) {
 			case "Point": return {
 				type,
-				coordinates: unprojectPoint(geometry[0], geometry[1])
+				coordinates: unprojectPoint(geometry[0], geometry[1], worldCoordinateHelper)
 			};
 			case "MultiPoint": return {
 				type,
-				coordinates: unprojectPoints(geometry)
+				coordinates: unprojectPoints(geometry, worldCoordinateHelper)
 			};
 			case "LineString": return {
 				type,
-				coordinates: unprojectPoints(geometry.points)
+				coordinates: unprojectPoints(geometry.points, worldCoordinateHelper)
 			};
 			case "MultiLineString":
 			case "Polygon": return {
 				type,
-				coordinates: geometry.map((ring) => unprojectPoints(ring.points))
+				coordinates: geometry.map((ring) => unprojectPoints(ring.points, worldCoordinateHelper))
 			};
 			case "MultiPolygon": return {
 				type,
-				coordinates: geometry.map((polygon) => polygon.map((ring) => unprojectPoints(ring.points)))
+				coordinates: geometry.map((polygon) => polygon.map((ring) => unprojectPoints(ring.points, worldCoordinateHelper)))
 			};
 		}
 	}
-	function unprojectPoints(coords) {
+	function unprojectPoints(coords, worldCoordinateHelper = mercatorWorldCoordinateHelper) {
 		const result = [];
-		for (let i = 0; i < coords.length; i += 3) result.push(unprojectPoint(coords[i], coords[i + 1]));
+		for (let i = 0; i < coords.length; i += 3) result.push(unprojectPoint(coords[i], coords[i + 1], worldCoordinateHelper));
 		return result;
 	}
-	function unprojectPoint(x, y) {
-		return [unprojectX(x), unprojectY(y)];
-	}
-	/**
-	* Convert spherical mercator in [0..1] range to longitude
-	*/
-	function unprojectX(x) {
-		return (x - .5) * 360;
-	}
-	/**
-	* Convert spherical mercator in [0..1] range to latitude
-	*/
-	function unprojectY(y) {
-		const y2 = (180 - y * 360) * Math.PI / 180;
-		return 360 * Math.atan(Math.exp(y2)) / Math.PI - 90;
+	function unprojectPoint(x, y, worldCoordinateHelper) {
+		return [worldCoordinateHelper.unprojectX(x), worldCoordinateHelper.unprojectY(y)];
 	}
 
 //#endregion
@@ -488,12 +522,12 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			let exited = false;
 			if (trackMetrics) segLen = Math.sqrt(Math.pow(ax - bx, 2) + Math.pow(ay - by, 2));
 			if (a < start) {
-				if (b > start) {
+				if (b >= start) {
 					t = intersect(slice, ax, ay, bx, by, start);
 					if (trackMetrics) slice.start = len + segLen * t;
 				}
 			} else if (a > end) {
-				if (b < end) {
+				if (b <= end) {
 					t = intersect(slice, ax, ay, bx, by, end);
 					if (trackMetrics) slice.start = len + segLen * t;
 				}
@@ -554,6 +588,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 //#endregion
 //#region src/wrap.ts
 	function wrap(features, options) {
+		if (!options.wrap) return features;
 		const buffer = options.buffer / options.extent;
 		let merged = features;
 		const left = clip(features, 1, -1 - buffer, buffer, 0, -1, 2, options);
@@ -624,16 +659,19 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	* @param source 
 	* @param dataDiff 
 	* @param options 
+	* @param unlocated - the features without coordinates, by id, so that an update can give them some
 	* @returns 
 	*/
-	function applySourceDiff(source, dataDiff, options) {
+	function applySourceDiff(source, dataDiff, options, unlocated) {
 		const diff = diffToHashed(dataDiff, options);
 		let affected = [];
 		if (diff.removeAll) {
 			affected = source;
 			source = [];
+			unlocated?.clear();
 		}
 		if (diff.remove.size || diff.add.size) {
+			for (const id of diff.remove) unlocated?.delete(id);
 			const removeFeatures = [];
 			for (const feature of source) if (diff.remove.has(feature.id) || diff.add.has(feature.id)) removeFeatures.push(feature);
 			if (removeFeatures.length) {
@@ -645,7 +683,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				let addFeatures = convertToInternal({
 					type: "FeatureCollection",
 					features: Array.from(diff.add.values())
-				}, options);
+				}, options, unlocated);
 				addFeatures = wrap(addFeatures, options);
 				affected = affected.concat(addFeatures);
 				source = source.concat(addFeatures);
@@ -658,8 +696,14 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			else keepFeatures.push(feature);
 			for (const [id, update] of diff.update) {
 				const oldFeatures = oldFeaturesMap.get(id);
-				if (!oldFeatures || oldFeatures.length === 0) continue;
-				const updatedFeatures = getUpdatedFeatures(oldFeatures, update, options);
+				if (!oldFeatures || oldFeatures.length === 0) {
+					if (!unlocated?.has(id)) continue;
+					const locatedFeatures = getUpdatedUnlocatedFeatures(id, update, options, unlocated);
+					affected = affected.concat(locatedFeatures);
+					keepFeatures = keepFeatures.concat(locatedFeatures);
+					continue;
+				}
+				const updatedFeatures = getUpdatedFeatures(oldFeatures, update, options, unlocated);
 				affected = affected.concat(oldFeatures, updatedFeatures);
 				keepFeatures = keepFeatures.concat(updatedFeatures);
 			}
@@ -675,25 +719,16 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	* @param vtFeatures - the original features
 	* @param update - the update object to apply
 	* @param options - the options to use for the wrap method
-	* @returns Updated features. If geometry is updated, returns new feature(s) converted from geojson and wrapped. If only properties are updated, returns feature(s) with tags updated.
+	* @param unlocated - the features without coordinates, by id, which a new geometry without coordinates adds the feature to
+	* @returns Updated features. If geometry is updated, returns new feature(s) converted from geojson and wrapped, with the id the feature already has. If only properties are updated, returns feature(s) with tags updated.
 	*/
-	function getUpdatedFeatures(vtFeatures, update, options) {
+	function getUpdatedFeatures(vtFeatures, update, options, unlocated) {
 		const changeGeometry = !!update.newGeometry;
-		const changeProps = update.removeAllProperties || update.removeProperties?.length > 0 || update.addOrUpdateProperties?.length > 0;
+		const changeProps = hasPropertyChanges(update);
 		if (changeGeometry) {
 			const vtFeature = vtFeatures[0];
-			const geojsonFeature = {
-				type: "Feature",
-				id: vtFeature.id,
-				geometry: update.newGeometry,
-				properties: changeProps ? applyPropertyUpdates(vtFeature.tags, update) : vtFeature.tags
-			};
-			let features = convertToInternal({
-				type: "FeatureCollection",
-				features: [geojsonFeature]
-			}, options);
-			features = wrap(features, options);
-			return features;
+			const properties = changeProps ? applyPropertyUpdates(vtFeature.tags, update) : vtFeature.tags;
+			return convertNewGeometry(vtFeature.id, update.newGeometry, properties, options, unlocated);
 		}
 		if (changeProps) {
 			const updated = [];
@@ -707,6 +742,44 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		return vtFeatures;
 	}
 	/**
+	* Gets the features an update gives a feature without coordinates: none, unless its new geometry has some.
+	* Its property changes apply either way.
+	*/
+	function getUpdatedUnlocatedFeatures(id, update, options, unlocated) {
+		const feature = unlocated.get(id);
+		const properties = hasPropertyChanges(update) ? applyPropertyUpdates(feature.properties, update) : feature.properties;
+		if (!update.newGeometry) {
+			unlocated.set(id, {
+				...feature,
+				properties
+			});
+			return [];
+		}
+		return convertNewGeometry(id, update.newGeometry, properties, options, unlocated);
+	}
+	/**
+	* Converts the new geometry of a feature to internal format, keeping the id the feature already has
+	*/
+	function convertNewGeometry(id, geometry, properties, options, unlocated) {
+		const features = convertToInternal({
+			type: "FeatureCollection",
+			features: [{
+				type: "Feature",
+				id,
+				geometry,
+				properties
+			}]
+		}, {
+			...options,
+			promoteId: void 0,
+			generateId: false
+		}, unlocated);
+		return wrap(features, options);
+	}
+	function hasPropertyChanges(update) {
+		return update.removeAllProperties || update.removeProperties?.length > 0 || update.addOrUpdateProperties?.length > 0;
+	}
+	/**
 	* helper to apply property updates from a diff update object to a properties object
 	*/
 	function applyPropertyUpdates(tags, update) {
@@ -728,7 +801,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		return {
 			removeAll: diff.removeAll,
 			remove: new Set(diff.remove || []),
-			add: new Map(diff.add?.map((feature) => [options.promoteId ? feature.properties[options.promoteId] : feature.id, feature])),
+			add: new Map(diff.add?.map((feature) => [options.promoteId ? feature.properties?.[options.promoteId] : feature.id, feature])),
 			update: new Map(diff.update?.map((update) => [update.id, update]))
 		};
 	}
@@ -1031,54 +1104,105 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		log: false,
 		generateId: false,
 		reduce: null,
-		map: (props) => props
+		map: (props) => props,
+		coordinates: "lngLat",
+		wrap: true
 	};
-	const OFFSET_ZOOM = 2;
-	const OFFSET_ID = 3;
-	const OFFSET_PARENT = 4;
-	const OFFSET_NUM = 5;
-	const OFFSET_PROP = 6;
+	/**
+	* The highest zoom level to cluster on. A cluster id keeps its zoom level in five bits.
+	*/
+	const MAX_ZOOM = 30;
+	/**
+	* Projected coordinates, which are 0 to 1 inside the world, are stored as integers with this many steps per world,
+	* so that they take half the memory of doubles. One step is ~4 cm at the equator.
+	*/
+	const SCALE = 1073741824;
+	/**
+	* The largest value a 32-bit integer holds.
+	*/
+	const MAX_INTEGER = 2147483647;
+	/**
+	* A projected coordinate in steps from the center of the world, see `SCALE`.
+	*/
+	function encode(coord) {
+		return (coord - .5) * SCALE;
+	}
+	function decode(value) {
+		return value / SCALE + .5;
+	}
+	/**
+	* Whether a projected coordinate fits in a 32-bit integer. One that is more than two worlds from the center of the
+	* world does not, and neither does one that is not a number.
+	*/
+	function fitsInteger(coord) {
+		return Math.abs(encode(coord)) < MAX_INTEGER;
+	}
+	const OFFSET_ZOOM = 0;
+	const OFFSET_ID = 1;
+	const OFFSET_PARENT = 2;
+	const OFFSET_NUM = 3;
+	const OFFSET_PROP = 4;
 	/**
 	* This class allow clustering of geojson points.
 	*/
 	var ClusterTileIndex = class {
 		constructor(options) {
-			this.options = Object.assign(Object.create(defaultClusterOptions), options);
+			this.options = createOptions(options);
+			this.worldCoordinateHelper = getWorldCoordinateHelper(this.options.coordinates);
 			this.trees = new Array(this.options.maxZoom + 1);
-			this.stride = this.options.reduce ? 7 : 6;
+			this.stride = this.options.reduce ? 5 : 4;
 			this.clusterProps = [];
 			this.points = [];
 		}
 		/**
-		* Loads GeoJSON point features and builds the internal clustering index.
-		* @param points - GeoJSON point features to cluster.
+		* Loads GeoJSON Point and MultiPoint features and builds the internal clustering index.
+		* Each position of a MultiPoint is clustered as a point of its own, with the id and properties of its feature.
+		* @param points - GeoJSON Point and MultiPoint features to cluster.
 		*/
 		load(points) {
 			const features = [];
 			for (const point of points) {
 				if (!point.geometry) continue;
-				const [lng, lat] = point.geometry.coordinates;
-				const [x, y] = [projectX(lng), projectY(lat)];
-				const feature = {
-					id: point.id,
-					type: "Point",
-					geometry: [x, y],
-					tags: point.properties
-				};
-				features.push(feature);
+				const positions = point.geometry.type === "MultiPoint" ? point.geometry.coordinates : [point.geometry.coordinates];
+				for (const [lng, lat] of positions) {
+					const [x, y] = [this.worldCoordinateHelper.projectX(lng), this.worldCoordinateHelper.projectY(lat)];
+					if (!this.options.wrap && !isInWorld([x, y])) continue;
+					const feature = {
+						id: point.id,
+						type: "Point",
+						geometry: [x, y],
+						tags: point.properties
+					};
+					features.push(feature);
+				}
 			}
 			this.createIndex(features);
 		}
 		/**
 		* @internal
 		* Loads internal GeoJSONVT point features from a data source and builds the clustering index.
+		* Each position of a MultiPoint feature becomes a point of its own, with the id and properties of its feature.
 		* @param features - {@link GeoJSONVTInternalFeature} data source features to filter and cluster.
 		*/
 		initialize(features) {
 			const points = [];
 			for (const feature of features) {
-				if (feature.type !== "Point") continue;
-				points.push(feature);
+				if (feature.type === "Point") {
+					if (!this.options.wrap && !isInWorld(feature.geometry)) continue;
+					points.push(feature);
+					continue;
+				}
+				if (feature.type !== "MultiPoint") continue;
+				for (let i = 0; i < feature.geometry.length; i += 3) {
+					const geometry = [feature.geometry[i], feature.geometry[i + 1]];
+					if (!this.options.wrap && !isInWorld(geometry)) continue;
+					points.push({
+						id: feature.id,
+						type: "Point",
+						geometry,
+						tags: feature.tags
+					});
+				}
 			}
 			this.createIndex(points);
 		}
@@ -1088,41 +1212,113 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		* @param features 
 		*/
 		updateIndex(features, _affected, options) {
-			this.options = Object.assign(Object.create(defaultClusterOptions), options.clusterOptions);
+			this.options = createOptions({
+				...options.clusterOptions,
+				coordinates: this.options.coordinates,
+				wrap: this.options.wrap
+			});
 			this.initialize(features);
 		}
+		/**
+		* Builds a tree per zoom level from the points. A point whose position does not fit in an integer is left out,
+		* see `fitsInteger`.
+		*/
 		createIndex(points) {
 			const { log, minZoom, maxZoom } = this.options;
+			this.trees = new Array(maxZoom + 1);
+			this.stride = this.options.reduce ? 5 : 4;
+			this.clusterProps = [];
 			if (log) console.time("total time");
 			const timerId = `prepare ${points.length} points`;
 			if (log) console.time(timerId);
 			this.points = points;
-			const data = [];
+			const stride = this.stride;
+			const notProcessed = maxZoom + 1;
+			const coords = new Int32Array(points.length * 2);
+			const data = new Int32Array(points.length * stride);
+			let numItems = 0;
 			for (let i = 0; i < points.length; i++) {
 				const p = points[i];
-				if (!p?.geometry) continue;
-				let [x, y] = p.geometry;
-				x = Math.fround(x);
-				y = Math.fround(y);
-				data.push(x, y, Infinity, i, -1, 1);
-				if (this.options.reduce) data.push(0);
+				if (!p?.geometry || !fitsInteger(p.geometry[0]) || !fitsInteger(p.geometry[1])) continue;
+				coords[numItems * 2] = Math.round(encode(p.geometry[0]));
+				coords[numItems * 2 + 1] = Math.round(encode(p.geometry[1]));
+				const k = numItems * stride;
+				data[k + OFFSET_ZOOM] = notProcessed;
+				data[k + OFFSET_ID] = i;
+				data[k + OFFSET_PARENT] = -1;
+				data[k + OFFSET_NUM] = 1;
+				numItems++;
 			}
-			let tree = this.trees[maxZoom + 1] = this.createTree(data);
+			let tree = this.trees[maxZoom + 1] = this.createTree(coords, data, numItems);
 			if (log) console.timeEnd(timerId);
+			const nextCoords = new Int32Array(numItems * 2);
+			const nextData = new Int32Array(numItems * stride);
 			for (let z = maxZoom; z >= minZoom; z--) {
 				const now = Date.now();
-				tree = this.trees[z] = this.createTree(this.cluster(tree, z));
+				const nextNumItems = this.cluster(tree, z, nextCoords, nextData);
+				if (!this.isSameAsTree(tree, nextData, nextNumItems)) tree = this.createTree(nextCoords.slice(0, nextNumItems * 2), nextData.slice(0, nextNumItems * stride), nextNumItems);
+				this.trees[z] = tree;
 				if (log) console.log("z%d: %d clusters in %dms", z, tree.numItems, Date.now() - now);
 			}
 			if (log) console.timeEnd("total time");
 		}
 		/**
 		* Returns clusters and/or points within a bounding box at a given zoom level.
-		* @param bbox - Bounding box in `[westLng, southLat, eastLng, northLat]` order.
+		* @param bbox - Bounding box in `[westLng, southLat, eastLng, northLat]` order, or `[minX, minY, maxX, maxY]` in the unit square with `coordinates: 'unitSquare'`.
+		* In a world that wraps, the box can reach across the antimeridian. In one that doesn't, only its part inside the world counts.
 		* @param zoom - Zoom level to query.
 		*/
 		getClusters(bbox, zoom) {
-			return this.getClustersInternal(bbox, zoom).map((f) => featureToGeoJSON(f));
+			return (!this.options.wrap ? this.getClustersInWorld(bbox, zoom) : this.options.coordinates === "unitSquare" ? this.getClustersAcrossEdge(bbox, zoom) : this.getClustersInternal(bbox, zoom)).map((f) => featureToGeoJSON(f, this.worldCoordinateHelper));
+		}
+		/**
+		* The clusters and points in the part of a box inside a world that ends at its edges.
+		*/
+		getClustersInWorld(bbox, zoom) {
+			const lngLat = this.options.coordinates !== "unitSquare";
+			const y1 = this.worldCoordinateHelper.projectY(lngLat ? Math.max(-90, Math.min(90, bbox[1])) : bbox[1]);
+			const y2 = this.worldCoordinateHelper.projectY(lngLat ? Math.max(-90, Math.min(90, bbox[3])) : bbox[3]);
+			const minX = Math.max(0, this.worldCoordinateHelper.projectX(bbox[0]));
+			const maxX = Math.min(1, this.worldCoordinateHelper.projectX(bbox[2]));
+			if (minX > maxX) return [];
+			return this.getClustersInRange([
+				minX,
+				Math.min(y1, y2),
+				maxX,
+				Math.max(y1, y2)
+			], zoom);
+		}
+		/**
+		* The clusters and points in a box of a unit square that wraps, where the box can reach across its left or right edge.
+		*/
+		getClustersAcrossEdge([minX, minY, maxX, maxY], zoom) {
+			if (maxX < minX) maxX += 1;
+			if (maxX - minX >= 1) return this.getClustersInRange([
+				0,
+				minY,
+				1,
+				maxY
+			], zoom);
+			const shift = Math.floor(minX);
+			const west = minX - shift;
+			const east = maxX - shift;
+			if (east <= 1) return this.getClustersInRange([
+				west,
+				minY,
+				east,
+				maxY
+			], zoom);
+			return this.getClustersInRange([
+				west,
+				minY,
+				1,
+				maxY
+			], zoom).concat(this.getClustersInRange([
+				0,
+				minY,
+				east - 1,
+				maxY
+			], zoom));
 		}
 		getClustersInternal(bbox, zoom) {
 			let minLng = ((bbox[0] + 180) % 360 + 360) % 360 - 180;
@@ -1147,13 +1343,25 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				], zoom);
 				return easternHem.concat(westernHem);
 			}
+			return this.getClustersInRange([
+				this.worldCoordinateHelper.projectX(minLng),
+				this.worldCoordinateHelper.projectY(maxLat),
+				this.worldCoordinateHelper.projectX(maxLng),
+				this.worldCoordinateHelper.projectY(minLat)
+			], zoom);
+		}
+		/**
+		* The clusters and points in a box of the internal coordinates, `[minX, minY, maxX, maxY]`.
+		*/
+		getClustersInRange([minX, minY, maxX, maxY], zoom) {
 			const tree = this.trees[this.limitZoom(zoom)];
-			const ids = tree.range(projectX(minLng), projectY(maxLat), projectX(maxLng), projectY(minLat));
+			const ids = tree.range(encode(minX), encode(minY), encode(maxX), encode(maxY));
+			const coords = tree.flatCoords;
 			const data = tree.flatData;
 			const clusters = [];
 			for (const id of ids) {
 				const k = this.stride * id;
-				clusters.push(data[k + OFFSET_NUM] > 1 ? getClusterFeature(data, k, this.clusterProps) : this.points[data[k + OFFSET_ID]]);
+				clusters.push(data[k + OFFSET_NUM] > 1 ? getClusterFeature(coords, id, data, k, this.clusterProps) : this.points[data[k + OFFSET_ID]]);
 			}
 			return clusters;
 		}
@@ -1167,16 +1375,17 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			const clusterError = /* @__PURE__ */ new Error("No cluster with the specified id: " + clusterId);
 			const tree = this.trees[originZoom];
 			if (!tree) throw clusterError;
+			const coords = tree.flatCoords;
 			const data = tree.flatData;
-			if (originId * this.stride >= data.length) throw clusterError;
-			const r = this.options.radius / (this.options.extent * Math.pow(2, originZoom - 1));
-			const x = data[originId * this.stride];
-			const y = data[originId * this.stride + 1];
+			if (originId >= tree.numItems) throw clusterError;
+			const r = this.options.radius / (this.options.extent * Math.pow(2, originZoom - 1)) * SCALE;
+			const x = coords[originId * 2];
+			const y = coords[originId * 2 + 1];
 			const ids = tree.within(x, y, r);
 			const children = [];
 			for (const id of ids) {
 				const k = id * this.stride;
-				if (data[k + OFFSET_PARENT] === clusterId) children.push(data[k + OFFSET_NUM] > 1 ? getClusterGeoJSON(data, k, this.clusterProps) : featureToGeoJSON(this.points[data[k + OFFSET_ID]]));
+				if (data[k + OFFSET_PARENT] === clusterId) children.push(data[k + OFFSET_NUM] > 1 ? getClusterGeoJSON(coords, id, data, k, this.clusterProps, this.worldCoordinateHelper) : featureToGeoJSON(this.points[data[k + OFFSET_ID]], this.worldCoordinateHelper));
 			}
 			if (children.length === 0) throw clusterError;
 			return children;
@@ -1204,10 +1413,11 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			const tree = this.trees[this.limitZoom(z)];
 			if (!tree) return null;
 			const z2 = Math.pow(2, z);
+			if (!this.options.wrap && (x < 0 || x >= z2 || y < 0 || y >= z2)) return null;
 			const { extent, radius } = this.options;
 			const p = radius / extent;
-			const top = (y - p) / z2;
-			const bottom = (y + 1 + p) / z2;
+			const top = encode((y - p) / z2);
+			const bottom = encode((y + 1 + p) / z2);
 			const tile = {
 				transformed: true,
 				features: [],
@@ -1216,9 +1426,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				y,
 				z
 			};
-			this.addTileFeatures(tree.range((x - p) / z2, top, (x + 1 + p) / z2, bottom), tree.flatData, x, y, z2, tile);
-			if (x === 0) this.addTileFeatures(tree.range(1 - p / z2, top, 1, bottom), tree.flatData, z2, y, z2, tile);
-			if (x === z2 - 1) this.addTileFeatures(tree.range(0, top, p / z2, bottom), tree.flatData, -1, y, z2, tile);
+			this.addTileFeatures(tree.range(encode((x - p) / z2), top, encode((x + 1 + p) / z2), bottom), tree, x, y, z2, tile);
+			if (this.options.wrap && x === 0) this.addTileFeatures(tree.range(encode(1 - p / z2), top, encode(1), bottom), tree, z2, y, z2, tile);
+			if (this.options.wrap && x === z2 - 1) this.addTileFeatures(tree.range(encode(0), top, encode(p / z2), bottom), tree, -1, y, z2, tile);
 			return tile;
 		}
 		/**
@@ -1241,15 +1451,27 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			}
 			return skipped;
 		}
-		createTree(data) {
-			const tree = new KDBush(data.length / this.stride | 0, this.options.nodeSize, Float32Array);
-			for (let i = 0; i < data.length; i += this.stride) tree.add(data[i], data[i + 1]);
+		createTree(coords, data, numItems) {
+			const tree = new KDBush(numItems, this.options.nodeSize, Int32Array);
+			for (let i = 0; i < numItems; i++) tree.add(coords[i * 2], coords[i * 2 + 1]);
 			tree.finish();
+			tree.flatCoords = coords;
 			tree.flatData = data;
 			tree.data = null;
 			return tree;
 		}
-		addTileFeatures(ids, data, x, y, z2, tile) {
+		/**
+		* Whether clustering a tree left all its points and clusters as they were, in the same order.
+		*/
+		isSameAsTree(tree, nextData, nextNumItems) {
+			if (nextNumItems !== tree.numItems) return false;
+			const data = tree.flatData;
+			for (let k = OFFSET_ID; k < nextNumItems * this.stride; k += this.stride) if (nextData[k] !== data[k]) return false;
+			return true;
+		}
+		addTileFeatures(ids, tree, x, y, z2, tile) {
+			const coords = tree.flatCoords;
+			const data = tree.flatData;
 			for (const i of ids) {
 				const k = i * this.stride;
 				const isCluster = data[k + OFFSET_NUM] > 1;
@@ -1258,8 +1480,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				let py;
 				if (isCluster) {
 					tags = getClusterProperties(data, k, this.clusterProps);
-					px = data[k];
-					py = data[k + 1];
+					px = decode(coords[i * 2]);
+					py = decode(coords[i * 2 + 1]);
 				} else {
 					const p = this.points[data[k + OFFSET_ID]];
 					tags = p.tags;
@@ -1280,22 +1502,30 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		limitZoom(z) {
 			return Math.max(this.options.minZoom, Math.min(Math.floor(+z), this.options.maxZoom + 1));
 		}
-		cluster(tree, zoom) {
-			const { radius, extent, reduce, minPoints } = this.options;
-			const r = radius / (extent * Math.pow(2, zoom));
+		/**
+		* Clusters the points of a tree on a zoom level, writing the result to `nextCoords` and `nextData`.
+		* @returns the number of points and clusters written
+		*/
+		cluster(tree, zoom, nextCoords, nextData) {
+			const { radius, extent, reduce, minPoints, maxZoom } = this.options;
+			const r = radius / (extent * Math.pow(2, zoom)) * SCALE;
+			const notProcessed = maxZoom + 1;
+			const coords = tree.flatCoords;
 			const data = tree.flatData;
-			const nextData = [];
 			const stride = this.stride;
-			for (let i = 0; i < data.length; i += stride) {
+			const neighborIds = new Uint32Array(tree.numItems);
+			let nextNumItems = 0;
+			for (let index = 0; index < tree.numItems; index++) {
+				const i = index * stride;
 				if (data[i + OFFSET_ZOOM] <= zoom) continue;
 				data[i + OFFSET_ZOOM] = zoom;
-				const x = data[i];
-				const y = data[i + 1];
-				const neighborIds = tree.within(data[i], data[i + 1], r);
+				const x = coords[index * 2];
+				const y = coords[index * 2 + 1];
+				const numNeighbors = tree.withinInto(x, y, r, neighborIds);
 				const numPointsOrigin = data[i + OFFSET_NUM];
 				let numPoints = numPointsOrigin;
-				for (const neighborId of neighborIds) {
-					const k = neighborId * stride;
+				for (let n = 0; n < numNeighbors; n++) {
+					const k = neighborIds[n] * stride;
 					if (data[k + OFFSET_ZOOM] > zoom) numPoints += data[k + OFFSET_NUM];
 				}
 				if (numPoints > numPointsOrigin && numPoints >= minPoints) {
@@ -1303,14 +1533,15 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 					let wy = y * numPointsOrigin;
 					let clusterProperties;
 					let clusterPropIndex = -1;
-					const id = ((i / stride | 0) << 5) + (zoom + 1) + this.points.length;
-					for (const neighborId of neighborIds) {
-						const k = neighborId * stride;
+					const id = (index << 5) + (zoom + 1) + this.points.length;
+					for (let n = 0; n < numNeighbors; n++) {
+						const neighborIndex = neighborIds[n];
+						const k = neighborIndex * stride;
 						if (data[k + OFFSET_ZOOM] <= zoom) continue;
 						data[k + OFFSET_ZOOM] = zoom;
 						const numPoints2 = data[k + OFFSET_NUM];
-						wx += data[k] * numPoints2;
-						wy += data[k + 1] * numPoints2;
+						wx += coords[neighborIndex * 2] * numPoints2;
+						wy += coords[neighborIndex * 2 + 1] * numPoints2;
 						data[k + OFFSET_PARENT] = id;
 						if (reduce) {
 							if (!clusterProperties) {
@@ -1322,19 +1553,33 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 						}
 					}
 					data[i + OFFSET_PARENT] = id;
-					nextData.push(wx / numPoints, wy / numPoints, Infinity, id, -1, numPoints);
-					if (reduce) nextData.push(clusterPropIndex);
+					nextCoords[nextNumItems * 2] = Math.round(wx / numPoints);
+					nextCoords[nextNumItems * 2 + 1] = Math.round(wy / numPoints);
+					const next = nextNumItems * stride;
+					nextData[next + OFFSET_ZOOM] = notProcessed;
+					nextData[next + OFFSET_ID] = id;
+					nextData[next + OFFSET_PARENT] = -1;
+					nextData[next + OFFSET_NUM] = numPoints;
+					if (reduce) nextData[next + OFFSET_PROP] = clusterPropIndex;
+					nextNumItems++;
 				} else {
-					for (let j = 0; j < stride; j++) nextData.push(data[i + j]);
-					if (numPoints > 1) for (const neighborId of neighborIds) {
-						const k = neighborId * stride;
+					nextCoords[nextNumItems * 2] = x;
+					nextCoords[nextNumItems * 2 + 1] = y;
+					for (let j = 0; j < stride; j++) nextData[nextNumItems * stride + j] = data[i + j];
+					nextNumItems++;
+					if (numPoints > 1) for (let n = 0; n < numNeighbors; n++) {
+						const neighborIndex = neighborIds[n];
+						const k = neighborIndex * stride;
 						if (data[k + OFFSET_ZOOM] <= zoom) continue;
 						data[k + OFFSET_ZOOM] = zoom;
-						for (let j = 0; j < stride; j++) nextData.push(data[k + j]);
+						nextCoords[nextNumItems * 2] = coords[neighborIndex * 2];
+						nextCoords[nextNumItems * 2 + 1] = coords[neighborIndex * 2 + 1];
+						for (let j = 0; j < stride; j++) nextData[nextNumItems * stride + j] = data[k + j];
+						nextNumItems++;
 					}
 				}
 			}
-			return nextData;
+			return nextNumItems;
 		}
 		getOriginId(clusterId) {
 			return clusterId - this.points.length >> 5;
@@ -1352,22 +1597,28 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			return clone && result === original ? Object.assign({}, result) : result;
 		}
 	};
-	function getClusterFeature(data, i, clusterProps) {
+	function createOptions(options) {
+		const result = Object.assign(Object.create(defaultClusterOptions), options);
+		result.minZoom = Math.min(result.minZoom, MAX_ZOOM);
+		result.maxZoom = Math.min(result.maxZoom, MAX_ZOOM);
+		return result;
+	}
+	function getClusterFeature(coords, index, data, i, clusterProps) {
 		return {
 			id: data[i + OFFSET_ID],
 			type: "Point",
 			tags: getClusterProperties(data, i, clusterProps),
-			geometry: [data[i], data[i + 1]]
+			geometry: [decode(coords[index * 2]), decode(coords[index * 2 + 1])]
 		};
 	}
-	function getClusterGeoJSON(data, i, clusterProps) {
+	function getClusterGeoJSON(coords, index, data, i, clusterProps, worldCoordinateHelper) {
 		return {
 			type: "Feature",
 			id: data[i + OFFSET_ID],
 			properties: getClusterProperties(data, i, clusterProps),
 			geometry: {
 				type: "Point",
-				coordinates: [unprojectX(data[i]), unprojectY(data[i + 1])]
+				coordinates: [worldCoordinateHelper.unprojectX(decode(coords[index * 2])), worldCoordinateHelper.unprojectY(decode(coords[index * 2 + 1]))]
 			}
 		};
 	}
@@ -1383,6 +1634,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			point_count_abbreviated: abbrev
 		});
 	}
+	function isInWorld(geometry) {
+		return geometry[0] >= 0 && geometry[0] <= 1 && geometry[1] >= 0 && geometry[1] <= 1;
+	}
 
 //#endregion
 //#region src/tile.ts
@@ -1594,7 +1848,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			this.total = 0;
 		}
 		initialize(features) {
-			this.splitTile(features, 0, 0, 0);
+			this.splitTile(this.clipToWorld(features), 0, 0, 0);
 			if (this.options.debug) {
 				if (features.length) console.log("features: %d, points: %d", this.tiles[0].numFeatures, this.tiles[0].numPoints);
 				console.timeEnd("generate tiles");
@@ -1614,8 +1868,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				0,
 				0
 			];
-			const rootTile = createTile(source, z, x, y, options);
-			rootTile.source = source;
+			const rootSource = this.clipToWorld(source);
+			const rootTile = createTile(rootSource, z, x, y, options);
+			rootTile.source = rootSource;
 			const id = toID(z, x, y);
 			this.tiles[id] = rootTile;
 			this.tileCoords.push({
@@ -1646,6 +1901,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		getTile(z, x, y) {
 			const { extent, debug } = this.options;
 			const z2 = 1 << z;
+			if (!this.options.wrap && (x < 0 || x >= z2)) return null;
 			x = x + z2 & z2 - 1;
 			const id = toID(z, x, y);
 			if (this.tiles[id]) return transformTile(this.tiles[id], extent);
@@ -1671,6 +1927,19 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			return transformTile(this.tiles[id], extent);
 		}
 		/**
+		* The features the top tile starts from. A world that wraps keeps them all left and right, where wrapping already
+		* put them inside, and one that doesn't only what lies inside the world square and its buffer. Positions in the
+		* unit square are also cut above and below in a world that wraps, where lng/lat is clamped already. The index keeps
+		* the rest, so an update can still move a feature in from outside.
+		*/
+		clipToWorld(features) {
+			const { wrap, coordinates } = this.options;
+			if (wrap && coordinates !== "unitSquare") return features;
+			const buffer = this.options.buffer / this.options.extent;
+			const inX = wrap ? features : clip(features, 1, -buffer, 1 + buffer, 0, -Infinity, Infinity, this.options) || [];
+			return clip(inX, 1, -buffer, 1 + buffer, 1, -Infinity, Infinity, this.options) || [];
+		}
+		/**
 		* splits features from a parent tile to sub-tiles.
 		* z, x, and y are the coordinates of the parent tile
 		* cz, cx, and cy are the coordinates of the target tile
@@ -1824,7 +2093,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		updateable: false,
 		cluster: false,
 		clusterOptions: defaultClusterOptions,
-		debug: 0
+		debug: 0,
+		coordinates: "lngLat",
+		wrap: true
 	};
 	/**
 	* Main class for creating and managing a vector tile index from GeoJSON data.
@@ -1832,11 +2103,13 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	var GeoJSONVT = class {
 		constructor(data, options) {
 			options = this.options = Object.assign({}, defaultOptions, options);
+			this.worldCoordinateHelper = getWorldCoordinateHelper(options.coordinates);
 			const debug = options.debug;
 			if (debug) console.time("preprocess data");
 			if (options.maxZoom < 0 || options.maxZoom > 24) throw new Error("maxZoom should be in the 0-24 range");
 			if (options.promoteId && options.generateId) throw new Error("promoteId and generateId cannot be used together.");
-			let features = convertToInternal(data, options);
+			if (options.updateable) this.unlocated = /* @__PURE__ */ new Map();
+			let features = convertToInternal(data, options, this.unlocated);
 			if (debug) {
 				console.timeEnd("preprocess data");
 				console.log("index: maxZoom: %d, maxPoints: %d", options.indexMaxZoom, options.indexMaxPoints);
@@ -1847,7 +2120,11 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			this.initializeIndex(features, options);
 		}
 		initializeIndex(features, options) {
-			this.tileIndex = options.cluster ? new ClusterTileIndex(options.clusterOptions) : new TileIndex(options);
+			this.tileIndex = options.cluster ? new ClusterTileIndex({
+				...options.clusterOptions,
+				coordinates: options.coordinates,
+				wrap: options.wrap
+			}) : new TileIndex(options);
 			if (!features.length) return;
 			this.tileIndex.initialize(features);
 		}
@@ -1872,24 +2149,27 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		updateData(diff, filter) {
 			const options = this.options;
 			if (!options.updateable) throw new Error("to update tile geojson `updateable` option must be set to true");
-			let { affected, source } = applySourceDiff(this.source, diff, options);
+			let { affected, source } = applySourceDiff(this.source, diff, options, this.unlocated);
 			if (filter) ({affected, source} = this.filterUpdate(source, affected, filter));
 			if (!affected.length) return;
 			this.source = source;
 			this.tileIndex.updateIndex(source, affected, options);
 		}
 		/**
-		* Filter an update using a predicate function. Returns the affected and updated source features.
+		* Filter an update using a predicate function, the features an update emptied included, so that one the filter
+		* rejects can't come back with a later update. A feature without a geometry at all isn't passed to the predicate.
+		* Returns the affected and updated source features.
 		*/
 		filterUpdate(source, affected, predicate) {
 			const removeIds = /* @__PURE__ */ new Set();
 			for (const feature of source) {
 				if (feature.id == void 0) continue;
-				if (predicate(featureToGeoJSON(feature))) continue;
+				if (predicate(featureToGeoJSON(feature, this.worldCoordinateHelper))) continue;
 				affected.push(feature);
 				removeIds.add(feature.id);
 			}
 			source = source.filter((feature) => !removeIds.has(feature.id));
+			for (const [id, feature] of this.unlocated ?? []) if (feature.geometry && !predicate(feature)) this.unlocated.delete(id);
 			return {
 				affected,
 				source
@@ -1900,12 +2180,12 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		*/
 		getData() {
 			if (!this.options.updateable) throw new Error("to retrieve data the `updateable` option must be set to true");
-			return convertToGeoJSON(this.source);
+			return convertToGeoJSON(this.source, this.worldCoordinateHelper);
 		}
 		/**
 		* Update supercluster options and regenerate the index.
 		* @param cluster - whether to enable clustering
-		* @param clusterOptions - {@link SuperclusterOptions}
+		* @param clusterOptions - {@link SuperclusterOptions} without `coordinates` and `wrap`, which come from the index options
 		*/
 		updateClusterOptions(cluster, clusterOptions) {
 			const wasCluster = this.options.cluster;
@@ -1982,9 +2262,10 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	function geoJSONToTile(data, z, x, y, options = {}) {
 		options = {
 			...defaultOptions,
+			wrap: false,
 			...options
 		};
-		const { wrap: shouldWrap = false, clip: shouldClip = false } = options;
+		const { wrap: shouldWrap, clip: shouldClip = false } = options;
 		let features = convertToInternal(data, options);
 		if (shouldWrap) features = wrap(features, options);
 		if (shouldClip || options.lineMetrics) {