@maplibre/geojson-vt 6.2.0 → 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,25 +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 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.");
 	}
@@ -198,55 +255,55 @@ function convertGeometryCollection(features, geojson, geometry, options, index,
 		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;
@@ -264,47 +321,31 @@ function convertLine(ring, out, tolerance, isPolygon, worldCoordinates) {
 	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;
@@ -313,54 +354,39 @@ function featureToGeoJSON(feature, worldCoordinates = false) {
 /**
 * 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
 //#region src/clip.ts
@@ -550,7 +576,7 @@ function intersectY(out, ax, ay, bx, by, y) {
 //#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);
@@ -620,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) {
@@ -641,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);
@@ -654,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);
 		}
@@ -671,28 +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
+* @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,
-			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 = [];
@@ -706,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) {
@@ -1028,7 +1088,9 @@ const defaultClusterOptions = {
 	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.
@@ -1068,9 +1130,9 @@ const OFFSET_PROP = 4;
 * 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 = [];
@@ -1087,8 +1149,8 @@ var ClusterTileIndex = class {
 			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",
@@ -1110,14 +1172,14 @@ var ClusterTileIndex = class {
 		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",
@@ -1134,7 +1196,11 @@ var ClusterTileIndex = class {
 	* @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);
 	}
 	/**
@@ -1182,11 +1248,61 @@ var ClusterTileIndex = class {
 	}
 	/**
 	* 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;
@@ -1212,10 +1328,10 @@ var ClusterTileIndex = class {
 			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);
 	}
 	/**
@@ -1253,7 +1369,7 @@ var ClusterTileIndex = class {
 		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;
@@ -1281,7 +1397,7 @@ var ClusterTileIndex = class {
 		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);
@@ -1295,8 +1411,8 @@ var ClusterTileIndex = class {
 			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;
 	}
 	/**
@@ -1479,14 +1595,14 @@ function getClusterFeature(coords, index, data, i, clusterProps) {
 		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]))]
 		}
 	};
 }
@@ -1766,7 +1882,7 @@ var TileIndex = class {
 	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);
@@ -1792,14 +1908,16 @@ var TileIndex = class {
 		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;
-		return clip(clip(features, 1, -buffer, 1 + buffer, 0, -Infinity, Infinity, this.options) || [], 1, -buffer, 1 + buffer, 1, -Infinity, Infinity, this.options) || [];
+		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.
@@ -1955,7 +2073,8 @@ const defaultOptions = {
 	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.
@@ -1963,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);
@@ -1978,7 +2099,11 @@ var GeoJSONVT = class {
 		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);
 	}
@@ -2003,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, 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
@@ -2031,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, 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;
@@ -2112,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) {