@maplibre/geojson-vt 6.1.2 → 6.3.0

package/dist/geojson-vt.mjs

@@ -127,31 +127,88 @@ function calcLineBBox(feature, geom) {
 	}
 }
 //#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;
 /**
 * 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");
@@ -162,24 +219,25 @@ function featureToInternal(features, geojson, options, index, depth = 0) {
 	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.");
 	}
@@ -197,53 +255,55 @@ function convertGeometryCollection(features, geojson, geometry, options, index,
 		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;
@@ -261,45 +321,31 @@ function convertLine(ring, out, tolerance, isPolygon) {
 	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;
@@ -308,52 +354,39 @@ function featureToGeoJSON(feature) {
 /**
 * 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
 //#region src/clip.ts
@@ -478,12 +511,12 @@ function clipLine(geom, newGeom, start, end, axis, isPolygon, trackMetrics) {
 		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;
 			}
@@ -543,6 +576,7 @@ function intersectY(out, ax, ay, bx, by, y) {
 //#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);
@@ -612,16 +646,19 @@ function shiftLineCoords(line, offset) {
 * @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) {
@@ -633,7 +670,7 @@ function applySourceDiff(source, dataDiff, options) {
 			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);
@@ -646,8 +683,14 @@ function applySourceDiff(source, dataDiff, options) {
 		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);
 		}
@@ -663,24 +706,16 @@ function applySourceDiff(source, dataDiff, options) {
 * @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];
-		let features = convertToInternal({
-			type: "FeatureCollection",
-			features: [{
-				type: "Feature",
-				id: vtFeature.id,
-				geometry: update.newGeometry,
-				properties: changeProps ? applyPropertyUpdates(vtFeature.tags, update) : vtFeature.tags
-			}]
-		}, 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 = [];
@@ -694,6 +729,43 @@ function getUpdatedFeatures(vtFeatures, update, options) {
 	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) {
+	return wrap(convertToInternal({
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			id,
+			geometry,
+			properties
+		}]
+	}, {
+		...options,
+		promoteId: void 0,
+		generateId: false
+	}, unlocated), 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) {
@@ -715,7 +787,7 @@ function diffToHashed(diff, options) {
 	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]))
 	};
 }
@@ -1016,54 +1088,105 @@ const defaultClusterOptions = {
 	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);
 	}
@@ -1073,41 +1196,113 @@ var ClusterTileIndex = class {
 	* @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;
@@ -1132,13 +1327,25 @@ var ClusterTileIndex = class {
 			], 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;
 	}
@@ -1152,16 +1359,17 @@ var ClusterTileIndex = class {
 		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;
@@ -1189,10 +1397,11 @@ var ClusterTileIndex = class {
 		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: [],
@@ -1201,9 +1410,9 @@ var ClusterTileIndex = class {
 			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;
 	}
 	/**
@@ -1226,15 +1435,27 @@ var ClusterTileIndex = class {
 		}
 		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;
@@ -1243,8 +1464,8 @@ var ClusterTileIndex = class {
 			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;
@@ -1265,22 +1486,30 @@ var ClusterTileIndex = class {
 	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) {
@@ -1288,14 +1517,15 @@ var ClusterTileIndex = class {
 				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) {
@@ -1307,19 +1537,33 @@ var ClusterTileIndex = class {
 					}
 				}
 				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;
@@ -1337,22 +1581,28 @@ var ClusterTileIndex = class {
 		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]))]
 		}
 	};
 }
@@ -1368,6 +1618,9 @@ function getClusterProperties(data, i, clusterProps) {
 		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
 const GEOJSONVT_CLIP_START = "geojsonvt_clip_start";
@@ -1576,7 +1829,7 @@ var TileIndex = class {
 		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");
@@ -1596,8 +1849,9 @@ var TileIndex = class {
 			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({
@@ -1628,6 +1882,7 @@ var TileIndex = class {
 	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);
@@ -1653,6 +1908,18 @@ var TileIndex = class {
 		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;
+		return clip(wrap ? features : clip(features, 1, -buffer, 1 + buffer, 0, -Infinity, Infinity, this.options) || [], 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
@@ -1805,7 +2072,9 @@ const defaultOptions = {
 	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.
@@ -1813,11 +2082,13 @@ const defaultOptions = {
 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);
@@ -1828,7 +2099,11 @@ var GeoJSONVT = class {
 		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);
 	}
@@ -1853,24 +2128,27 @@ var GeoJSONVT = class {
 	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
@@ -1881,12 +2159,12 @@ var GeoJSONVT = class {
 	*/
 	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;
@@ -1962,9 +2240,10 @@ var GeoJSONVT = class {
 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) {