@maplibre/geojson-vt 6.1.2 → 6.2.0

package/dist/geojson-vt.mjs

@@ -162,24 +162,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;
 	switch (geojson.geometry.type) {
 		case "Point":
-			convertPointFeature(features, id, geojson.geometry, geojson.properties);
+			convertPointFeature(features, id, geojson.geometry, worldCoordinates, geojson.properties);
 			return;
 		case "MultiPoint":
-			convertMultiPointFeature(features, id, geojson.geometry, geojson.properties);
+			convertMultiPointFeature(features, id, geojson.geometry, worldCoordinates, geojson.properties);
 			return;
 		case "LineString":
-			convertLineStringFeature(features, id, geojson.geometry, tolerance, geojson.properties);
+			convertLineStringFeature(features, id, geojson.geometry, tolerance, worldCoordinates, geojson.properties);
 			return;
 		case "MultiLineString":
-			convertMultiLineStringFeature(features, id, geojson.geometry, tolerance, options, geojson.properties);
+			convertMultiLineStringFeature(features, id, geojson.geometry, tolerance, worldCoordinates, options, geojson.properties);
 			return;
 		case "Polygon":
-			convertPolygonFeature(features, id, geojson.geometry, tolerance, geojson.properties);
+			convertPolygonFeature(features, id, geojson.geometry, tolerance, worldCoordinates, geojson.properties);
 			return;
 		case "MultiPolygon":
-			convertMultiPolygonFeature(features, id, geojson.geometry, tolerance, geojson.properties);
+			convertMultiPolygonFeature(features, id, geojson.geometry, tolerance, worldCoordinates, geojson.properties);
 			return;
 		default: throw new Error("Input data is not a valid GeoJSON object.");
 	}
@@ -197,53 +198,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, worldCoordinates, properties) {
 	const out = [];
-	out.push(projectX(geom.coordinates[0]), projectY(geom.coordinates[1]), 0);
+	out.push(projectX(geom.coordinates[0], worldCoordinates), projectY(geom.coordinates[1], worldCoordinates), 0);
 	features.push(createFeature(id, "Point", out, properties));
 }
