@maplibre/geojson-vt 6.2.0 → 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,25 +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 worldCoordinates = options.worldCoordinates === true;
+		const worldCoordinateHelper = getWorldCoordinateHelper(options.coordinates);
 		switch (geojson.geometry.type) {
 			case "Point":
-				convertPointFeature(features, id, geojson.geometry, worldCoordinates, geojson.properties);
+				convertPointFeature(features, id, geojson.geometry, worldCoordinateHelper, geojson.properties);
 				return;
 			case "MultiPoint":
-				convertMultiPointFeature(features, id, geojson.geometry, worldCoordinates, geojson.properties);
+				convertMultiPointFeature(features, id, geojson.geometry, worldCoordinateHelper, geojson.properties);
 				return;
 			case "LineString":
-				convertLineStringFeature(features, id, geojson.geometry, tolerance, worldCoordinates, geojson.properties);
+				convertLineStringFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, geojson.properties);
 				return;
 			case "MultiLineString":
-				convertMultiLineStringFeature(features, id, geojson.geometry, tolerance, worldCoordinates, options, geojson.properties);
+				convertMultiLineStringFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, options, geojson.properties);
 				return;
 			case "Polygon":
-				convertPolygonFeature(features, id, geojson.geometry, tolerance, worldCoordinates, geojson.properties);
+				convertPolygonFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, geojson.properties);
 				return;
 			case "MultiPolygon":
-				convertMultiPolygonFeature(features, id, geojson.geometry, tolerance, worldCoordinates, geojson.properties);
+				convertMultiPolygonFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, geojson.properties);
 				return;
 			default: throw new Error("Input data is not a valid GeoJSON object.");
 		}
@@ -206,55 +264,55 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			properties: geojson.properties
 		}, options, index, depth);
 	}
