@tangram.gl/basemap-layers 0.0.0-stage → 0.0.0

package/dist/geojson-worker.js

@@ -0,0 +1,2160 @@
+"use strict";
+(() => {
+  // ../../node_modules/@maplibre/geojson-vt/dist/geojson-vt.mjs
+  function simplify(coords, first, last, sqTolerance) {
+    const stack = [first, last];
+    while (stack.length) {
+      last = stack.pop();
+      first = stack.pop();
+      simplifySegment(coords, first, last, sqTolerance, stack);
+    }
+  }
+  function simplifySegment(coords, first, last, sqTolerance, stack) {
+    let maxSqDist = sqTolerance;
+    const mid = first + (last - first >> 1);
+    let minPosToMid = last - first;
+    let index;
+    const ax = coords[first];
+    const ay = coords[first + 1];
+    const bx = coords[last];
+    const by = coords[last + 1];
+    for (let i = first + 3; i < last; i += 3) {
+      const d = getSqSegDist(coords[i], coords[i + 1], ax, ay, bx, by);
+      if (d > maxSqDist) {
+        index = i;
+        maxSqDist = d;
+        continue;
+      }
+      if (d === maxSqDist) {
+        const posToMid = Math.abs(i - mid);
+        if (posToMid < minPosToMid) {
+          index = i;
+          minPosToMid = posToMid;
+        }
+      }
+    }
+    if (maxSqDist > sqTolerance) {
+      coords[index + 2] = maxSqDist;
+      if (index - first > 3) stack.push(first, index);
+      if (last - index > 3) stack.push(index, last);
+    }
+  }
+  function getSqSegDist(px, py, x, y, bx, by) {
+    let dx = bx - x;
+    let dy = by - y;
+    if (dx !== 0 || dy !== 0) {
+      const t = ((px - x) * dx + (py - y) * dy) / (dx * dx + dy * dy);
+      if (t > 1) {
+        x = bx;
+        y = by;
+      } else if (t > 0) {
+        x += dx * t;
+        y += dy * t;
+      }
+    }
+    dx = px - x;
+    dy = py - y;
+    return dx * dx + dy * dy;
+  }
+  function createFeature(id, type, geom, tags) {
+    const data = {
+      type,
+      geom
+    };
+    const feature = {
+      id: id == null ? null : id,
+      type: data.type,
+      geometry: data.geom,
+      tags,
+      minX: Infinity,
+      minY: Infinity,
+      maxX: -Infinity,
+      maxY: -Infinity
+    };
+    switch (data.type) {
+      case "Point":
+      case "MultiPoint":
+        calcLineBBox(feature, data.geom);
+        break;
+      case "LineString":
+        calcLineBBox(feature, data.geom.points);
+        break;
+      case "Polygon":
+        calcLineBBox(feature, data.geom[0].points);
+        break;
+      case "MultiLineString":
+        for (const line of data.geom) calcLineBBox(feature, line.points);
+        break;
+      case "MultiPolygon":
+        for (const polygon of data.geom) calcLineBBox(feature, polygon[0].points);
+    }
+    return feature;
+  }
+  function optimizeLineMemory(line) {
+    const lineImmutable = line;
+    if (line.points.length > 64) lineImmutable.points = new Float64Array(line.points);
+  }
+  function calcLineBBox(feature, geom) {
+    for (let i = 0; i < geom.length; i += 3) {
+      feature.minX = Math.min(feature.minX, geom[i]);
+      feature.minY = Math.min(feature.minY, geom[i + 1]);
+      feature.maxX = Math.max(feature.maxX, geom[i]);
+      feature.maxY = Math.max(feature.maxY, geom[i + 1]);
+    }
+  }
+  var MercatorWorldCoordinateHelper = class {
+    projectX(lng) {
+      return lng / 360 + 0.5;
+    }
+    projectY(lat) {
+      const sin = Math.sin(lat * Math.PI / 180);
+      const y = 0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI;
+      return y < 0 ? 0 : y > 1 ? 1 : y;
+    }
+    unprojectX(x) {
+      return (x - 0.5) * 360;
+    }
+    unprojectY(y) {
+      const y2 = (180 - y * 360) * Math.PI / 180;
+      return 360 * Math.atan(Math.exp(y2)) / Math.PI - 90;
+    }
+  };
+  var IdentityWorldCoordinateHelper = class {
+    projectX(x) {
+      return x;
+    }
+    projectY(y) {
+      return y;
+    }
+    unprojectX(x) {
+      return x;
+    }
+    unprojectY(y) {
+      return y;
+    }
+  };
+  var mercatorWorldCoordinateHelper = new MercatorWorldCoordinateHelper();
+  var identityWorldCoordinateHelper = new IdentityWorldCoordinateHelper();
+  function getWorldCoordinateHelper(coordinates) {
+    return coordinates === "unitSquare" ? identityWorldCoordinateHelper : mercatorWorldCoordinateHelper;
+  }
+  var MAX_GEOMETRY_COLLECTION_DEPTH = 1024;
+  function convertToInternal(data, options, unlocated) {
+    const features = [];
+    switch (data.type) {
+      case "FeatureCollection":
+        for (let i = 0; i < data.features.length; i++) convertFeature(features, data.features[i], options, unlocated, i);
+        break;
+      case "Feature":
+        convertFeature(features, data, options, unlocated);
+        break;
+      default:
+        convertFeature(features, {
+          type: "Feature",
+          geometry: data,
+          properties: void 0
+        }, 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");
+    if (geojson.geometry.type === "GeometryCollection") {
+      convertGeometryCollection(features, geojson, geojson.geometry, options, index, depth + 1);
+      return;
+    }
+    if (!geojson.geometry.coordinates?.length) return;
+    const id = getFeatureId(geojson, options, index);
+    const tolerance = Math.pow(options.tolerance / ((1 << options.maxZoom) * options.extent), 2);
+    const worldCoordinateHelper = getWorldCoordinateHelper(options.coordinates);
+    switch (geojson.geometry.type) {
+      case "Point":
+        convertPointFeature(features, id, geojson.geometry, worldCoordinateHelper, geojson.properties);
+        return;
+      case "MultiPoint":
+        convertMultiPointFeature(features, id, geojson.geometry, worldCoordinateHelper, geojson.properties);
+        return;
+      case "LineString":
+        convertLineStringFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, geojson.properties);
+        return;
+      case "MultiLineString":
+        convertMultiLineStringFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, options, geojson.properties);
+        return;
+      case "Polygon":
+        convertPolygonFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, geojson.properties);
+        return;
+      case "MultiPolygon":
+        convertMultiPolygonFeature(features, id, geojson.geometry, tolerance, worldCoordinateHelper, geojson.properties);
+        return;
+      default:
+        throw new Error("Input data is not a valid GeoJSON object.");
+    }
+  }
+  function getFeatureId(geojson, options, index) {
+    if (options.promoteId) return geojson.properties?.[options.promoteId];
+    if (options.generateId) return index || 0;
+    return geojson.id;
+  }
+  function convertGeometryCollection(features, geojson, geometry, options, index, depth = 0) {
+    for (const geom of geometry.geometries) featureToInternal(features, {
+      id: geojson.id,
+      type: "Feature",
+      geometry: geom,
+      properties: geojson.properties
+    }, options, index, depth);
+  }
+  function convertPointFeature(features, id, geom, worldCoordinateHelper, properties) {
+    const out = [];
+    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, worldCoordinateHelper, properties) {
+    const out = [];
+    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, worldCoordinateHelper, properties) {
+    const out = { points: [] };
+    convertLine(geom.coordinates, out, tolerance, false, worldCoordinateHelper);
+    features.push(createFeature(id, "LineString", out, 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, worldCoordinateHelper);
+      features.push(createFeature(id, "LineString", out, properties));
+    }
+    else {
+      const out = [];
+      convertLines(geom.coordinates, out, tolerance, false, worldCoordinateHelper);
+      features.push(createFeature(id, "MultiLineString", out, properties));
+    }
+  }
+  function convertPolygonFeature(features, id, geom, tolerance, worldCoordinateHelper, properties) {
+    const out = [];
+    convertLines(geom.coordinates, out, tolerance, true, worldCoordinateHelper);
+    features.push(createFeature(id, "Polygon", out, properties));
+  }
+  function convertMultiPolygonFeature(features, id, geom, tolerance, worldCoordinateHelper, properties) {
+    const out = [];
+    for (const polygon of geom.coordinates) {
+      const polygonOut = [];
+      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, worldCoordinateHelper) {
+    let x0, y0;
+    let size = 0;
+    for (let j = 0; j < ring.length; j++) {
+      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;
+        else size += Math.sqrt(Math.pow(x - x0, 2) + Math.pow(y - y0, 2));
+      }
+      x0 = x;
+      y0 = y;
+    }
+    const last = out.points.length - 3;
+    out.points[2] = 1;
+    if (tolerance > 0) simplify(out.points, 0, last, tolerance);
+    out.points[last + 2] = 1;
+    optimizeLineMemory(out);
+    out.size = Math.abs(size);
+    out.start = 0;
+    out.end = out.size;
+  }
+  function convertLines(rings, out, tolerance, isPolygon, worldCoordinateHelper) {
+    for (let i = 0; i < rings.length; i++) {
+      const geom = { points: [] };
+      convertLine(rings[i], geom, tolerance, isPolygon, worldCoordinateHelper);
+      out.push(geom);
+    }
+  }
+  function convertToGeoJSON(source, worldCoordinateHelper = mercatorWorldCoordinateHelper) {
+    return {
+      type: "FeatureCollection",
+      features: source.map((feature) => featureToGeoJSON(feature, worldCoordinateHelper))
+    };
+  }
+  function featureToGeoJSON(feature, worldCoordinateHelper = mercatorWorldCoordinateHelper) {
+    const geojsonFeature = {
+      type: "Feature",
+      geometry: geometryToGeoJSON(feature, worldCoordinateHelper),
+      properties: feature.tags
+    };
+    if (feature.id != null) geojsonFeature.id = feature.id;
+    return geojsonFeature;
+  }
+  function geometryToGeoJSON(feature, worldCoordinateHelper) {
+    const { type, geometry } = feature;
+    switch (type) {
+      case "Point":
+        return {
+          type,
+          coordinates: unprojectPoint(geometry[0], geometry[1], worldCoordinateHelper)
+        };
+      case "MultiPoint":
+        return {
+          type,
+          coordinates: unprojectPoints(geometry, worldCoordinateHelper)
+        };
+      case "LineString":
+        return {
+          type,
+          coordinates: unprojectPoints(geometry.points, worldCoordinateHelper)
+        };
+      case "MultiLineString":
+      case "Polygon":
+        return {
+          type,
+          coordinates: geometry.map((ring) => unprojectPoints(ring.points, worldCoordinateHelper))
+        };
+      case "MultiPolygon":
+        return {
+          type,
+          coordinates: geometry.map((polygon) => polygon.map((ring) => unprojectPoints(ring.points, worldCoordinateHelper)))
+        };
+    }
+  }
+  function unprojectPoints(coords, worldCoordinateHelper = mercatorWorldCoordinateHelper) {
+    const result = [];
+    for (let i = 0; i < coords.length; i += 3) result.push(unprojectPoint(coords[i], coords[i + 1], worldCoordinateHelper));
+    return result;
+  }
+  function unprojectPoint(x, y, worldCoordinateHelper) {
+    return [worldCoordinateHelper.unprojectX(x), worldCoordinateHelper.unprojectY(y)];
+  }
+  function clip(features, scale, start, end, axis, minAll, maxAll, options) {
+    start /= scale;
+    end /= scale;
+    if (minAll >= start && maxAll < end) return features;
+    if (maxAll < start || minAll >= end) return null;
+    const clipped = [];
+    for (const feature of features) {
+      const min = axis === 0 ? feature.minX : feature.minY;
+      const max = axis === 0 ? feature.maxX : feature.maxY;
+      if (min >= start && max < end) {
+        clipped.push(feature);
+        continue;
+      }
+      if (max < start || min >= end) continue;
+      switch (feature.type) {
+        case "Point":
+        case "MultiPoint":
+          clipPointFeature(feature, clipped, start, end, axis);
+          continue;
+        case "LineString":
+          clipLineStringFeature(feature, clipped, start, end, axis, options);
+          continue;
+        case "MultiLineString":
+          clipMultiLineStringFeature(feature, clipped, start, end, axis);
+          continue;
+        case "Polygon":
+          clipPolygonFeature(feature, clipped, start, end, axis);
+          continue;
+        case "MultiPolygon":
+          clipMultiPolygonFeature(feature, clipped, start, end, axis);
+          continue;
+      }
+    }
+    if (!clipped.length) return null;
+    return clipped;
+  }
+  function clipPointFeature(feature, clipped, start, end, axis) {
+    const geom = [];
+    clipPoints(feature.geometry, geom, start, end, axis);
+    if (!geom.length) return;
+    const type = geom.length === 3 ? "Point" : "MultiPoint";
+    clipped.push(createFeature(feature.id, type, geom, feature.tags));
+  }
+  function clipLineStringFeature(feature, clipped, start, end, axis, options) {
+    const geom = [];
+    clipLine(feature.geometry, geom, start, end, axis, false, options.lineMetrics);
+    if (!geom.length) return;
+    if (options.lineMetrics) {
+      for (const line of geom) clipped.push(createFeature(feature.id, "LineString", line, feature.tags));
+      return;
+    }
+    if (geom.length > 1) {
+      clipped.push(createFeature(feature.id, "MultiLineString", geom, feature.tags));
+      return;
+    }
+    clipped.push(createFeature(feature.id, "LineString", geom[0], feature.tags));
+  }
+  function clipMultiLineStringFeature(feature, clipped, start, end, axis) {
+    const geom = [];
+    clipLines(feature.geometry, geom, start, end, axis, false);
+    if (!geom.length) return;
+    if (geom.length === 1) {
+      clipped.push(createFeature(feature.id, "LineString", geom[0], feature.tags));
+      return;
+    }
+    clipped.push(createFeature(feature.id, "MultiLineString", geom, feature.tags));
+  }
+  function clipPolygonFeature(feature, clipped, start, end, axis) {
+    const geom = [];
+    clipLines(feature.geometry, geom, start, end, axis, true);
+    if (!geom.length) return;
+    clipped.push(createFeature(feature.id, "Polygon", geom, feature.tags));
+  }
+  function clipMultiPolygonFeature(feature, clipped, start, end, axis) {
+    const geom = [];
+    for (const polygon of feature.geometry) {
+      const newPolygon = [];
+      clipLines(polygon, newPolygon, start, end, axis, true);
+      if (!newPolygon.length) continue;
+      geom.push(newPolygon);
+    }
+    if (!geom.length) return;
+    clipped.push(createFeature(feature.id, "MultiPolygon", geom, feature.tags));
+  }
+  function clipPoints(geom, newGeom, start, end, axis) {
+    for (let i = 0; i < geom.length; i += 3) {
+      const a = geom[i + axis];
+      if (a >= start && a <= end) addPoint(newGeom, geom[i], geom[i + 1], geom[i + 2]);
+    }
+  }
+  function clipLine(geom, newGeom, start, end, axis, isPolygon, trackMetrics) {
+    let slice = newSlice(geom);
+    const intersect = axis === 0 ? intersectX : intersectY;
+    let len = geom.start;
+    let segLen, t;
+    for (let i = 0; i < geom.points.length - 3; i += 3) {
+      const ax2 = geom.points[i];
+      const ay2 = geom.points[i + 1];
+      const az2 = geom.points[i + 2];
+      const bx = geom.points[i + 3];
+      const by = geom.points[i + 4];
+      const a2 = axis === 0 ? ax2 : ay2;
+      const b = axis === 0 ? bx : by;
+      let exited = false;
+      if (trackMetrics) segLen = Math.sqrt(Math.pow(ax2 - bx, 2) + Math.pow(ay2 - by, 2));
+      if (a2 < start) {
+        if (b >= start) {
+          t = intersect(slice, ax2, ay2, bx, by, start);
+          if (trackMetrics) slice.start = len + segLen * t;
+        }
+      } else if (a2 > end) {
+        if (b <= end) {
+          t = intersect(slice, ax2, ay2, bx, by, end);
+          if (trackMetrics) slice.start = len + segLen * t;
+        }
+      } else addPoint(slice.points, ax2, ay2, az2);
+      if (b < start && a2 >= start) {
+        t = intersect(slice, ax2, ay2, bx, by, start);
+        exited = true;
+      }
+      if (b > end && a2 <= end) {
+        t = intersect(slice, ax2, ay2, bx, by, end);
+        exited = true;
+      }
+      if (!isPolygon && exited) {
+        if (trackMetrics) slice.end = len + segLen * t;
+        newGeom.push(slice);
+        slice = newSlice(geom);
+      }
+      if (trackMetrics) len += segLen;
+    }
+    let last = geom.points.length - 3;
+    const ax = geom.points[last];
+    const ay = geom.points[last + 1];
+    const az = geom.points[last + 2];
+    const a = axis === 0 ? ax : ay;
+    if (a >= start && a <= end) addPoint(slice.points, ax, ay, az);
+    last = slice.points.length - 3;
+    if (isPolygon && last >= 3 && (slice.points[last] !== slice.points[0] || slice.points[last + 1] !== slice.points[1])) addPoint(slice.points, slice.points[0], slice.points[1], slice.points[2]);
+    if (slice.points.length) {
+      optimizeLineMemory(slice);
+      newGeom.push(slice);
+    }
+  }
+  function newSlice(line) {
+    return {
+      points: [],
+      size: line.size,
+      start: line.start,
+      end: line.end
+    };
+  }
+  function clipLines(geom, newGeom, start, end, axis, isPolygon) {
+    for (const line of geom) clipLine(line, newGeom, start, end, axis, isPolygon, false);
+  }
+  function addPoint(out, x, y, z) {
+    out.push(x, y, z);
+  }
+  function intersectX(out, ax, ay, bx, by, x) {
+    const t = (x - ax) / (bx - ax);
+    addPoint(out.points, x, ay + (by - ay) * t, 1);
+    return t;
+  }
+  function intersectY(out, ax, ay, bx, by, y) {
+    const t = (y - ay) / (by - ay);
+    addPoint(out.points, ax + (bx - ax) * t, y, 1);
+    return t;
+  }
+  function wrap(features, options) {
+    if (!options.wrap) return features;
+    const buffer = options.buffer / options.extent;
+    let merged = features;
+    const left = clip(features, 1, -1 - buffer, buffer, 0, -1, 2, options);
+    const right = clip(features, 1, 1 - buffer, 2 + buffer, 0, -1, 2, options);
+    if (!left && !right) return merged;
+    merged = clip(features, 1, -buffer, 1 + buffer, 0, -1, 2, options) || [];
+    if (left) merged = shiftFeatureCoords(left, 1).concat(merged);
+    if (right) merged = merged.concat(shiftFeatureCoords(right, -1));
+    return merged;
+  }
+  function shiftFeatureCoords(features, offset) {
+    const newFeatures = [];
+    for (const feature of features) switch (feature.type) {
+      case "Point":
+      case "MultiPoint": {
+        const newGeometry = shiftPointCoords(feature.geometry, offset);
+        newFeatures.push(createFeature(feature.id, feature.type, newGeometry, feature.tags));
+        continue;
+      }
+      case "LineString": {
+        const newGeometry = shiftLineCoords(feature.geometry, offset);
+        newFeatures.push(createFeature(feature.id, feature.type, newGeometry, feature.tags));
+        continue;
+      }
+      case "MultiLineString":
+      case "Polygon": {
+        const newGeometry = [];
+        for (const line of feature.geometry) newGeometry.push(shiftLineCoords(line, offset));
+        newFeatures.push(createFeature(feature.id, feature.type, newGeometry, feature.tags));
+        continue;
+      }
+      case "MultiPolygon": {
+        const newGeometry = [];
+        for (const polygon of feature.geometry) {
+          const newPolygon = [];
+          for (const line of polygon) newPolygon.push(shiftLineCoords(line, offset));
+          newGeometry.push(newPolygon);
+        }
+        newFeatures.push(createFeature(feature.id, feature.type, newGeometry, feature.tags));
+        continue;
+      }
+    }
+    return newFeatures;
+  }
+  function shiftPointCoords(coords, offset) {
+    const newCoords = [];
+    for (let i = 0; i < coords.length; i += 3) newCoords.push(coords[i] + offset, coords[i + 1], coords[i + 2]);
+    return newCoords;
+  }
+  function shiftLineCoords(line, offset) {
+    const newLine = {
+      points: [],
+      size: line.size
+    };
+    if (line.start !== void 0) {
+      newLine.start = line.start;
+      newLine.end = line.end;
+    }
+    for (let i = 0; i < line.points.length; i += 3) newLine.points.push(line.points[i] + offset, line.points[i + 1], line.points[i + 2]);
+    optimizeLineMemory(newLine);
+    return newLine;
+  }
+  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) {
+        affected = affected.concat(removeFeatures);
+        const removeIds = new Set(removeFeatures.map((f) => f.id));
+        source = source.filter((f) => !removeIds.has(f.id));
+      }
+      if (diff.add.size) {
+        let addFeatures = convertToInternal({
+          type: "FeatureCollection",
+          features: Array.from(diff.add.values())
+        }, options, unlocated);
+        addFeatures = wrap(addFeatures, options);
+        affected = affected.concat(addFeatures);
+        source = source.concat(addFeatures);
+      }
+    }
+    if (diff.update.size) {
+      const oldFeaturesMap = /* @__PURE__ */ new Map();
+      let keepFeatures = [];
+      for (const feature of source) if (diff.update.has(feature.id)) oldFeaturesMap.set(feature.id, [...oldFeaturesMap.get(feature.id) || [], feature]);
+      else keepFeatures.push(feature);
+      for (const [id, update] of diff.update) {
+        const oldFeatures = oldFeaturesMap.get(id);
+        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);
+      }
+      source = keepFeatures;
+    }
+    return {
+      affected,
+      source
+    };
+  }
+  function getUpdatedFeatures(vtFeatures, update, options, unlocated) {
+    const changeGeometry = !!update.newGeometry;
+    const changeProps = hasPropertyChanges(update);
+    if (changeGeometry) {
+      const vtFeature = vtFeatures[0];
+      const properties = changeProps ? applyPropertyUpdates(vtFeature.tags, update) : vtFeature.tags;
+      return convertNewGeometry(vtFeature.id, update.newGeometry, properties, options, unlocated);
+    }
+    if (changeProps) {
+      const updated = [];
+      for (const vtFeature of vtFeatures) {
+        const feature = { ...vtFeature };
+        feature.tags = applyPropertyUpdates(feature.tags, update);
+        updated.push(feature);
+      }
+      return updated;
+    }
+    return vtFeatures;
+  }
+  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);
+  }
+  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;
+  }
+  function applyPropertyUpdates(tags, update) {
+    if (update.removeAllProperties) return {};
+    const properties = { ...tags || {} };
+    if (update.removeProperties) for (const key of update.removeProperties) delete properties[key];
+    if (update.addOrUpdateProperties) for (const { key, value } of update.addOrUpdateProperties) properties[key] = value;
+    return properties;
+  }
+  function diffToHashed(diff, options) {
+    if (!diff) return {
+      remove: /* @__PURE__ */ new Set(),
+      add: /* @__PURE__ */ new Map(),
+      update: /* @__PURE__ */ new Map()
+    };
+    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])),
+      update: new Map(diff.update?.map((update) => [update.id, update]))
+    };
+  }
+  var ARRAY_TYPES = [
+    Int8Array,
+    Uint8Array,
+    Uint8ClampedArray,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array
+  ];
+  var VERSION = 1;
+  var HEADER_SIZE = 8;
+  var STACK = /* @__PURE__ */ new Uint32Array(96);
+  var KDBush = class KDBush2 {
+    /**
+    * Creates an index from raw `ArrayBuffer` data.
+    * @param {ArrayBufferLike} data
+    */
+    static from(data) {
+      if (!data || data.byteLength === void 0 || data.buffer) throw new Error("Data must be an instance of ArrayBuffer or SharedArrayBuffer.");
+      const [magic, versionAndType] = new Uint8Array(data, 0, 2);
+      if (magic !== 219) throw new Error("Data does not appear to be in a KDBush format.");
+      const version = versionAndType >> 4;
+      if (version !== VERSION) throw new Error(`Got v${version} data when expected v${VERSION}.`);
+      const ArrayType = ARRAY_TYPES[versionAndType & 15];
+      if (!ArrayType) throw new Error("Unrecognized array type.");
+      const [nodeSize] = new Uint16Array(data, 2, 1);
+      const [numItems] = new Uint32Array(data, 4, 1);
+      return new KDBush2(numItems, nodeSize, ArrayType, void 0, data);
+    }
+    /**
+    * Creates an index that will hold a given number of items.
+    * @param {number} numItems
+    * @param {number} [nodeSize=64] Size of the KD-tree node (64 by default).
+    * @param {TypedArrayConstructor} [ArrayType=Float64Array] The array type used for coordinates storage (`Float64Array` by default).
+    * @param {ArrayBufferConstructor | SharedArrayBufferConstructor} [ArrayBufferType=ArrayBuffer] The array buffer type used for storage (`ArrayBuffer` by default).
+    * @param {ArrayBufferLike} [data] (For internal use only)
+    */
+    constructor(numItems, nodeSize = 64, ArrayType = Float64Array, ArrayBufferType = ArrayBuffer, data) {
+      if (isNaN(numItems) || numItems < 0) throw new Error(`Unexpected numItems value: ${numItems}.`);
+      this.numItems = +numItems;
+      this.nodeSize = Math.min(Math.max(+nodeSize, 2), 65535);
+      this.ArrayType = ArrayType;
+      this.IndexArrayType = numItems < 65536 ? Uint16Array : Uint32Array;
+      const arrayTypeIndex = ARRAY_TYPES.indexOf(this.ArrayType);
+      const coordsByteSize = numItems * 2 * this.ArrayType.BYTES_PER_ELEMENT;
+      const idsByteSize = numItems * this.IndexArrayType.BYTES_PER_ELEMENT;
+      const padCoords = (8 - idsByteSize % 8) % 8;
+      if (arrayTypeIndex < 0) throw new Error(`Unexpected typed array class: ${ArrayType}.`);
+      if (data) {
+        this.data = data;
+        this.ids = new this.IndexArrayType(data, HEADER_SIZE, numItems);
+        this.coords = new ArrayType(data, HEADER_SIZE + idsByteSize + padCoords, numItems * 2);
+        this._pos = numItems * 2;
+        this._finished = true;
+      } else {
+        const data2 = this.data = new ArrayBufferType(HEADER_SIZE + coordsByteSize + idsByteSize + padCoords);
+        this.ids = new this.IndexArrayType(data2, HEADER_SIZE, numItems);
+        this.coords = new ArrayType(data2, HEADER_SIZE + idsByteSize + padCoords, numItems * 2);
+        this._pos = 0;
+        this._finished = false;
+        new Uint8Array(data2, 0, 2).set([219, 16 + arrayTypeIndex]);
+        new Uint16Array(data2, 2, 1)[0] = nodeSize;
+        new Uint32Array(data2, 4, 1)[0] = numItems;
+      }
+    }
+    /**
+    * Add a point to the index.
+    * @param {number} x
+    * @param {number} y
+    * @returns {number} An incremental index associated with the added item (starting from `0`).
+    */
+    add(x, y) {
+      const index = this._pos >> 1;
+      this.ids[index] = index;
+      this.coords[this._pos++] = x;
+      this.coords[this._pos++] = y;
+      return index;
+    }
+    /**
+    * Perform indexing of the added points.
+    */
+    finish() {
+      const numAdded = this._pos >> 1;
+      if (numAdded !== this.numItems) throw new Error(`Added ${numAdded} items when expected ${this.numItems}.`);
+      sort(this.ids, this.coords, this.nodeSize, 0, this.numItems - 1, 0);
+      this._finished = true;
+      return this;
+    }
+    /**
+    * Search the index for items within a given bounding box.
+    * @param {number} minX
+    * @param {number} minY
+    * @param {number} maxX
+    * @param {number} maxY
+    * @returns {number[]} An array of indices correponding to the found items.
+    */
+    range(minX, minY, maxX, maxY) {
+      if (!this._finished) throw new Error("Data not yet indexed - call index.finish().");
+      const { ids, coords, nodeSize } = this;
+      STACK[0] = 0;
+      STACK[1] = ids.length - 1;
+      STACK[2] = 0;
+      let sp = 3;
+      const result = [];
+      while (sp > 0) {
+        const axis = STACK[--sp];
+        const right = STACK[--sp];
+        const left = STACK[--sp];
+        if (right - left <= nodeSize) {
+          for (let i = left; i <= right; i++) {
+            const x2 = coords[2 * i];
+            const y2 = coords[2 * i + 1];
+            if (x2 >= minX && x2 <= maxX && y2 >= minY && y2 <= maxY) result.push(ids[i]);
+          }
+          continue;
+        }
+        const m = left + right >> 1;
+        const x = coords[2 * m];
+        const y = coords[2 * m + 1];
+        if (x >= minX && x <= maxX && y >= minY && y <= maxY) result.push(ids[m]);
+        if (axis === 0 ? minX <= x : minY <= y) {
+          STACK[sp++] = left;
+          STACK[sp++] = m - 1;
+          STACK[sp++] = 1 - axis;
+        }
+        if (axis === 0 ? maxX >= x : maxY >= y) {
+          STACK[sp++] = m + 1;
+          STACK[sp++] = right;
+          STACK[sp++] = 1 - axis;
+        }
+      }
+      return result;
+    }
+    /**
+    * Search the index for items within a given radius.
+    * @param {number} qx
+    * @param {number} qy
+    * @param {number} r Query radius.
+    * @returns {number[]} An array of indices correponding to the found items.
+    */
+    within(qx, qy, r) {
+      const result = [];
+      this.withinInto(qx, qy, r, result);
+      return result;
+    }
+    /**
+    * Search the index for items within a given radius, writing matching ids into `out`
+    * via indexed assignment (`out[i] = id`). Accepts any indexed-writable container —
+    * a typed array sized to the expected upper bound (allocation-free, fast) or a plain
+    * `Array` (which will grow as needed). Returns the number of matches written.
+    * @param {number} qx
+    * @param {number} qy
+    * @param {number} r Query radius.
+    * @param {number[] | TypedArray} out Container to write matching ids into.
+    * @returns {number} The number of matches written to `out`.
+    */
+    withinInto(qx, qy, r, out) {
+      if (!this._finished) throw new Error("Data not yet indexed - call index.finish().");
+      const { ids, coords, nodeSize } = this;
+      STACK[0] = 0;
+      STACK[1] = ids.length - 1;
+      STACK[2] = 0;
+      let sp = 3;
+      let count = 0;
+      const r2 = r * r;
+      while (sp > 0) {
+        const axis = STACK[--sp];
+        const right = STACK[--sp];
+        const left = STACK[--sp];
+        if (right - left <= nodeSize) {
+          for (let i = left; i <= right; i++) if (sqDist(coords[2 * i], coords[2 * i + 1], qx, qy) <= r2) out[count++] = ids[i];
+          continue;
+        }
+        const m = left + right >> 1;
+        const x = coords[2 * m];
+        const y = coords[2 * m + 1];
+        if (sqDist(x, y, qx, qy) <= r2) out[count++] = ids[m];
+        if (axis === 0 ? qx - r <= x : qy - r <= y) {
+          STACK[sp++] = left;
+          STACK[sp++] = m - 1;
+          STACK[sp++] = 1 - axis;
+        }
+        if (axis === 0 ? qx + r >= x : qy + r >= y) {
+          STACK[sp++] = m + 1;
+          STACK[sp++] = right;
+          STACK[sp++] = 1 - axis;
+        }
+      }
+      return count;
+    }
+  };
+  function sort(ids, coords, nodeSize, left, right, axis) {
+    if (right - left <= nodeSize) return;
+    const m = left + right >> 1;
+    select(ids, coords, m, left, right, axis);
+    sort(ids, coords, nodeSize, left, m - 1, 1 - axis);
+    sort(ids, coords, nodeSize, m + 1, right, 1 - axis);
+  }
+  function select(ids, coords, k, left, right, axis) {
+    while (right > left) {
+      if (right - left > 600) {
+        const n = right - left + 1;
+        const m = k - left + 1;
+        const z = Math.log(n);
+        const s = 0.5 * Math.exp(2 * z / 3);
+        const sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
+        select(ids, coords, k, Math.max(left, Math.floor(k - m * s / n + sd)), Math.min(right, Math.floor(k + (n - m) * s / n + sd)), axis);
+      }
+      const t = coords[2 * k + axis];
+      let i = left;
+      let j = right;
+      swapItem(ids, coords, left, k);
+      if (coords[2 * right + axis] > t) swapItem(ids, coords, left, right);
+      while (i < j) {
+        swapItem(ids, coords, i, j);
+        i++;
+        j--;
+        while (coords[2 * i + axis] < t) i++;
+        while (coords[2 * j + axis] > t) j--;
+      }
+      if (coords[2 * left + axis] === t) swapItem(ids, coords, left, j);
+      else {
+        j++;
+        swapItem(ids, coords, j, right);
+      }
+      if (j <= k) left = j + 1;
+      if (k <= j) right = j - 1;
+    }
+  }
+  function swapItem(ids, coords, i, j) {
+    swap(ids, i, j);
+    swap(coords, 2 * i, 2 * j);
+    swap(coords, 2 * i + 1, 2 * j + 1);
+  }
+  function swap(arr, i, j) {
+    const tmp = arr[i];
+    arr[i] = arr[j];
+    arr[j] = tmp;
+  }
+  function sqDist(ax, ay, bx, by) {
+    const dx = ax - bx;
+    const dy = ay - by;
+    return dx * dx + dy * dy;
+  }
+  var defaultClusterOptions = {
+    minZoom: 0,
+    maxZoom: 16,
+    minPoints: 2,
+    radius: 40,
+    extent: 512,
+    nodeSize: 64,
+    log: false,
+    generateId: false,
+    reduce: null,
+    map: (props) => props,
+    coordinates: "lngLat",
+    wrap: true
+  };
+  var MAX_ZOOM = 30;
+  var SCALE = 1073741824;
+  var MAX_INTEGER = 2147483647;
+  function encode(coord) {
+    return (coord - 0.5) * SCALE;
+  }
+  function decode(value) {
+    return value / SCALE + 0.5;
+  }
+  function fitsInteger(coord) {
+    return Math.abs(encode(coord)) < MAX_INTEGER;
+  }
+  var OFFSET_ZOOM = 0;
+  var OFFSET_ID = 1;
+  var OFFSET_PARENT = 2;
+  var OFFSET_NUM = 3;
+  var OFFSET_PROP = 4;
+  var ClusterTileIndex = class {
+    constructor(options) {
+      this.options = createOptions(options);
+      this.worldCoordinateHelper = getWorldCoordinateHelper(this.options.coordinates);
+      this.trees = new Array(this.options.maxZoom + 1);
+      this.stride = this.options.reduce ? 5 : 4;
+      this.clusterProps = [];
+      this.points = [];
+    }
+    /**
+    * 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 positions = point.geometry.type === "MultiPoint" ? point.geometry.coordinates : [point.geometry.coordinates];
+        for (const [lng, lat] of positions) {
+          const [x, y] = [this.worldCoordinateHelper.projectX(lng), this.worldCoordinateHelper.projectY(lat)];
+          if (!this.options.wrap && !isInWorld([x, y])) continue;
+          const feature = {
+            id: point.id,
+            type: "Point",
+            geometry: [x, y],
+            tags: point.properties
+          };
+          features.push(feature);
+        }
+      }
+      this.createIndex(features);
+    }
+    /**
+    * @internal
+    * Loads internal GeoJSONVT point features from a data source and builds the clustering index.
+    * Each position of a MultiPoint feature becomes a point of its own, with the id and properties of its feature.
+    * @param features - {@link GeoJSONVTInternalFeature} data source features to filter and cluster.
+    */
+    initialize(features) {
+      const points = [];
+      for (const feature of features) {
+        if (feature.type === "Point") {
+          if (!this.options.wrap && !isInWorld(feature.geometry)) continue;
+          points.push(feature);
+          continue;
+        }
+        if (feature.type !== "MultiPoint") continue;
+        for (let i = 0; i < feature.geometry.length; i += 3) {
+          const geometry = [feature.geometry[i], feature.geometry[i + 1]];
+          if (!this.options.wrap && !isInWorld(geometry)) continue;
+          points.push({
+            id: feature.id,
+            type: "Point",
+            geometry,
+            tags: feature.tags
+          });
+        }
+      }
+      this.createIndex(points);
+    }
+    /**
+    * @internal
+    * Updates the cluster data by rebuilding.
+    * @param features 
+    */
+    updateIndex(features, _affected, options) {
+      this.options = createOptions({
+        ...options.clusterOptions,
+        coordinates: this.options.coordinates,
+        wrap: this.options.wrap
+      });
+      this.initialize(features);
+    }
+    /**
+    * Builds a tree per zoom level from the points. A point whose position does not fit in an integer is left out,
+    * see `fitsInteger`.
+    */
+    createIndex(points) {
+      const { log, minZoom, maxZoom } = this.options;
+      this.trees = new Array(maxZoom + 1);
+      this.stride = this.options.reduce ? 5 : 4;
+      this.clusterProps = [];
+      if (log) console.time("total time");
+      const timerId = `prepare ${points.length} points`;
+      if (log) console.time(timerId);
+      this.points = points;
+      const 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 || !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(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();
+        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, 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.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;
+      const minLat = Math.max(-90, Math.min(90, bbox[1]));
+      let maxLng = bbox[2] === 180 ? 180 : ((bbox[2] + 180) % 360 + 360) % 360 - 180;
+      const maxLat = Math.max(-90, Math.min(90, bbox[3]));
+      if (bbox[2] - bbox[0] >= 360) {
+        minLng = -180;
+        maxLng = 180;
+      } else if (minLng > maxLng) {
+        const easternHem = this.getClustersInternal([
+          minLng,
+          minLat,
+          180,
+          maxLat
+        ], zoom);
+        const westernHem = this.getClustersInternal([
+          -180,
+          minLat,
+          maxLng,
+          maxLat
+        ], zoom);
+        return easternHem.concat(westernHem);
+      }
+      return this.getClustersInRange([
+        this.worldCoordinateHelper.projectX(minLng),
+        this.worldCoordinateHelper.projectY(maxLat),
+        this.worldCoordinateHelper.projectX(maxLng),
+        this.worldCoordinateHelper.projectY(minLat)
+      ], zoom);
+    }
+    /**
+    * The clusters and points in a box of the internal coordinates, `[minX, minY, maxX, maxY]`.
+    */
+    getClustersInRange([minX, minY, maxX, maxY], zoom) {
+      const tree = this.trees[this.limitZoom(zoom)];
+      const ids = tree.range(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(coords, id, data, k, this.clusterProps) : this.points[data[k + OFFSET_ID]]);
+      }
+      return clusters;
+    }
+    /**
+    * Returns the immediate children (clusters or points) of a cluster as GeoJSON.
+    * @param clusterId - The target cluster id.
+    */
+    getChildren(clusterId) {
+      const originId = this.getOriginId(clusterId);
+      const originZoom = this.getOriginZoom(clusterId);
+      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 >= 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(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;
+    }
+    /**
+    * Returns leaf point features under a cluster, paginated by `limit` and `offset`.
+    * @param clusterId - The target cluster id.
+    * @param limit - Maximum number of points to return (defaults to `10`).
+    * @param offset - Number of points to skip before collecting results (defaults to `0`).
+    */
+    getLeaves(clusterId, limit, offset) {
+      limit = limit || 10;
+      offset = offset || 0;
+      const leaves = [];
+      this.appendLeaves(leaves, clusterId, limit, offset, 0);
+      return leaves;
+    }
+    /**
+    * Generates a vector-tile-like representation of a single tile.
+    * @param z - Tile zoom.
+    * @param x - Tile x coordinate.
+    * @param y - Tile y coordinate.
+    */
+    getTile(z, x, y) {
+      const tree = this.trees[this.limitZoom(z)];
+      if (!tree) return null;
+      const z2 = Math.pow(2, z);
+      if (!this.options.wrap && (x < 0 || x >= z2 || y < 0 || y >= z2)) return null;
+      const { extent, radius } = this.options;
+      const p = radius / extent;
+      const top = encode((y - p) / z2);
+      const bottom = encode((y + 1 + p) / z2);
+      const tile = {
+        transformed: true,
+        features: [],
+        source: null,
+        x,
+        y,
+        z
+      };
+      this.addTileFeatures(tree.range(encode((x - p) / z2), top, encode((x + 1 + p) / z2), bottom), tree, x, y, z2, tile);
+      if (this.options.wrap && x === 0) this.addTileFeatures(tree.range(encode(1 - p / z2), top, encode(1), bottom), tree, z2, y, z2, tile);
+      if (this.options.wrap && x === z2 - 1) this.addTileFeatures(tree.range(encode(0), top, encode(p / z2), bottom), tree, -1, y, z2, tile);
+      return tile;
+    }
+    /**
+    * Returns the zoom level at which a cluster expands into multiple children.
+    * @param clusterId - The target cluster id.
+    */
+    getClusterExpansionZoom(clusterId) {
+      return this.getOriginZoom(clusterId);
+    }
+    appendLeaves(result, clusterId, limit, offset, skipped) {
+      const children = this.getChildren(clusterId);
+      for (const child of children) {
+        const props = child.properties;
+        if (props?.cluster) {
+          if (skipped + props.point_count <= offset) skipped += props.point_count;
+          else skipped = this.appendLeaves(result, props.cluster_id, limit, offset, skipped);
+        } else if (skipped < offset) skipped++;
+        else result.push(child);
+        if (result.length === limit) break;
+      }
+      return skipped;
+    }
+    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;
+    }
+    /**
+    * 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;
+        let tags;
+        let px;
+        let py;
+        if (isCluster) {
+          tags = getClusterProperties(data, k, this.clusterProps);
+          px = decode(coords[i * 2]);
+          py = decode(coords[i * 2 + 1]);
+        } else {
+          const p = this.points[data[k + OFFSET_ID]];
+          tags = p.tags;
+          [px, py] = p.geometry;
+        }
+        const f = {
+          type: 1,
+          geometry: [[Math.round(this.options.extent * (px * z2 - x)), Math.round(this.options.extent * (py * z2 - y))]],
+          tags
+        };
+        let id;
+        if (isCluster || this.options.generateId) id = data[k + OFFSET_ID];
+        else id = this.points[data[k + OFFSET_ID]].id;
+        if (id !== void 0) f.id = id;
+        tile.features.push(f);
+      }
+    }
+    limitZoom(z) {
+      return Math.max(this.options.minZoom, Math.min(Math.floor(+z), this.options.maxZoom + 1));
+    }
+    /**
+    * 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 stride = this.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 = 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 (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) {
+          let wx = x * numPointsOrigin;
+          let wy = y * numPointsOrigin;
+          let clusterProperties;
+          let clusterPropIndex = -1;
+          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 += coords[neighborIndex * 2] * numPoints2;
+            wy += coords[neighborIndex * 2 + 1] * numPoints2;
+            data[k + OFFSET_PARENT] = id;
+            if (reduce) {
+              if (!clusterProperties) {
+                clusterProperties = this.map(data, i, true);
+                clusterPropIndex = this.clusterProps.length;
+                this.clusterProps.push(clusterProperties);
+              }
+              reduce(clusterProperties, this.map(data, k));
+            }
+          }
+          data[i + OFFSET_PARENT] = id;
+          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 {
+          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;
+            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 nextNumItems;
+    }
+    getOriginId(clusterId) {
+      return clusterId - this.points.length >> 5;
+    }
+    getOriginZoom(clusterId) {
+      return (clusterId - this.points.length) % 32;
+    }
+    map(data, i, clone) {
+      if (data[i + OFFSET_NUM] > 1) {
+        const props = this.clusterProps[data[i + OFFSET_PROP]];
+        return clone ? Object.assign({}, props) : props;
+      }
+      const original = this.points[data[i + OFFSET_ID]].tags;
+      const result = this.options.map(original);
+      return clone && result === original ? Object.assign({}, result) : result;
+    }
+  };
+  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: [decode(coords[index * 2]), decode(coords[index * 2 + 1])]
+    };
+  }
+  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: [worldCoordinateHelper.unprojectX(decode(coords[index * 2])), worldCoordinateHelper.unprojectY(decode(coords[index * 2 + 1]))]
+      }
+    };
+  }
+  function getClusterProperties(data, i, clusterProps) {
+    const count = data[i + OFFSET_NUM];
+    const abbrev = count >= 1e4 ? `${Math.round(count / 1e3)}k` : count >= 1e3 ? `${Math.round(count / 100) / 10}k` : count;
+    const propIndex = data[i + OFFSET_PROP];
+    const properties = propIndex === -1 ? {} : Object.assign({}, clusterProps[propIndex]);
+    return Object.assign(properties, {
+      cluster: true,
+      cluster_id: data[i + OFFSET_ID],
+      point_count: count,
+      point_count_abbreviated: abbrev
+    });
+  }
+  function isInWorld(geometry) {
+    return geometry[0] >= 0 && geometry[0] <= 1 && geometry[1] >= 0 && geometry[1] <= 1;
+  }
+  var GEOJSONVT_CLIP_START = "geojsonvt_clip_start";
+  var GEOJSONVT_CLIP_END = "geojsonvt_clip_end";
+  function createTile(features, z, tx, ty, options) {
+    const tolerance = z === options.maxZoom ? 0 : options.tolerance / ((1 << z) * options.extent);
+    const tile = {
+      transformed: false,
+      features: [],
+      source: null,
+      x: tx,
+      y: ty,
+      z,
+      minX: 2,
+      minY: 1,
+      maxX: -1,
+      maxY: 0,
+      numPoints: 0,
+      numSimplified: 0,
+      numFeatures: features.length
+    };
+    for (const feature of features) addFeature(tile, feature, tolerance, options);
+    return tile;
+  }
+  function addFeature(tile, feature, tolerance, options) {
+    tile.minX = Math.min(tile.minX, feature.minX);
+    tile.minY = Math.min(tile.minY, feature.minY);
+    tile.maxX = Math.max(tile.maxX, feature.maxX);
+    tile.maxY = Math.max(tile.maxY, feature.maxY);
+    switch (feature.type) {
+      case "Point":
+      case "MultiPoint":
+        addPointsTileFeature(tile, feature);
+        return;
+      case "LineString":
+        addLineTileFeautre(tile, feature, tolerance, options);
+        return;
+      case "MultiLineString":
+      case "Polygon":
+        addLinesTileFeature(tile, feature, tolerance);
+        return;
+      case "MultiPolygon":
+        addMultiPolygonTileFeature(tile, feature, tolerance);
+        return;
+    }
+  }
+  function addPointsTileFeature(tile, feature) {
+    const geometry = [];
+    for (let i = 0; i < feature.geometry.length; i += 3) {
+      geometry.push(feature.geometry[i], feature.geometry[i + 1]);
+      tile.numPoints++;
+      tile.numSimplified++;
+    }
+    if (!geometry.length) return;
+    const tileFeature = {
+      type: 1,
+      tags: feature.tags || null,
+      geometry
+    };
+    if (feature.id !== null) tileFeature.id = feature.id;
+    tile.features.push(tileFeature);
+  }
+  function addLineTileFeautre(tile, feature, tolerance, options) {
+    const geometry = [];
+    addLine(geometry, feature.geometry, tile, tolerance, false, false);
+    if (!geometry.length) return;
+    let tags = feature.tags || null;
+    if (options.lineMetrics) {
+      tags = {};
+      for (const key in feature.tags) tags[key] = feature.tags[key];
+      tags[GEOJSONVT_CLIP_START] = feature.geometry.start / feature.geometry.size;
+      tags[GEOJSONVT_CLIP_END] = feature.geometry.end / feature.geometry.size;
+    }
+    const tileFeature = {
+      type: 2,
+      tags,
+      geometry
+    };
+    if (feature.id !== null) tileFeature.id = feature.id;
+    tile.features.push(tileFeature);
+  }
+  function addLinesTileFeature(tile, feature, tolerance) {
+    const geometry = [];
+    for (let i = 0; i < feature.geometry.length; i++) addLine(geometry, feature.geometry[i], tile, tolerance, feature.type === "Polygon", i === 0);
+    if (!geometry.length) return;
+    const tileFeature = {
+      type: feature.type === "Polygon" ? 3 : 2,
+      tags: feature.tags || null,
+      geometry
+    };
+    if (feature.id !== null) tileFeature.id = feature.id;
+    tile.features.push(tileFeature);
+  }
+  function addMultiPolygonTileFeature(tile, feature, tolerance) {
+    const geometry = [];
+    for (let k = 0; k < feature.geometry.length; k++) {
+      const polygon = feature.geometry[k];
+      for (let i = 0; i < polygon.length; i++) addLine(geometry, polygon[i], tile, tolerance, true, i === 0);
+    }
+    if (!geometry.length) return;
+    const tileFeature = {
+      type: 3,
+      tags: feature.tags || null,
+      geometry
+    };
+    if (feature.id !== null) tileFeature.id = feature.id;
+    tile.features.push(tileFeature);
+  }
+  function addLine(result, geom, tile, tolerance, isPolygon, isOuter) {
+    const sqTolerance = tolerance * tolerance;
+    if (tolerance > 0 && geom.size < (isPolygon ? sqTolerance : tolerance)) {
+      tile.numPoints += geom.points.length / 3;
+      return;
+    }
+    const ring = [];
+    for (let i = 0; i < geom.points.length; i += 3) {
+      if (tolerance === 0 || geom.points[i + 2] > sqTolerance) {
+        tile.numSimplified++;
+        ring.push(geom.points[i], geom.points[i + 1]);
+      }
+      tile.numPoints++;
+    }
+    if (isPolygon) rewind(ring, isOuter);
+    result.push(ring);
+  }
+  function rewind(ring, clockwise) {
+    let area = 0;
+    for (let i = 0, len = ring.length, j = len - 2; i < len; j = i, i += 2) area += (ring[i] - ring[j]) * (ring[i + 1] + ring[j + 1]);
+    if (area > 0 !== clockwise) return;
+    for (let i = 0, len = ring.length; i < len / 2; i += 2) {
+      const x = ring[i];
+      const y = ring[i + 1];
+      ring[i] = ring[len - 2 - i];
+      ring[i + 1] = ring[len - 1 - i];
+      ring[len - 2 - i] = x;
+      ring[len - 1 - i] = y;
+    }
+  }
+  function transformTile(tile, extent) {
+    if (tile.transformed) return tile;
+    const z2 = 1 << tile.z;
+    const tx = tile.x;
+    const ty = tile.y;
+    for (const feature of tile.features) if (feature.type === 1) transformPointFeature(feature, extent, z2, tx, ty);
+    else transformNonPointFeature(feature, extent, z2, tx, ty);
+    tile.transformed = true;
+    return tile;
+  }
+  function transformPointFeature(feature, extent, z2, tx, ty) {
+    const transformed = feature;
+    const geometry = feature.geometry;
+    const point = [];
+    for (let i = 0; i < geometry.length; i += 2) point.push(transformPoint(geometry[i], geometry[i + 1], extent, z2, tx, ty));
+    transformed.geometry = point;
+    return transformed;
+  }
+  function transformNonPointFeature(feature, extent, z2, tx, ty) {
+    const transformed = feature;
+    const geometry = feature.geometry;
+    const nonPoint = [];
+    for (const geom of geometry) {
+      const ring = [];
+      for (let i = 0; i < geom.length; i += 2) ring.push(transformPoint(geom[i], geom[i + 1], extent, z2, tx, ty));
+      nonPoint.push(ring);
+    }
+    transformed.geometry = nonPoint;
+    return transformed;
+  }
+  function transformPoint(x, y, extent, z2, tx, ty) {
+    return [Math.round(extent * (x * z2 - tx)), Math.round(extent * (y * z2 - ty))];
+  }
+  var TileIndex = class {
+    constructor(options) {
+      this.options = options;
+      this.total = 0;
+      this.stats = {};
+      this.tiles = {};
+      this.tileCoords = [];
+      this.stats = {};
+      this.total = 0;
+    }
+    initialize(features) {
+      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");
+        console.log("tiles generated:", this.total, JSON.stringify(this.stats));
+      }
+    }
+    /** {@inheritdoc} */
+    updateIndex(source, affected, options) {
+      if (options.debug > 1) {
+        console.log("invalidating tiles");
+        console.time("invalidating");
+      }
+      this.invalidateTiles(affected);
+      if (options.debug > 1) console.timeEnd("invalidating");
+      const [z, x, y] = [
+        0,
+        0,
+        0
+      ];
+      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({
+        z,
+        x,
+        y,
+        id
+      });
+      if (options.debug) {
+        const key = `z${z}`;
+        this.stats[key] = (this.stats[key] || 0) + 1;
+        this.total++;
+      }
+    }
+    /** {@inheritdoc} */
+    getClusterExpansionZoom(_clusterId) {
+      return null;
+    }
+    /** {@inheritdoc} */
+    getChildren(_clusterId) {
+      return null;
+    }
+    /** {@inheritdoc} */
+    getLeaves(_clusterId, _limit, _offset) {
+      return null;
+    }
+    /** {@inheritdoc} */
+    getTile(z, x, y) {
+      const { extent, debug } = this.options;
+      const z2 = 1 << z;
+      if (!this.options.wrap && (x < 0 || x >= z2)) return null;
+      x = x + z2 & z2 - 1;
+      const id = toID(z, x, y);
+      if (this.tiles[id]) return transformTile(this.tiles[id], extent);
+      if (debug > 1) console.log("drilling down to z%d-%d-%d", z, x, y);
+      let z0 = z;
+      let x0 = x;
+      let y0 = y;
+      let parent;
+      while (!parent && z0 > 0) {
+        z0--;
+        x0 = x0 >> 1;
+        y0 = y0 >> 1;
+        parent = this.tiles[toID(z0, x0, y0)];
+      }
+      if (!parent?.source) return null;
+      if (debug > 1) {
+        console.log("found parent tile z%d-%d-%d", z0, x0, y0);
+        console.time("drilling down");
+      }
+      this.splitTile(parent.source, z0, x0, y0, z, x, y);
+      if (debug > 1) console.timeEnd("drilling down");
+      if (!this.tiles[id]) return null;
+      return transformTile(this.tiles[id], extent);
+    }
+    /**
+    * The features the top tile starts from. A world that wraps keeps them all left and right, where wrapping already
+    * put them inside, and one that doesn't only what lies inside the world square and its buffer. Positions in the
+    * unit square are also cut above and below in a world that wraps, where lng/lat is clamped already. The index keeps
+    * the rest, so an update can still move a feature in from outside.
+    */
+    clipToWorld(features) {
+      const { wrap: wrap2, coordinates } = this.options;
+      if (wrap2 && coordinates !== "unitSquare") return features;
+      const buffer = this.options.buffer / this.options.extent;
+      return clip(wrap2 ? features : clip(features, 1, -buffer, 1 + buffer, 0, -Infinity, Infinity, this.options) || [], 1, -buffer, 1 + buffer, 1, -Infinity, Infinity, this.options) || [];
+    }
+    /**
+    * splits features from a parent tile to sub-tiles.
+    * z, x, and y are the coordinates of the parent tile
+    * cz, cx, and cy are the coordinates of the target tile
+    * 
+    * If no target tile is specified, splitting stops when we reach the maximum
+    * zoom or the number of points is low as specified in the options.
+    * @internal
+    * @param features - features to split
+    * @param z - tile zoom level
+    * @param x - tile x coordinate
+    * @param y - tile y coordinate
+    * @param cz - target tile zoom level
+    * @param cx - target tile x coordinate
+    * @param cy - target tile y coordinate
+    */
+    splitTile(features, z, x, y, cz, cx, cy) {
+      const stack = [
+        features,
+        z,
+        x,
+        y
+      ];
+      const options = this.options;
+      const debug = options.debug;
+      while (stack.length) {
+        y = stack.pop();
+        x = stack.pop();
+        z = stack.pop();
+        features = stack.pop();
+        const z2 = 1 << z;
+        const id = toID(z, x, y);
+        let tile = this.tiles[id];
+        if (!tile) {
+          if (debug > 1) console.time("creation");
+          tile = this.tiles[id] = createTile(features, z, x, y, options);
+          this.tileCoords.push({
+            z,
+            x,
+            y,
+            id
+          });
+          if (debug) {
+            if (debug > 1) {
+              console.log("tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", z, x, y, tile.numFeatures, tile.numPoints, tile.numSimplified);
+              console.timeEnd("creation");
+            }
+            const key = `z${z}`;
+            this.stats[key] = (this.stats[key] || 0) + 1;
+            this.total++;
+          }
+        }
+        tile.source = features;
+        if (cz == null) {
+          if (z === options.indexMaxZoom || tile.numPoints <= options.indexMaxPoints) continue;
+        } else if (z === options.maxZoom || z === cz) continue;
+        else if (cz != null) {
+          const zoomSteps = cz - z;
+          if (x !== cx >> zoomSteps || y !== cy >> zoomSteps) continue;
+        }
+        tile.source = null;
+        if (!features.length) continue;
+        if (debug > 1) console.time("clipping");
+        const k1 = 0.5 * options.buffer / options.extent;
+        const k2 = 0.5 - k1;
+        const k3 = 0.5 + k1;
+        const k4 = 1 + k1;
+        let tl = null;
+        let bl = null;
+        let tr = null;
+        let br = null;
+        const left = clip(features, z2, x - k1, x + k3, 0, tile.minX, tile.maxX, options);
+        const right = clip(features, z2, x + k2, x + k4, 0, tile.minX, tile.maxX, options);
+        if (left) {
+          tl = clip(left, z2, y - k1, y + k3, 1, tile.minY, tile.maxY, options);
+          bl = clip(left, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, options);
+        }
+        if (right) {
+          tr = clip(right, z2, y - k1, y + k3, 1, tile.minY, tile.maxY, options);
+          br = clip(right, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, options);
+        }
+        if (debug > 1) console.timeEnd("clipping");
+        stack.push(tl || [], z + 1, x * 2, y * 2);
+        stack.push(bl || [], z + 1, x * 2, y * 2 + 1);
+        stack.push(tr || [], z + 1, x * 2 + 1, y * 2);
+        stack.push(br || [], z + 1, x * 2 + 1, y * 2 + 1);
+      }
+    }
+    /**
+    * Invalidates (removes) tiles affected by the provided features
+    * @internal
+    * @param features 
+    */
+    invalidateTiles(features) {
+      if (!features.length) return;
+      const options = this.options;
+      const { debug } = options;
+      let minX = Infinity;
+      let maxX = -Infinity;
+      let minY = Infinity;
+      let maxY = -Infinity;
+      for (const feature of features) {
+        minX = Math.min(minX, feature.minX);
+        maxX = Math.max(maxX, feature.maxX);
+        minY = Math.min(minY, feature.minY);
+        maxY = Math.max(maxY, feature.maxY);
+      }
+      const k1 = options.buffer / options.extent;
+      const removedLookup = /* @__PURE__ */ new Set();
+      for (const id in this.tiles) {
+        const tile = this.tiles[id];
+        const z2 = 1 << tile.z;
+        const tileMinX = (tile.x - k1) / z2;
+        const tileMaxX = (tile.x + 1 + k1) / z2;
+        const tileMinY = (tile.y - k1) / z2;
+        const tileMaxY = (tile.y + 1 + k1) / z2;
+        if (maxX < tileMinX || minX >= tileMaxX || maxY < tileMinY || minY >= tileMaxY) continue;
+        let intersects = false;
+        for (const feature of features) if (feature.maxX >= tileMinX && feature.minX < tileMaxX && feature.maxY >= tileMinY && feature.minY < tileMaxY) {
+          intersects = true;
+          break;
+        }
+        if (!intersects) continue;
+        if (debug) {
+          if (debug > 1) console.log("invalidate tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", tile.z, tile.x, tile.y, tile.numFeatures, tile.numPoints, tile.numSimplified);
+          const key = `z${tile.z}`;
+          this.stats[key] = (this.stats[key] || 0) - 1;
+          this.total--;
+        }
+        delete this.tiles[id];
+        removedLookup.add(id);
+      }
+      if (removedLookup.size) this.tileCoords = this.tileCoords.filter((c) => !removedLookup.has(c.id));
+    }
+  };
+  function toID(z, x, y) {
+    return ((1 << z) * y + x) * 32 + z;
+  }
+  var defaultOptions = {
+    maxZoom: 14,
+    indexMaxZoom: 5,
+    indexMaxPoints: 1e5,
+    tolerance: 3,
+    extent: 4096,
+    buffer: 64,
+    lineMetrics: false,
+    promoteId: null,
+    generateId: false,
+    updateable: false,
+    cluster: false,
+    clusterOptions: defaultClusterOptions,
+    debug: 0,
+    coordinates: "lngLat",
+    wrap: true
+  };
+  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.");
+      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);
+        console.time("generate tiles");
+      }
+      features = wrap(features, options);
+      if (options.updateable) this.source = features;
+      this.initializeIndex(features, options);
+    }
+    initializeIndex(features, 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);
+    }
+    /**
+    * Given z, x, and y tile coordinates, returns the corresponding tile with geometries in tile coordinates, much like MVT data is stored.
+    * @param z - tile zoom level
+    * @param x - tile x coordinate
+    * @param y - tile y coordinate
+    * @returns the transformed tile or null if not found
+    */
+    getTile(z, x, y) {
+      z = +z;
+      x = +x;
+      y = +y;
+      if (z < 0 || z > 24) return null;
+      return this.tileIndex.getTile(z, x, y);
+    }
+    /**
+    * Updates the source data feature set using a {@link GeoJSONVTSourceDiff}
+    * @param diff - the source diff object
+    */
+    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, 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, 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.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
+      };
+    }
+    /**
+    * Returns source data as GeoJSON - only available when `updateable` option is set to true.
+    */
+    getData() {
+      if (!this.options.updateable) throw new Error("to retrieve data the `updateable` option must be set to true");
+      return convertToGeoJSON(this.source, this.worldCoordinateHelper);
+    }
+    /**
+    * Update supercluster options and regenerate the index.
+    * @param cluster - whether to enable clustering
+    * @param clusterOptions - {@link SuperclusterOptions} without `coordinates` and `wrap`, which come from the index options
+    */
+    updateClusterOptions(cluster, clusterOptions) {
+      const wasCluster = this.options.cluster;
+      this.options.cluster = cluster;
+      this.options.clusterOptions = clusterOptions;
+      if (wasCluster == cluster) {
+        this.tileIndex.updateIndex(this.source, [], this.options);
+        return;
+      }
+      this.initializeIndex(this.source, this.options);
+    }
+    /**
+    * Returns the zoom level at which a cluster expands into multiple children.
+    * @param clusterId - The target cluster id.
+    * @returns the expansion zoom or null in case of non-clustered source
+    */
+    getClusterExpansionZoom(clusterId) {
+      return this.tileIndex.getClusterExpansionZoom(clusterId);
+    }
+    /**
+    * Returns the immediate children (clusters or points) of a cluster as GeoJSON.
+    * @param clusterId - The target cluster id.
+    * @returns the immediate children or null in case of non-clustered source
+    */
+    getClusterChildren(clusterId) {
+      return this.tileIndex.getChildren(clusterId);
+    }
+    /**
+    * Returns leaf point features under a cluster, paginated by `limit` and `offset`.
+    * @param clusterId - The target cluster id.
+    * @param limit - Maximum number of points to return (defaults to `10`).
+    * @param offset - Number of points to skip before collecting results (defaults to `0`).
+    * @returns leaf point features under a cluster or null in case of non-clustered source
+    */
+    getClusterLeaves(clusterId, limit, offset) {
+      return this.tileIndex.getLeaves(clusterId, limit, offset);
+    }
+  };
+
+  // src/geojson-tiler.ts
+  var GEOMETRY_DEPTHS = {
+    Point: 0,
+    MultiPoint: 1,
+    LineString: 1,
+    MultiLineString: 2,
+    Polygon: 2,
+    MultiPolygon: 3
+  };
+  function createTileIndex(data, options) {
+    return new GeoJSONVT(data, options);
+  }
+  function getSignedArea(ring) {
+    let sum = 0;
+    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+      sum += (ring[j][0] - ring[i][0]) * (ring[i][1] + ring[j][1]);
+    }
+    return sum;
+  }
+  function classifyRings(rings) {
+    const polygons = [];
+    let polygon;
+    let clockwise;
+    for (const ring of rings) {
+      const area = getSignedArea(ring);
+      if (area === 0) {
+        continue;
+      }
+      clockwise ??= area < 0;
+      if (clockwise === area < 0) {
+        polygon = [ring];
+        polygons.push(polygon);
+      } else {
+        polygon?.push(ring);
+      }
+    }
+    return polygons;
+  }
+  function getGeometry(feature) {
+    if (feature.type === 1) {
+      const points = feature.geometry;
+      return points.length === 1 ? { type: "Point", coordinates: points[0] } : { type: "MultiPoint", coordinates: points };
+    }
+    if (feature.type === 2) {
+      const lines = feature.geometry;
+      return lines.length === 1 ? { type: "LineString", coordinates: lines[0] } : { type: "MultiLineString", coordinates: lines };
+    }
+    const polygons = classifyRings(feature.geometry);
+    if (polygons.length === 0) {
+      return null;
+    }
+    return polygons.length === 1 ? { type: "Polygon", coordinates: polygons[0] } : { type: "MultiPolygon", coordinates: polygons };
+  }
+  function cutTile(index, z, x, y) {
+    const features = [];
+    const positions = [];
+    const lengths = [];
+    const writeCoordinates = (coordinates, depth) => {
+      if (depth === 0) {
+        positions.push(coordinates[0], coordinates[1]);
+        return;
+      }
+      lengths.push(coordinates.length);
+      for (const child of coordinates) {
+        writeCoordinates(child, depth - 1);
+      }
+    };
+    for (const feature of index.getTile(z, x, y)?.features || []) {
+      const geometry = getGeometry(feature);
+      if (!geometry) {
+        continue;
+      }
+      writeCoordinates(geometry.coordinates, GEOMETRY_DEPTHS[geometry.type]);
+      const encoded = { type: geometry.type, properties: feature.tags || {} };
+      if (feature.id !== void 0) {
+        encoded.id = feature.id;
+      }
+      features.push(encoded);
+    }
+    return { features, positions: Int32Array.from(positions), lengths: Uint32Array.from(lengths) };
+  }
+
+  // src/geojson-worker.ts
+  var pendingFeatures = /* @__PURE__ */ new Map();
+  var indexes = /* @__PURE__ */ new Map();
+  var scope = globalThis;
+  scope.onmessage = ({ data: message }) => {
+    switch (message.type) {
+      case "features": {
+        const features = pendingFeatures.get(message.source);
+        if (features) {
+          for (const feature of message.features) {
+            features.push(feature);
+          }
+        } else {
+          pendingFeatures.set(message.source, message.features);
+        }
+        break;
+      }
+      case "index": {
+        const data = message.data ?? {
+          type: "FeatureCollection",
+          features: pendingFeatures.get(message.source) || []
+        };
+        pendingFeatures.delete(message.source);
+        try {
+          indexes.set(message.source, createTileIndex(data, message.options));
+        } catch (error) {
+          indexes.set(message.source, error instanceof Error ? error : new Error(String(error)));
+        }
+        break;
+      }
+      case "tile": {
+        const index = indexes.get(message.source);
+        try {
+          if (!index) {
+            throw new Error("GeoJSON source has no index");
+          }
+          if (index instanceof Error) {
+            throw index;
+          }
+          const tile = cutTile(index, message.z, message.x, message.y);
+          scope.postMessage({ request: message.request, tile }, [
+            tile.positions.buffer,
+            tile.lengths.buffer
+          ]);
+        } catch (error) {
+          scope.postMessage(
+            { request: message.request, error: error instanceof Error ? error.message : String(error) },
+            []
+          );
+        }
+        break;
+      }
+      case "remove":
+        pendingFeatures.delete(message.source);
+        indexes.delete(message.source);
+        break;
+      default:
+    }
+  };
+})();
+//# sourceMappingURL=geojson-worker.js.map