-function convertMultiPointFeature(features, id, geom, properties) {
+function convertMultiPointFeature(features, id, geom, worldCoordinates, 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(projectX(coords[0], worldCoordinates), projectY(coords[1], worldCoordinates), 0);
 	features.push(createFeature(id, "MultiPoint", out, properties));
 }
-function convertLineStringFeature(features, id, geom, tolerance, properties) {
+function convertLineStringFeature(features, id, geom, tolerance, worldCoordinates, properties) {
 	const out = { points: [] };
-	convertLine(geom.coordinates, out, tolerance, false);
+	convertLine(geom.coordinates, out, tolerance, false, worldCoordinates);
 	features.push(createFeature(id, "LineString", out, properties));
 }
-function convertMultiLineStringFeature(features, id, geom, tolerance, options, properties) {
+function convertMultiLineStringFeature(features, id, geom, tolerance, worldCoordinates, options, properties) {
 	if (options.lineMetrics) for (const line of geom.coordinates) {
 		const out = { points: [] };
-		convertLine(line, out, tolerance, false);
+		convertLine(line, out, tolerance, false, worldCoordinates);
 		features.push(createFeature(id, "LineString", out, properties));
 	}
 	else {
 		const out = [];
-		convertLines(geom.coordinates, out, tolerance, false);
+		convertLines(geom.coordinates, out, tolerance, false, worldCoordinates);
 		features.push(createFeature(id, "MultiLineString", out, properties));
 	}
 }
-function convertPolygonFeature(features, id, geom, tolerance, properties) {
+function convertPolygonFeature(features, id, geom, tolerance, worldCoordinates, properties) {
 	const out = [];
-	convertLines(geom.coordinates, out, tolerance, true);
+	convertLines(geom.coordinates, out, tolerance, true, worldCoordinates);
 	features.push(createFeature(id, "Polygon", out, properties));
 }
-function convertMultiPolygonFeature(features, id, geom, tolerance, properties) {
+function convertMultiPolygonFeature(features, id, geom, tolerance, worldCoordinates, properties) {
 	const out = [];
 	for (const polygon of geom.coordinates) {
 		const polygonOut = [];
-		convertLines(polygon, polygonOut, tolerance, true);
+		convertLines(polygon, polygonOut, tolerance, true, worldCoordinates);
+		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, worldCoordinates) {
 	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 = projectX(ring[j][0], worldCoordinates);
+		const y = projectY(ring[j][1], worldCoordinates);
 		out.points.push(x, y, 0);
 		if (j > 0) {
 			if (isPolygon) size += (x0 * y - x * y0) / 2;
@@ -261,23 +264,25 @@ 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, worldCoordinates) {
 	for (let i = 0; i < rings.length; i++) {
 		const geom = { points: [] };
-		convertLine(rings[i], geom, tolerance, isPolygon);
+		convertLine(rings[i], geom, tolerance, isPolygon, worldCoordinates);
 		out.push(geom);
 	}
 }
 /**
-* Convert longitude to spherical mercator in [0..1] range
+* Convert longitude to spherical mercator in [0..1] range, or keep a world coordinate as it is
 */
-function projectX(x) {
+function projectX(x, worldCoordinates = false) {
+	if (worldCoordinates) return x;
 	return x / 360 + .5;
 }
 /**
-* Convert latitude to spherical mercator in [0..1] range
+* Convert latitude to spherical mercator in [0..1] range, or keep a world coordinate as it is
 */
-function projectY(y) {
+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;
@@ -287,19 +292,19 @@ function projectY(y) {
 /**
 * Converts internal source features back to GeoJSON format.
 */
-function convertToGeoJSON(source) {
+function convertToGeoJSON(source, worldCoordinates = false) {
 	return {
 		type: "FeatureCollection",
-		features: source.map((feature) => featureToGeoJSON(feature))
+		features: source.map((feature) => featureToGeoJSON(feature, worldCoordinates))
 	};
 }
 /**
 * Converts a single internal feature to GeoJSON format.
 */
-function featureToGeoJSON(feature) {
+function featureToGeoJSON(feature, worldCoordinates = false) {
 	const geojsonFeature = {
 		type: "Feature",
-		geometry: geometryToGeoJSON(feature),
+		geometry: geometryToGeoJSON(feature, worldCoordinates),
 		properties: feature.tags
 	};
 	if (feature.id != null) geojsonFeature.id = feature.id;
@@ -308,50 +313,52 @@ function featureToGeoJSON(feature) {
 /**
 * Converts a single internal feature geometry to GeoJSON format.
 */
-function geometryToGeoJSON(feature) {
+function geometryToGeoJSON(feature, worldCoordinates) {
 	const { type, geometry } = feature;
 	switch (type) {
 		case "Point": return {
 			type,
-			coordinates: unprojectPoint(geometry[0], geometry[1])
+			coordinates: unprojectPoint(geometry[0], geometry[1], worldCoordinates)
 		};
 		case "MultiPoint": return {
 			type,
-			coordinates: unprojectPoints(geometry)
+			coordinates: unprojectPoints(geometry, worldCoordinates)
 		};
 		case "LineString": return {
 			type,
-			coordinates: unprojectPoints(geometry.points)
+			coordinates: unprojectPoints(geometry.points, worldCoordinates)
 		};
 		case "MultiLineString":
 		case "Polygon": return {
 			type,
-			coordinates: geometry.map((ring) => unprojectPoints(ring.points))
+			coordinates: geometry.map((ring) => unprojectPoints(ring.points, worldCoordinates))
 		};
 		case "MultiPolygon": return {
 			type,
-			coordinates: geometry.map((polygon) => polygon.map((ring) => unprojectPoints(ring.points)))
+			coordinates: geometry.map((polygon) => polygon.map((ring) => unprojectPoints(ring.points, worldCoordinates)))
 		};
 	}
 }
-function unprojectPoints(coords) {
+function unprojectPoints(coords, worldCoordinates = false) {
 	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], worldCoordinates));
 	return result;
 }
-function unprojectPoint(x, y) {
-	return [unprojectX(x), unprojectY(y)];
+function unprojectPoint(x, y, worldCoordinates) {
+	return [unprojectX(x, worldCoordinates), unprojectY(y, worldCoordinates)];
 }
 /**
-* Convert spherical mercator in [0..1] range to longitude
+* Convert spherical mercator in [0..1] range to longitude, or keep a world coordinate as it is
 */
-function unprojectX(x) {
+function unprojectX(x, worldCoordinates = false) {
+	if (worldCoordinates) return x;
 	return (x - .5) * 360;
 }
 /**
-* Convert spherical mercator in [0..1] range to latitude
+* Convert spherical mercator in [0..1] range to latitude, or keep a world coordinate as it is
 */
-function unprojectY(y) {
+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;
 }
@@ -478,12 +485,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 +550,7 @@ function intersectY(out, ax, ay, bx, by, y) {
 //#endregion
 //#region src/wrap.ts
 function wrap(features, options) {
+	if (options.worldCoordinates) return features;
 	const buffer = options.buffer / options.extent;
 	let merged = features;
 	const left = clip(features, 1, -1 - buffer, buffer, 0, -1, 2, options);
@@ -663,7 +671,7 @@ 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.
+* @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) {
 	const changeGeometry = !!update.newGeometry;
@@ -678,7 +686,11 @@ function getUpdatedFeatures(vtFeatures, update, options) {
 				geometry: update.newGeometry,
 				properties: changeProps ? applyPropertyUpdates(vtFeature.tags, update) : vtFeature.tags
 			}]
-		}, options);
+		}, {
+			...options,
+			promoteId: void 0,
+			generateId: false
+		});
 		features = wrap(features, options);
 		return features;
 	}
@@ -715,7 +727,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]))
 	};
 }
@@ -1018,52 +1030,101 @@ const defaultClusterOptions = {
 	reduce: null,
 	map: (props) => props
 };
-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);
+	constructor(options, worldCoordinates = false) {
+		this.options = createOptions(options);
+		this.worldCoordinates = worldCoordinates;
 		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] = [projectX(lng, this.worldCoordinates), projectY(lat, this.worldCoordinates)];
+				if (this.worldCoordinates && !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.worldCoordinates && !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;
+				points.push({
+					id: feature.id,
+					type: "Point",
+					geometry,
+					tags: feature.tags
+				});
+			}
 		}
 		this.createIndex(points);
 	}
@@ -1073,41 +1134,59 @@ var ClusterTileIndex = class {
 	* @param features 
 	*/
 	updateIndex(features, _affected, options) {
-		this.options = Object.assign(Object.create(defaultClusterOptions), options.clusterOptions);
+		this.options = createOptions(options.clusterOptions);
 		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 world coordinates.
 	* @param zoom - Zoom level to query.
 	*/
 	getClusters(bbox, zoom) {
-		return this.getClustersInternal(bbox, zoom).map((f) => featureToGeoJSON(f));
+		return (this.worldCoordinates ? this.getClustersInRange(bbox, zoom) : this.getClustersInternal(bbox, zoom)).map((f) => featureToGeoJSON(f, this.worldCoordinates));
 	}
 	getClustersInternal(bbox, zoom) {
 		let minLng = ((bbox[0] + 180) % 360 + 360) % 360 - 180;
@@ -1132,13 +1211,25 @@ var ClusterTileIndex = class {
 			], zoom);
 			return easternHem.concat(westernHem);
 		}
+		return this.getClustersInRange([
+			projectX(minLng),
+			projectY(maxLat),
+			projectX(maxLng),
+			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 +1243,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.worldCoordinates) : featureToGeoJSON(this.points[data[k + OFFSET_ID]], this.worldCoordinates));
 		}
 		if (children.length === 0) throw clusterError;
 		return children;
@@ -1189,10 +1281,11 @@ 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;
 		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 +1294,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.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);
 		return tile;
 	}
 	/**
@@ -1226,15 +1319,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 +1348,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 +1370,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 +1401,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 +1421,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 +1465,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, worldCoordinates) {
 	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: [unprojectX(decode(coords[index * 2]), worldCoordinates), unprojectY(decode(coords[index * 2 + 1]), worldCoordinates)]
 		}
 	};
 }
@@ -1368,6 +1502,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 +1713,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 +1733,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 +1766,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;
 		x = x + z2 & z2 - 1;
 		const id = toID(z, x, y);
 		if (this.tiles[id]) return transformTile(this.tiles[id], extent);
@@ -1653,6 +1792,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.
+	*/
+	clipToWorld(features) {
+		if (!this.options.worldCoordinates) 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) || [];
+	}
+	/**
 	* 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 +1954,8 @@ const defaultOptions = {
 	updateable: false,
 	cluster: false,
 	clusterOptions: defaultClusterOptions,
-	debug: 0
+	debug: 0,
+	worldCoordinates: false
 };
 /**
 * Main class for creating and managing a vector tile index from GeoJSON data.
@@ -1828,7 +1978,7 @@ 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, options.worldCoordinates) : new TileIndex(options);
 		if (!features.length) return;
 		this.tileIndex.initialize(features);
 	}
@@ -1866,7 +2016,7 @@ var GeoJSONVT = class {
 		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.options.worldCoordinates))) continue;
 			affected.push(feature);
 			removeIds.add(feature.id);
 		}
@@ -1881,7 +2031,7 @@ 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.options.worldCoordinates);
 	}
 	/**
 	* Update supercluster options and regenerate the index.