-	function convertPointFeature(features, id, geom, worldCoordinates, properties) {
+	function convertPointFeature(features, id, geom, worldCoordinateHelper, properties) {
 		const out = [];
-		out.push(projectX(geom.coordinates[0], worldCoordinates), projectY(geom.coordinates[1], worldCoordinates), 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, worldCoordinates, properties) {
+	function convertMultiPointFeature(features, id, geom, worldCoordinateHelper, properties) {
 		const out = [];
-		for (const coords of geom.coordinates) out.push(projectX(coords[0], worldCoordinates), projectY(coords[1], worldCoordinates), 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, worldCoordinates, properties) {
+	function convertLineStringFeature(features, id, geom, tolerance, worldCoordinateHelper, properties) {
 		const out = { points: [] };
-		convertLine(geom.coordinates, out, tolerance, false, worldCoordinates);
+		convertLine(geom.coordinates, out, tolerance, false, worldCoordinateHelper);
 		features.push(createFeature(id, "LineString", out, properties));
 	}
-	function convertMultiLineStringFeature(features, id, geom, tolerance, worldCoordinates, 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, worldCoordinates);
+			convertLine(line, out, tolerance, false, worldCoordinateHelper);
 			features.push(createFeature(id, "LineString", out, properties));
 		}
 		else {
 			const out = [];
-			convertLines(geom.coordinates, out, tolerance, false, worldCoordinates);
+			convertLines(geom.coordinates, out, tolerance, false, worldCoordinateHelper);
 			features.push(createFeature(id, "MultiLineString", out, properties));
 		}
 	}
-	function convertPolygonFeature(features, id, geom, tolerance, worldCoordinates, properties) {
+	function convertPolygonFeature(features, id, geom, tolerance, worldCoordinateHelper, properties) {
 		const out = [];
-		convertLines(geom.coordinates, out, tolerance, true, worldCoordinates);
+		convertLines(geom.coordinates, out, tolerance, true, worldCoordinateHelper);
 		features.push(createFeature(id, "Polygon", out, properties));
 	}
-	function convertMultiPolygonFeature(features, id, geom, tolerance, worldCoordinates, properties) {
+	function convertMultiPolygonFeature(features, id, geom, tolerance, worldCoordinateHelper, properties) {
 		const out = [];
 		for (const polygon of geom.coordinates) {
 			const polygonOut = [];
-			convertLines(polygon, polygonOut, tolerance, true, worldCoordinates);
+			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, worldCoordinates) {
+	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], worldCoordinates);
-			const y = projectY(ring[j][1], worldCoordinates);
+			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;
@@ -272,48 +330,32 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		out.start = 0;
 		out.end = out.size;
 	}
-	function convertLines(rings, out, tolerance, isPolygon, worldCoordinates) {
+	function convertLines(rings, out, tolerance, isPolygon, worldCoordinateHelper) {
 		for (let i = 0; i < rings.length; i++) {
 			const geom = { points: [] };
-			convertLine(rings[i], geom, tolerance, isPolygon, worldCoordinates);
+			convertLine(rings[i], geom, tolerance, isPolygon, worldCoordinateHelper);
 			out.push(geom);
 		}
 	}
-	/**
-	* Convert longitude to spherical mercator in [0..1] range, or keep a world coordinate as it is
-	*/
-	function projectX(x, worldCoordinates = false) {
-		if (worldCoordinates) return x;
-		return x / 360 + .5;
-	}
-	/**
-	* Convert latitude to spherical mercator in [0..1] range, or keep a world coordinate as it is
-	*/
-	function projectY(y, worldCoordinates = false) {
-		if (worldCoordinates) return 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, worldCoordinates = false) {
+	function convertToGeoJSON(source, worldCoordinateHelper = mercatorWorldCoordinateHelper) {
 		return {
 			type: "FeatureCollection",
-			features: source.map((feature) => featureToGeoJSON(feature, worldCoordinates))
+			features: source.map((feature) => featureToGeoJSON(feature, worldCoordinateHelper))
 		};
 	}
 	/**
 	* Converts a single internal feature to GeoJSON format.
 	*/
-	function featureToGeoJSON(feature, worldCoordinates = false) {
+	function featureToGeoJSON(feature, worldCoordinateHelper = mercatorWorldCoordinateHelper) {
 		const geojsonFeature = {
 			type: "Feature",
-			geometry: geometryToGeoJSON(feature, worldCoordinates),
+			geometry: geometryToGeoJSON(feature, worldCoordinateHelper),
 			properties: feature.tags
 		};
 		if (feature.id != null) geojsonFeature.id = feature.id;
@@ -322,54 +364,39 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	/**
 	* Converts a single internal feature geometry to GeoJSON format.
 	*/
-	function geometryToGeoJSON(feature, worldCoordinates) {
+	function geometryToGeoJSON(feature, worldCoordinateHelper) {
 		const { type, geometry } = feature;
 		switch (type) {
 			case "Point": return {
 				type,
-				coordinates: unprojectPoint(geometry[0], geometry[1], worldCoordinates)
+				coordinates: unprojectPoint(geometry[0], geometry[1], worldCoordinateHelper)
 			};
 			case "MultiPoint": return {
 				type,
-				coordinates: unprojectPoints(geometry, worldCoordinates)
+				coordinates: unprojectPoints(geometry, worldCoordinateHelper)
 			};
 			case "LineString": return {
 				type,
-				coordinates: unprojectPoints(geometry.points, worldCoordinates)
+				coordinates: unprojectPoints(geometry.points, worldCoordinateHelper)
 			};
 			case "MultiLineString":
 			case "Polygon": return {
 				type,
-				coordinates: geometry.map((ring) => unprojectPoints(ring.points, worldCoordinates))
+				coordinates: geometry.map((ring) => unprojectPoints(ring.points, worldCoordinateHelper))
 			};
 			case "MultiPolygon": return {
 				type,
-				coordinates: geometry.map((polygon) => polygon.map((ring) => unprojectPoints(ring.points, worldCoordinates)))
+				coordinates: geometry.map((polygon) => polygon.map((ring) => unprojectPoints(ring.points, worldCoordinateHelper)))
 			};
 		}
 	}
-	function unprojectPoints(coords, worldCoordinates = false) {
+	function unprojectPoints(coords, worldCoordinateHelper = mercatorWorldCoordinateHelper) {
 		const result = [];
-		for (let i = 0; i < coords.length; i += 3) result.push(unprojectPoint(coords[i], coords[i + 1], worldCoordinates));
+		for (let i = 0; i < coords.length; i += 3) result.push(unprojectPoint(coords[i], coords[i + 1], worldCoordinateHelper));
 		return result;
 	}
-	function unprojectPoint(x, y, worldCoordinates) {
-		return [unprojectX(x, worldCoordinates), unprojectY(y, worldCoordinates)];
-	}
-	/**
-	* Convert spherical mercator in [0..1] range to longitude, or keep a world coordinate as it is
-	*/
-	function unprojectX(x, worldCoordinates = false) {
-		if (worldCoordinates) return x;
-		return (x - .5) * 360;
-	}
-	/**
-	* Convert spherical mercator in [0..1] range to latitude, or keep a world coordinate as it is
-	*/
-	function unprojectY(y, worldCoordinates = false) {
-		if (worldCoordinates) return 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
@@ -561,7 +588,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 //#endregion
 //#region src/wrap.ts
 	function wrap(features, options) {
-		if (options.worldCoordinates) return features;
+		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);
@@ -632,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) {
@@ -653,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);
@@ -666,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);
 			}
@@ -683,29 +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
+	* @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,
-				promoteId: void 0,
-				generateId: false
-			});
-			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 = [];
@@ -719,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) {
@@ -1043,7 +1104,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		log: false,
 		generateId: false,
 		reduce: null,
-		map: (props) => props
+		map: (props) => props,
+		coordinates: "lngLat",
+		wrap: true
 	};
 	/**
 	* The highest zoom level to cluster on. A cluster id keeps its zoom level in five bits.
@@ -1083,9 +1146,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	* This class allow clustering of geojson points.
 	*/
 	var ClusterTileIndex = class {
-		constructor(options, worldCoordinates = false) {
+		constructor(options) {
 			this.options = createOptions(options);
-			this.worldCoordinates = worldCoordinates;
+			this.worldCoordinateHelper = getWorldCoordinateHelper(this.options.coordinates);
 			this.trees = new Array(this.options.maxZoom + 1);
 			this.stride = this.options.reduce ? 5 : 4;
 			this.clusterProps = [];
@@ -1102,8 +1165,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				if (!point.geometry) continue;
 				const positions = point.geometry.type === "MultiPoint" ? point.geometry.coordinates : [point.geometry.coordinates];
 				for (const [lng, lat] of positions) {
-					const [x, y] = [projectX(lng, this.worldCoordinates), projectY(lat, this.worldCoordinates)];
-					if (this.worldCoordinates && !isInWorld([x, y])) continue;
+					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",
@@ -1125,14 +1188,14 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			const points = [];
 			for (const feature of features) {
 				if (feature.type === "Point") {
-					if (this.worldCoordinates && !isInWorld(feature.geometry)) continue;
+					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.worldCoordinates && !isInWorld(geometry)) continue;
+					if (!this.options.wrap && !isInWorld(geometry)) continue;
 					points.push({
 						id: feature.id,
 						type: "Point",
@@ -1149,7 +1212,11 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		* @param features 
 		*/
 		updateIndex(features, _affected, options) {
-			this.options = createOptions(options.clusterOptions);
+			this.options = createOptions({
+				...options.clusterOptions,
+				coordinates: this.options.coordinates,
+				wrap: this.options.wrap
+			});
 			this.initialize(features);
 		}
 		/**
@@ -1197,11 +1264,61 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		}
 		/**
 		* Returns clusters and/or points within a bounding box at a given zoom level.
-		* @param bbox - Bounding box in `[westLng, southLat, eastLng, northLat]` order, or `[minX, minY, maxX, maxY]` in world coordinates.
+		* @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.worldCoordinates ? this.getClustersInRange(bbox, zoom) : this.getClustersInternal(bbox, zoom)).map((f) => featureToGeoJSON(f, this.worldCoordinates));
+			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;
@@ -1227,10 +1344,10 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				return easternHem.concat(westernHem);
 			}
 			return this.getClustersInRange([
-				projectX(minLng),
-				projectY(maxLat),
-				projectX(maxLng),
-				projectY(minLat)
+				this.worldCoordinateHelper.projectX(minLng),
+				this.worldCoordinateHelper.projectY(maxLat),
+				this.worldCoordinateHelper.projectX(maxLng),
+				this.worldCoordinateHelper.projectY(minLat)
 			], zoom);
 		}
 		/**
@@ -1268,7 +1385,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			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(coords, id, data, k, this.clusterProps, this.worldCoordinates) : featureToGeoJSON(this.points[data[k + OFFSET_ID]], this.worldCoordinates));
+				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;
@@ -1296,7 +1413,7 @@ 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.worldCoordinates && (x < 0 || x >= z2 || y < 0 || y >= z2)) return null;
+			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 = encode((y - p) / z2);
@@ -1310,8 +1427,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				z
 			};
 			this.addTileFeatures(tree.range(encode((x - p) / z2), top, encode((x + 1 + p) / z2), bottom), tree, x, y, z2, tile);
-			if (!this.worldCoordinates && x === 0) this.addTileFeatures(tree.range(encode(1 - p / z2), top, encode(1), bottom), tree, z2, y, z2, tile);
-			if (!this.worldCoordinates && x === z2 - 1) this.addTileFeatures(tree.range(encode(0), top, encode(p / z2), bottom), tree, -1, 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;
 		}
 		/**
@@ -1494,14 +1611,14 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			geometry: [decode(coords[index * 2]), decode(coords[index * 2 + 1])]
 		};
 	}
-	function getClusterGeoJSON(coords, index, data, i, clusterProps, worldCoordinates) {
+	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(decode(coords[index * 2]), worldCoordinates), unprojectY(decode(coords[index * 2 + 1]), worldCoordinates)]
+				coordinates: [worldCoordinateHelper.unprojectX(decode(coords[index * 2])), worldCoordinateHelper.unprojectY(decode(coords[index * 2 + 1]))]
 			}
 		};
 	}
@@ -1784,7 +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.worldCoordinates && (x < 0 || x >= z2)) return null;
+			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);
@@ -1810,14 +1927,16 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			return transformTile(this.tiles[id], extent);
 		}
 		/**
-		* The features the top tile starts from: all of them in a wrapping world, where wrapping already put them inside,
-		* and only what lies inside the world square and its buffer with `worldCoordinates`. The index keeps the rest, so
-		* an update can still move a feature in from outside.
+		* 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) {
-			if (!this.options.worldCoordinates) return features;
+			const { wrap, coordinates } = this.options;
+			if (wrap && coordinates !== "unitSquare") return features;
 			const buffer = this.options.buffer / this.options.extent;
-			const inX = clip(features, 1, -buffer, 1 + buffer, 0, -Infinity, Infinity, this.options) || [];
+			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) || [];
 		}
 		/**
@@ -1975,7 +2094,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		cluster: false,
 		clusterOptions: defaultClusterOptions,
 		debug: 0,
-		worldCoordinates: false
+		coordinates: "lngLat",
+		wrap: true
 	};
 	/**
 	* Main class for creating and managing a vector tile index from GeoJSON data.
@@ -1983,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);
@@ -1998,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, options.worldCoordinates) : 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);
 		}
@@ -2023,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, this.options.worldCoordinates))) 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
@@ -2051,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, this.options.worldCoordinates);
+			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;
@@ -2133,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) {