@guardian/interactive-component-library 0.2.0-rc-06ceabc.0 → 0.2.0-rc1

package/dist/interactive-component-library.umd.cjs

@@ -6180,175 +6180,6 @@
       )
     ] });
   }
-  class FeatureRenderer {
-    constructor() {
-      this.drawingFunction = d3Geo.geoPath();
-    }
-    setStyle(style2) {
-      this.style = style2;
-    }
-    render(frameState, feature, context) {
-      if (!this.style) {
-        return;
-      }
-      const { projection, transform, pixelRatio } = frameState.viewState;
-      const { stroke, fill } = this.style;
-      this.drawingFunction.context(context);
-      context.beginPath();
-      const geometries = feature.getProjectedGeometries(projection);
-      if (frameState.debug) {
-        try {
-          validateGeometries(geometries);
-        } catch {
-          console.error(
-            `Invalid geometry. Feature skipped during rendering. Click here to inspect geometry: ${generateDebugUrl(feature)} 
-`,
-            feature
-          );
-        }
-      }
-      for (const geometry of geometries) {
-        this.drawingFunction(geometry);
-      }
-      if (fill) {
-        context.fillStyle = fill.getRgba();
-        context.fill();
-      }
-      if (stroke) {
-        context.lineWidth = stroke.width * pixelRatio / transform.k;
-        context.strokeStyle = stroke.getRgba();
-        context.stroke();
-      }
-    }
-  }
-  const textPadding = {
-    top: 20,
-    right: 20,
-    bottom: 20,
-    left: 20
-  };
-  class TextLayerRenderer {
-    constructor(layer) {
-      this.layer = layer;
-      this.featureRenderer = new FeatureRenderer();
-      this._element = document.createElement("div");
-      this._element.className = "gv-text-layer";
-      const style2 = this._element.style;
-      style2.position = "absolute";
-      style2.width = "100%";
-      style2.height = "100%";
-      style2.pointerEvents = "none";
-      style2.overflow = "hidden";
-    }
-    renderFrame(frameState, targetElement) {
-      if (this.layer.opacity === 0) return targetElement;
-      const { declutterTree } = frameState;
-      const { projection, viewPortSize, sizeInPixels, visibleExtent, transform } = frameState.viewState;
-      this._element.style.opacity = this.layer.opacity;
-      const source = this.layer.source;
-      const features = source.getFeaturesInExtent(visibleExtent);
-      const textElements = [];
-      for (const feature of features) {
-        const geometries = feature.getProjectedGeometries(projection);
-        const point = geometries.find((d2) => d2.type === "Point");
-        if (!point) {
-          throw new Error(
-            `Expected Point geometry for feature in TextLayer: ${feature}`
-          );
-        }
-        const styleFunction2 = feature.getStyleFunction() || this.layer.getStyleFunction();
-        const featureStyle = styleFunction2(feature);
-        const textElement = this.getTextElementWithID(feature.uid);
-        textElement.innerText = featureStyle.text.content;
-        const [relativeX, relativeY] = transform.apply(point.coordinates).map((d2, i) => d2 / sizeInPixels[i]);
-        const position = {
-          left: `${relativeX * 100}%`,
-          top: `${relativeY * 100}%`
-        };
-        this.styleTextElement(textElement, featureStyle.text, position);
-        const bbox = this.getElementBBox(textElement, {
-          x: relativeX * viewPortSize[0],
-          y: relativeY * viewPortSize[1]
-        });
-        if (declutterTree.collides(bbox)) {
-          continue;
-        }
-        declutterTree.insert(bbox);
-        if (this.layer.drawCollisionBoxes) {
-          const collisionBoxDebugElement = this.getCollisionBoxElement(bbox);
-          textElements.push(collisionBoxDebugElement);
-        }
-        textElements.push(textElement);
-      }
-      replaceChildren(this._element, textElements);
-      return this._element;
-    }
-    getTextElementWithID(id2) {
-      const elementId = `text-feature-${id2}`;
-      let textElement = this._element.querySelector(`#${elementId}`);
-      if (!textElement) {
-        textElement = document.createElement("div");
-        textElement.id = elementId;
-      }
-      return textElement;
-    }
-    styleTextElement(element, textStyle, position) {
-      const style2 = element.style;
-      style2.position = "absolute";
-      style2.transform = `translate(-50%, -50%)`;
-      style2.left = position.left;
-      style2.top = position.top;
-      style2.textAlign = "center";
-      style2.whiteSpace = "nowrap";
-      style2.fontFamily = textStyle.fontFamily;
-      style2.fontSize = textStyle.fontSize;
-      style2.fontWeight = textStyle.fontWeight;
-      style2.lineHeight = textStyle.lineHeight;
-      style2.color = textStyle.color;
-      style2.textShadow = textStyle.textShadow;
-      style2.padding = `${textPadding.top}px ${textPadding.right}px ${textPadding.bottom}px ${textPadding.left}px`;
-    }
-    getElementBBox(element, position) {
-      if (!element.parentElement) {
-        document.body.appendChild(element);
-      }
-      const { width, height } = element.getBoundingClientRect();
-      if (element.parentElement !== this._element) {
-        element.remove();
-      }
-      return {
-        minX: Math.floor(position.x) - width / 2,
-        minY: Math.floor(position.y) - height / 2,
-        maxX: Math.ceil(position.x + width / 2),
-        maxY: Math.ceil(position.y + height / 2)
-      };
-    }
-    getCollisionBoxElement(bbox) {
-      const element = document.createElement("div");
-      const style2 = element.style;
-      style2.position = "absolute";
-      style2.left = `${bbox.minX}px`;
-      style2.top = `${bbox.minY}px`;
-      style2.width = `${bbox.maxX - bbox.minX}px`;
-      style2.height = `${bbox.maxY - bbox.minY}px`;
-      style2.border = "2px solid black";
-      return element;
-    }
-  }
-  class Style {
-    constructor(properties) {
-      this.stroke = properties == null ? void 0 : properties.stroke;
-      this.fill = properties == null ? void 0 : properties.fill;
-      this.text = properties == null ? void 0 : properties.text;
-    }
-    clone() {
-      return new Style({
-        stroke: this.stroke,
-        fill: this.fill,
-        text: this.text
-      });
-    }
-  }
   function memoise(fn) {
     let called = false;
     let lastResult;
@@ -6365,928 +6196,1302 @@
       return lastResult;
     };
   }
-  function toRgba(color2, opacity = 1) {
-    color2 = color2.replace(/\s+/g, "").toLowerCase();
-    if (color2.startsWith("#")) {
-      color2 = color2.replace(/^#/, "");
-      if (color2.length === 3) {
-        color2 = color2.split("").map((char) => char + char).join("");
-      }
-      let r = parseInt(color2.substring(0, 2), 16);
-      let g = parseInt(color2.substring(2, 4), 16);
-      let b = parseInt(color2.substring(4, 6), 16);
-      return `rgba(${r}, ${g}, ${b}, ${opacity})`;
-    }
-    let rgbaMatch = color2.match(/^rgba?\((\d+),(\d+),(\d+)(?:,(\d+(\.\d+)?))?\)$/);
-    if (rgbaMatch) {
-      let r = parseInt(rgbaMatch[1], 10);
-      let g = parseInt(rgbaMatch[2], 10);
-      let b = parseInt(rgbaMatch[3], 10);
-      let a = rgbaMatch[4] !== void 0 ? parseFloat(rgbaMatch[4]) : opacity;
-      return `rgba(${r}, ${g}, ${b}, ${a})`;
-    }
-    throw new Error("Unsupported color format");
-  }
-  class Stroke {
-    constructor(options) {
-      this.color = (options == null ? void 0 : options.color) || "#121212";
-      this.width = (options == null ? void 0 : options.width) || 0.5;
-      this.opacity = (options == null ? void 0 : options.opacity) || 1;
-      this._getRgba = memoise(toRgba);
+  class Feature {
+    /**
+     * Represents a feature on the map
+     * @constructor
+     * @param {Object} props - The properties for the feature.
+     * @property {string} id - The unique identifier of the feature
+     * @property {Array} geometries - The geometries of the feature
+     * @property {Object} properties - The properties of the feature
+     * @property {import("./styles").Style | import("./styles").StyleFunction} style - The style of the feature
+     */
+    constructor({ id: id2, geometries, properties, style: style2 }) {
+      this.id = id2;
+      this.geometries = geometries;
+      this.properties = properties;
+      this.style = style2;
+      this.uid = createUid();
+      this._getProjectedGeometries = memoise((projection) => {
+        return this.geometries.map(
+          (d2) => d2.getProjected(projection, projection.revision)
+        );
+      }).bind(this);
     }
-    getRgba() {
-      return this._getRgba(this.color, this.opacity);
+    setGeometries(geometries) {
+      this.geometries = geometries;
+      this._extent = void 0;
     }
-  }
-  class Fill {
-    constructor(options) {
-      this.color = (options == null ? void 0 : options.color) || "#CCC";
-      this.opacity = (options == null ? void 0 : options.opacity) || 1;
-      this._getRgba = memoise(toRgba);
+    getExtent() {
+      if (this._extent) return this._extent;
+      const extent = this.geometries.reduce((combinedExtent, geometry) => {
+        if (!combinedExtent) return geometry.extent;
+        return combineExtents(geometry.extent, combinedExtent);
+      }, null);
+      this._extent = extent;
+      return extent;
     }
-    getRgba() {
-      return this._getRgba(this.color, this.opacity);
+    getProjectedGeometries(projection) {
+      return this._getProjectedGeometries(projection, projection.revision);
     }
-  }
-  class Text {
-    constructor(options) {
-      this.content = options == null ? void 0 : options.content;
-      this.fontFamily = (options == null ? void 0 : options.fontFamily) || "var(--text-sans)";
-      this.fontSize = (options == null ? void 0 : options.fontSize) || "17px";
-      this.fontWeight = (options == null ? void 0 : options.fontWeight) || "400";
-      this.lineHeight = (options == null ? void 0 : options.lineHeight) || 1.3;
-      this.color = (options == null ? void 0 : options.color) || "#121212";
-      this.textShadow = (options == null ? void 0 : options.textShadow) || "1px 1px 0px #f6f6f6, -1px -1px 0px #f6f6f6, -1px 1px 0px #f6f6f6, 1px -1px #f6f6f6";
+    getStyleFunction() {
+      const style2 = this.style;
+      if (!style2) return null;
+      if (typeof style2 === "function") return style2;
+      return () => {
+        return style2;
+      };
     }
-  }
-  class TinyQueue {
-    constructor(data = [], compare = defaultCompare) {
-      this.data = data;
-      this.length = this.data.length;
-      this.compare = compare;
-      if (this.length > 0) {
-        for (let i = (this.length >> 1) - 1; i >= 0; i--) this._down(i);
+    containsCoordinate(coordinate) {
+      if (!containsCoordinate(this.getExtent(), coordinate)) {
+        return false;
       }
+      for (const geometries of this.geometries) {
+        if (d3Geo.geoContains(geometries.getGeoJSON(), coordinate)) {
+          return true;
+        }
+      }
+      return false;
     }
-    push(item) {
-      this.data.push(item);
-      this.length++;
-      this._up(this.length - 1);
-    }
-    pop() {
-      if (this.length === 0) return void 0;
-      const top = this.data[0];
-      const bottom = this.data.pop();
-      this.length--;
-      if (this.length > 0) {
-        this.data[0] = bottom;
-        this._down(0);
-      }
-      return top;
+    clone() {
+      return new Feature({
+        id: this.id,
+        geometries: this.geometries.map((d2) => d2.clone()),
+        properties: this.properties,
+        style: this.style
+      });
     }
-    peek() {
-      return this.data[0];
+    /**
+     * Returns the geometries as a GeoJSON object
+     * @returns {Object} The GeoJSON representation of the geometries
+     */
+    getGeoJSON() {
+      const geometries = this.geometries.map((d2) => d2.getGeoJSON());
+      if (geometries.length === 1) return geometries[0];
+      return {
+        type: "Feature",
+        geometry: this._getGeometryGeoJSON(),
+        properties: this.properties
+      };
     }
-    _up(pos) {
-      const { data, compare } = this;
-      const item = data[pos];
-      while (pos > 0) {
-        const parent = pos - 1 >> 1;
-        const current = data[parent];
-        if (compare(item, current) >= 0) break;
-        data[pos] = current;
-        pos = parent;
+    _getGeometryGeoJSON() {
+      const geometries = this.geometries.map((d2) => d2.getGeoJSON());
+      if (geometries.length === 0) throw new Error("Feature has no geometries");
+      if (geometries.length === 1) return geometries[0];
+      if (geometries[0].type === "Polygon") {
+        return {
+          type: "MultiPolygon",
+          coordinates: geometries.map((d2) => d2.coordinates)
+        };
+      } else if (geometries[0].type === "LineString") {
+        return {
+          type: "MultiLineString",
+          coordinates: geometries.map((d2) => d2.coordinates)
+        };
+      } else if (geometries[0].type === "Point") {
+        return {
+          type: "MultiPoint",
+          coordinates: geometries.map((d2) => d2.coordinates)
+        };
       }
-      data[pos] = item;
+      throw new Error("Could not determine geometry type");
     }
-    _down(pos) {
-      const { data, compare } = this;
-      const halfLength = this.length >> 1;
-      const item = data[pos];
-      while (pos < halfLength) {
-        let left = (pos << 1) + 1;
-        let best = data[left];
-        const right = left + 1;
-        if (right < this.length && compare(data[right], best) < 0) {
-          left = right;
-          best = data[right];
-        }
-        if (compare(best, item) >= 0) break;
-        data[pos] = best;
-        pos = left;
-      }
-      data[pos] = item;
+  }
+  class Geometry {
+    /**
+     * Represents vector geometry
+     * @constructor
+     * @param {Object} options
+     * @param {string} options.type - The type of geometry (e.g., 'Point', 'LineString', 'Polygon')
+     * @param {Array} options.extent - The extent of the geometry (e.g., [xmin, ymin, xmax, ymax])
+     * @param {Array} options.coordinates - The coordinates of the geometry (e.g., [[x1, y1], [x2, y2], ...])
+     */
+    constructor({ type, extent, coordinates }) {
+      this.type = type;
+      this.extent = extent;
+      this.coordinates = coordinates;
+      this.getProjected = memoise(this._getProjected).bind(this);
+    }
+    /**
+     * Returns the geometry as a GeoJSON object
+     * @function
+     * @param {import("../projection").Projection} projection - The projection to use for the geometry
+     * @returns {Object} A GeoJSON representation of the projected geometry
+     * @private
+     */
+    // eslint-disable-next-line no-unused-vars
+    _getProjected(projection) {
+      throw new Error("Not implemented");
+    }
+    /**
+     * Returns the geometry as a GeoJSON object
+     * @returns {Object} The GeoJSON representation of the geometry
+     */
+    getGeoJSON() {
+      return {
+        type: this.type,
+        coordinates: this.coordinates
+      };
     }
   }
-  function defaultCompare(a, b) {
-    return a < b ? -1 : a > b ? 1 : 0;
+  class LineString extends Geometry {
+    constructor({ type = "LineString", extent, coordinates }) {
+      super({ type, extent, coordinates });
+    }
+    _getProjected(projection) {
+      const projected = [];
+      for (const point of this.coordinates) {
+        projected.push(projection(point));
+      }
+      return {
+        type: this.type,
+        coordinates: projected
+      };
+    }
   }
-  function knn(tree, x, y, n2, predicate, maxDistance) {
-    let node = tree.data;
-    const result = [];
-    const toBBox = tree.toBBox;
-    const queue = new TinyQueue(void 0, compareDist);
-    while (node) {
-      for (let i = 0; i < node.children.length; i++) {
-        const child = node.children[i];
-        const dist = boxDist(x, y, node.leaf ? toBBox(child) : child);
-        {
-          queue.push({
-            node: child,
-            isItem: node.leaf,
-            dist
-          });
+  class Polygon extends Geometry {
+    constructor({ type = "Polygon", extent, coordinates }) {
+      super({ type, extent, coordinates });
+    }
+    _getProjected(projection) {
+      const projected = [];
+      const rings = this.coordinates;
+      for (const ring of rings) {
+        const projectedRing = [];
+        for (const point of ring) {
+          const projectedPoint = projection(point);
+          if (projectedPoint) {
+            projectedRing.push(projectedPoint);
+          } else {
+            break;
+          }
+        }
+        if (projectedRing.length > 0) {
+          projected.push(projectedRing);
         }
       }
-      while (queue.length && queue.peek().isItem) {
-        const candidate = queue.pop().node;
-        if (!predicate || predicate(candidate))
-          result.push(candidate);
-        if (result.length === n2) return result;
-      }
-      node = queue.pop();
-      if (node) node = node.node;
+      return {
+        type: this.type,
+        coordinates: projected
+      };
     }
-    return result;
-  }
-  function compareDist(a, b) {
-    return a.dist - b.dist;
-  }
-  function boxDist(x, y, box) {
-    const dx = axisDist(x, box.minX, box.maxX), dy = axisDist(y, box.minY, box.maxY);
-    return dx * dx + dy * dy;
-  }
-  function axisDist(k, min, max) {
-    return k < min ? min - k : k <= max ? 0 : k - max;
-  }
-  class VectorSource {
-    constructor({ features }) {
-      this.dispatcher = new Dispatcher(this);
-      this._featuresRtree = new RBush();
-      this.setFeatures(features);
+    getOuterRing() {
+      return this.coordinates[0];
     }
-    tearDown() {
-      this.dispatcher = null;
+    setOuterRing(coordinates) {
+      this.coordinates[0] = coordinates;
     }
-    getFeatures() {
-      return this._features;
+    setCoordinates(coordinates) {
+      this.coordinates = coordinates;
     }
-    getFeaturesAtCoordinate(coordinate) {
-      const [lon, lat] = coordinate;
-      const features = knn(
-        this._featuresRtree,
-        lon,
-        lat,
-        10,
-        (d2) => d2.feature.containsCoordinate(coordinate)
-      ).map((d2) => {
-        const midX = d2.minX + (d2.minX + d2.maxX) / 2;
-        const midY = d2.minY + (d2.minY + d2.maxY) / 2;
-        d2.distance = Math.hypot(midX - lon, midY - lat);
-        return d2;
+    clone() {
+      return new Polygon({
+        extent: this.extent,
+        coordinates: JSON.parse(JSON.stringify(this.coordinates))
       });
-      features.sort((a, b) => a.distance - b.distance);
-      return features.map((d2) => d2.feature);
     }
-    getFeaturesInExtent(extent) {
-      const [minX, minY, maxX, maxY] = extent;
-      return this._featuresRtree.search({ minX, minY, maxX, maxY }).map((d2) => d2.feature);
+  }
+  class Point extends Geometry {
+    constructor({ type = "Point", coordinates }) {
+      super({ type, extent: null, coordinates });
+      this.extent = [...coordinates, ...coordinates];
     }
-    setFeatures(features) {
-      this._featuresRtree.clear();
-      for (const feature of features) {
-        const [minX, minY, maxX, maxY] = feature.getExtent();
-        this._featuresRtree.insert({
-          minX: Math.floor(minX),
-          minY: Math.floor(minY),
-          maxX: Math.ceil(maxX),
-          maxY: Math.ceil(maxY),
-          feature
-        });
-      }
-      this._features = features;
-      this.dispatcher.dispatch(MapEvent.CHANGE);
+    _getProjected(projection) {
+      return {
+        type: this.type,
+        coordinates: projection(this.coordinates)
+      };
     }
   }
-  class TextLayer {
-    /** @param {TextLayerComponentProps} props */
-    static Component({
-      features,
-      style: style2,
-      minZoom,
-      opacity,
-      declutter,
-      drawCollisionBoxes
-    }) {
-      const { registerLayer } = hooks.useContext(MapContext);
-      const layer = hooks.useMemo(
-        () => TextLayer.with(features, {
-          style: style2,
-          minZoom,
-          opacity,
-          declutter,
-          drawCollisionBoxes
-        }),
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-        [features, minZoom, opacity, declutter, drawCollisionBoxes]
-      );
-      registerLayer(layer);
-      hooks.useEffect(() => {
-        layer.style = style2;
-      }, [style2]);
+  class GeoJSON {
+    readFeaturesFromObject(object) {
+      const geoJSONObject = object;
+      let features = null;
+      if (geoJSONObject["type"] === "FeatureCollection") {
+        const geoJSONFeatureCollection = object;
+        features = [];
+        const geoJSONFeatures = geoJSONFeatureCollection["features"];
+        for (let i = 0, ii = geoJSONFeatures.length; i < ii; ++i) {
+          const featureObject = this.readFeatureFromObject(geoJSONFeatures[i]);
+          if (!featureObject) {
+            continue;
+          }
+          features.push(featureObject);
+        }
+      } else if (geoJSONObject["type"] === "Feature") {
+        features = [this.readFeatureFromObject(geoJSONObject)];
+      } else if (Array.isArray(geoJSONObject)) {
+        features = [];
+        for (let i = 0, ii = geoJSONObject.length; i < ii; ++i) {
+          const featureObject = this.readFeatureFromObject(geoJSONObject[i]);
+          if (!featureObject) {
+            continue;
+          }
+          features.push(featureObject);
+        }
+      } else {
+        try {
+          const geometries = this.readGeometriesFromObject(geoJSONObject);
+          const feature = new Feature({ geometries });
+          features = [feature];
+        } catch {
+          console.warn("Unable to interpret GeoJSON:", geoJSONObject);
+          return;
+        }
+      }
+      return features.flat();
+    }
+    readFeatureFromObject(geoJSONObject) {
+      const geometries = this.readGeometriesFromObject(geoJSONObject["geometry"]);
+      if (geometries.length > 0) {
+        return new Feature({
+          id: geoJSONObject["id"],
+          geometries,
+          properties: geoJSONObject["properties"]
+        });
+      }
       return null;
     }
+    readGeometriesFromObject(geometry) {
+      const geometries = [];
+      if (geometry.type === "Polygon") {
+        const polygon = this.readPolygonForCoordinates(geometry.coordinates);
+        geometries.push(polygon);
+      } else if (geometry.type === "MultiPolygon") {
+        for (const polygonCoordinates of geometry.coordinates) {
+          const polygon = this.readPolygonForCoordinates(polygonCoordinates);
+          geometries.push(polygon);
+        }
+      } else if (geometry.type === "LineString") {
+        const lineString = this.readLineStringForCoordinates(geometry.coordinates);
+        geometries.push(lineString);
+      } else if (geometry.type === "MultiLineString") {
+        for (const lineStringCoordinates of geometry.coordinates) {
+          const lineString = this.readLineStringForCoordinates(
+            lineStringCoordinates
+          );
+          geometries.push(lineString);
+        }
+      } else if (geometry.type === "Point") {
+        const point = this.readPointForCoordinates(geometry.coordinates);
+        geometries.push(point);
+      }
+      return geometries;
+    }
+    readPolygonForCoordinates(coordinates) {
+      const outerRing = coordinates[0];
+      const extent = extentForCoordinates(outerRing);
+      return new Polygon({ extent, coordinates });
+    }
+    readLineStringForCoordinates(coordinates) {
+      const extent = extentForCoordinates(coordinates);
+      return new LineString({ extent, coordinates });
+    }
+    readPointForCoordinates(coordinates) {
+      return new Point({ coordinates });
+    }
+  }
+  class FeatureCollection {
     /**
-     * @param {import("../Feature").Feature[]} features
-     * @param {TextLayerOptions} options
+     * Create a feature collection from GeoJSON features.
+     * @param {Object[]} geoJSON - The GeoJSON object
+     * @returns {FeatureCollection} The feature collection
      */
-    static with(features, options) {
-      const source = new VectorSource({ features });
-      return new TextLayer({ source, ...options });
+    static fromGeoJSON(geoJSON) {
+      const features = new GeoJSON().readFeaturesFromObject(geoJSON);
+      return new FeatureCollection(features);
     }
     /**
-     * @param {Object} params
-     * @param {VectorSource} params.source
-     * @param {Style} [params.style=undefined]
-     * @param {number} [params.minZoom=0]
-     * @param {number} [params.opacity=1]
-     * @param {boolean} [params.declutter=true]
-     * @param {boolean} [params.drawCollisionBoxes=false]
+     * Create a feature collection.
+     * @constructor
+     * @param {import("./Feature").Feature[]} features - The features to put in the collection
      */
-    constructor({
-      source,
-      style: style2,
-      minZoom = 0,
-      opacity = 1,
-      declutter = true,
-      drawCollisionBoxes = false
-    }) {
-      this.source = source;
-      this._style = style2;
-      this.minZoom = minZoom;
-      this.opacity = opacity;
-      this.declutter = declutter;
-      this.drawCollisionBoxes = drawCollisionBoxes;
-      this.renderer = new TextLayerRenderer(this);
-      this.dispatcher = new Dispatcher(this);
+    constructor(features) {
+      this.features = features;
     }
-    tearDown() {
-      this.dispatcher = null;
+  }
+  class Style {
+    constructor(properties) {
+      this.stroke = properties == null ? void 0 : properties.stroke;
+      this.fill = properties == null ? void 0 : properties.fill;
+      this.text = properties == null ? void 0 : properties.text;
     }
-    get style() {
-      if (this._style) return this._style;
-      const defaultStyle = new Style({
-        text: new Text()
+    clone() {
+      return new Style({
+        stroke: this.stroke,
+        fill: this.fill,
+        text: this.text
       });
-      return defaultStyle;
     }
-    set style(style2) {
-      this._style = style2;
-      this.dispatcher.dispatch(MapEvent.CHANGE);
+  }
+  function toRgba(color2, opacity = 1) {
+    color2 = color2.replace(/\s+/g, "").toLowerCase();
+    if (color2.startsWith("#")) {
+      color2 = color2.replace(/^#/, "");
+      if (color2.length === 3) {
+        color2 = color2.split("").map((char) => char + char).join("");
+      }
+      let r = parseInt(color2.substring(0, 2), 16);
+      let g = parseInt(color2.substring(2, 4), 16);
+      let b = parseInt(color2.substring(4, 6), 16);
+      return `rgba(${r}, ${g}, ${b}, ${opacity})`;
     }
-    getExtent() {
-      if (this._extent) return this._extent;
-      const features = this.source.getFeatures();
-      const extent = features.reduce((combinedExtent, feature) => {
-        const featureExtent = feature.getExtent();
-        if (!combinedExtent) return featureExtent;
-        return combineExtents(featureExtent, combinedExtent);
-      }, null);
-      this._extent = extent;
-      return extent;
+    let rgbaMatch = color2.match(/^rgba?\((\d+),(\d+),(\d+)(?:,(\d+(\.\d+)?))?\)$/);
+    if (rgbaMatch) {
+      let r = parseInt(rgbaMatch[1], 10);
+      let g = parseInt(rgbaMatch[2], 10);
+      let b = parseInt(rgbaMatch[3], 10);
+      let a = rgbaMatch[4] !== void 0 ? parseFloat(rgbaMatch[4]) : opacity;
+      return `rgba(${r}, ${g}, ${b}, ${a})`;
     }
-    getStyleFunction() {
-      const style2 = this.style;
-      if (typeof style2 === "function") return style2;
-      return () => {
-        return style2;
-      };
+    throw new Error("Unsupported color format");
+  }
+  const StrokePosition = {
+    CENTER: "center",
+    INSIDE: "inside"
+  };
+  class Stroke {
+    constructor(options) {
+      this.color = (options == null ? void 0 : options.color) || "#121212";
+      this.width = (options == null ? void 0 : options.width) || 0.5;
+      this.opacity = (options == null ? void 0 : options.opacity) || 1;
+      this.position = (options == null ? void 0 : options.position) || StrokePosition.CENTER;
+      this._getRgba = memoise(toRgba);
     }
-    renderFrame(frameState, targetElement) {
-      return this.renderer.renderFrame(frameState, targetElement);
+    getRgba() {
+      return this._getRgba(this.color, this.opacity);
     }
   }
-  class VectorLayerRenderer {
-    constructor(layer) {
-      this.layer = layer;
-      this.featureRenderer = new FeatureRenderer();
+  class Fill {
+    constructor(options) {
+      this.color = (options == null ? void 0 : options.color) || "#CCC";
+      this.opacity = (options == null ? void 0 : options.opacity) || 1;
+      this._getRgba = memoise(toRgba);
     }
-    renderFrame(frameState, targetElement) {
-      if (this.layer.opacity === 0) return targetElement;
-      const { projection, sizeInPixels, visibleExtent, transform } = frameState.viewState;
-      const container2 = this.getOrCreateContainer(targetElement, sizeInPixels);
-      const context = container2.firstElementChild.getContext("2d");
-      context.save();
-      context.translate(transform.x, transform.y);
-      context.scale(transform.k, transform.k);
-      context.lineJoin = "round";
-      context.lineCap = "round";
-      context.globalAlpha = this.layer.opacity;
-      const source = this.layer.source;
-      const features = source.getFeaturesInExtent(visibleExtent);
-      for (const feature of features) {
-        const styleFunction2 = feature.getStyleFunction() || this.layer.getStyleFunction();
-        const featureStyle = styleFunction2(feature);
-        if ((featureStyle == null ? void 0 : featureStyle.stroke) || (featureStyle == null ? void 0 : featureStyle.fill)) {
-          context.save();
-          this.featureRenderer.setStyle(featureStyle);
-          this.featureRenderer.render(frameState, feature, context);
-          context.restore();
-        }
-      }
-      if (Object.prototype.hasOwnProperty.call(projection, "getCompositionBorders")) {
-        context.beginPath();
-        context.lineWidth = 1 / transform.k;
-        context.strokeStyle = "#999";
-        projection.drawCompositionBorders(context);
-        context.stroke();
+    getRgba() {
+      return this._getRgba(this.color, this.opacity);
+    }
+  }
+  const TextAnchor = {
+    TOP: "top",
+    BOTTOM: "bottom",
+    LEFT: "left",
+    RIGHT: "right",
+    CENTER: "center",
+    TOP_LEFT: "top-left",
+    TOP_RIGHT: "top-right",
+    BOTTOM_LEFT: "bottom-left",
+    BOTTOM_RIGHT: "bottom-right"
+  };
+  class Text {
+    /**
+     * Create a text element style
+     * @constructor
+     * @param {TextStyle} options - Style options
+     */
+    constructor(options) {
+      this.content = options == null ? void 0 : options.content;
+      this.anchor = (options == null ? void 0 : options.anchor) || TextAnchor.CENTER;
+      this.fontFamily = (options == null ? void 0 : options.fontFamily) || "var(--text-sans)";
+      this.fontSize = (options == null ? void 0 : options.fontSize) || "17px";
+      this.fontWeight = (options == null ? void 0 : options.fontWeight) || "400";
+      this.lineHeight = (options == null ? void 0 : options.lineHeight) || 1.3;
+      this.color = (options == null ? void 0 : options.color) || "#121212";
+      this.textShadow = (options == null ? void 0 : options.textShadow) || "1px 1px 0px #f6f6f6, -1px -1px 0px #f6f6f6, -1px 1px 0px #f6f6f6, 1px -1px #f6f6f6";
+      this.radialOffset = (options == null ? void 0 : options.radialOffset) || 0;
+    }
+    /**
+     * Get the relative translation for the text element based on its anchor. The translation does not take `radialOffset` into account
+     * @private
+     * @return {{x: number, y: number}} - The x and y translation in percentage points
+     */
+    _getRelativeTranslation() {
+      switch (this.anchor) {
+        case TextAnchor.TOP:
+          return { x: -50, y: 0 };
+        case TextAnchor.BOTTOM:
+          return { x: -50, y: -100 };
+        case TextAnchor.LEFT:
+          return { x: 0, y: -50 };
+        case TextAnchor.RIGHT:
+          return { x: -100, y: -50 };
+        case TextAnchor.CENTER:
+          return { x: -50, y: -50 };
+        case TextAnchor.TOP_LEFT:
+          return { x: 0, y: 0 };
+        case TextAnchor.TOP_RIGHT:
+          return { x: 100, y: 0 };
+        case TextAnchor.BOTTOM_LEFT:
+          return { x: 0, y: 100 };
+        case TextAnchor.BOTTOM_RIGHT:
+          return { x: 100, y: 100 };
+        default:
+          return { x: 0, y: 0 };
       }
-      context.restore();
-      return container2;
-    }
-    getOrCreateContainer(targetElement, sizeInPixels) {
-      let container2 = null;
-      let containerReused = false;
-      let canvas = targetElement && targetElement.firstElementChild;
-      if (canvas instanceof HTMLCanvasElement) {
-        container2 = targetElement;
-        containerReused = true;
-      } else if (this._container) {
-        container2 = this._container;
-      } else {
-        container2 = this.createContainer();
-      }
-      if (!containerReused) {
-        const canvas2 = container2.firstElementChild;
-        canvas2.width = sizeInPixels[0];
-        canvas2.height = sizeInPixels[1];
-      }
-      this._container = container2;
-      return container2;
-    }
-    createContainer() {
-      const container2 = document.createElement("div");
-      container2.className = "gv-map-layer";
-      let style2 = container2.style;
-      style2.position = "absolute";
-      style2.width = "100%";
-      style2.height = "100%";
-      const canvas = document.createElement("canvas");
-      style2 = canvas.style;
-      style2.position = "absolute";
-      style2.width = "100%";
-      style2.height = "100%";
-      container2.appendChild(canvas);
-      return container2;
-    }
-  }
-  class VectorLayer {
-    /** @param {VectorLayerComponentProps} props */
-    static Component({ features, style: style2, minZoom, opacity, hitDetectionEnabled }) {
-      const { registerLayer } = hooks.useContext(MapContext);
-      const layer = hooks.useMemo(
-        () => VectorLayer.with(features, {
-          style: style2,
-          minZoom,
-          opacity,
-          hitDetectionEnabled
-        }),
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-        [features, minZoom, opacity, hitDetectionEnabled]
-      );
-      registerLayer(layer);
-      hooks.useEffect(() => {
-        layer.style = style2;
-      }, [style2]);
-      return null;
     }
     /**
-     * @param {import("../Feature").Feature[]} features
-     * @param {VectorLayerOptions} options
+     * Get the translation for the text element in pixels
+     * @param {number} elementWidth - The width of the element
+     * @param {number} elementHeight - The height of the element
+     * @return {{x: number, y: number}} - The x and y translation in pixels
      */
-    static with(features, options) {
-      const source = new VectorSource({ features });
-      return new VectorLayer({ source, ...options });
+    getTranslation(elementWidth, elementHeight) {
+      const translate = this._getRelativeTranslation();
+      let x = translate.x / 100 * elementWidth;
+      let y = translate.y / 100 * elementHeight;
+      const radialOffsetInPixels = this.radialOffset * this.fontSize.replace("px", "");
+      switch (this.anchor) {
+        case TextAnchor.TOP:
+          y += radialOffsetInPixels;
+          break;
+        case TextAnchor.BOTTOM:
+          y -= radialOffsetInPixels;
+          break;
+        case TextAnchor.LEFT:
+          x += radialOffsetInPixels;
+          break;
+        case TextAnchor.RIGHT:
+          x -= radialOffsetInPixels;
+          break;
+        case TextAnchor.CENTER:
+          break;
+        case TextAnchor.TOP_LEFT:
+          x += radialOffsetInPixels;
+          y += radialOffsetInPixels;
+          break;
+        case TextAnchor.TOP_RIGHT:
+          x -= radialOffsetInPixels;
+          y += radialOffsetInPixels;
+          break;
+        case TextAnchor.BOTTOM_LEFT:
+          x += radialOffsetInPixels;
+          y -= radialOffsetInPixels;
+          break;
+        case TextAnchor.BOTTOM_RIGHT:
+          x -= radialOffsetInPixels;
+          y -= radialOffsetInPixels;
+          break;
+      }
+      return { x, y };
     }
     /**
-     * @param {Object} params
-     * @param {VectorSource} params.source
-     * @param {Style | (() => Style)} [params.style=undefined]
-     * @param {number} [params.minZoom=0]
-     * @param {number} [params.opacity=1]
-     * @param {boolean} [params.hitDetectionEnabled=false]
+     * Get the transform for the text element
+     * @param {number} elementWidth - The width of the element
+     * @param {number} elementHeight - The height of the element
+     * @return {string} - The transform for the text element
      */
-    constructor({
-      source,
-      style: style2,
-      minZoom = 0,
-      opacity = 1,
-      hitDetectionEnabled = true
-    }) {
-      this.dispatcher = new Dispatcher(this);
-      this.renderer = new VectorLayerRenderer(this);
-      this.source = source;
-      this._style = style2;
-      this.minZoom = minZoom;
-      this.opacity = opacity;
-      this.hitDetectionEnabled = hitDetectionEnabled;
-    }
-    get source() {
-      return this._source;
+    getTransform(elementWidth, elementHeight) {
+      const { x, y } = this.getTranslation(elementWidth, elementHeight);
+      return `translate(${x}px, ${y}px)`;
     }
-    set source(source) {
-      if (this._source && source !== this._source) {
-        this._source.tearDown();
-      }
-      this._source = source;
-      source.on(MapEvent.CHANGE, () => {
-        this._extent = null;
-        this.dispatcher.dispatch(MapEvent.CHANGE);
-      });
+  }
+  class FeatureRenderer {
+    constructor() {
+      this.drawingFunction = d3Geo.geoPath();
     }
-    setRawProjection(projection) {
-      this.projection = projection;
+    setStyle(style2) {
+      this.style = style2;
     }
-    tearDown() {
-      this.dispatcher = null;
+    setFeature(feature) {
+      this.feature = feature;
     }
-    get style() {
-      if (this._style) return this._style;
-      const defaultStyle = new Style({
-        stroke: new Stroke()
-      });
-      return defaultStyle;
+    render(frameState, context) {
+      if (!this.style) {
+        return;
+      }
+      const feature = this.feature;
+      const { projection, transform, pixelRatio } = frameState.viewState;
+      const { stroke, fill } = this.style;
+      const geometries = feature.getProjectedGeometries(projection);
+      if (frameState.debug) {
+        try {
+          validateGeometries(geometries);
+        } catch {
+          console.error(
+            `Invalid geometry. Feature skipped during rendering. Click here to inspect geometry: ${generateDebugUrl(feature)} 
+`,
+            feature
+          );
+        }
+      }
+      this.drawPath(geometries, context);
+      if (fill) {
+        context.fillStyle = fill.getRgba();
+        context.fill();
+      }
+      if (stroke) {
+        context.save();
+        this.drawStroke(frameState, context, {
+          style: stroke.getRgba(),
+          width: stroke.width / transform.k * pixelRatio,
+          position: stroke.position
+        });
+        context.restore();
+      }
     }
-    set style(style2) {
-      this._style = style2;
-      this.dispatcher.dispatch(MapEvent.CHANGE);
+    drawPath(geometries, context, clipPath = false) {
+      this.drawingFunction.context(context);
+      context.beginPath();
+      for (const geometry of geometries) {
+        this.drawingFunction(geometry);
+      }
+      if (clipPath) {
+        context.clip();
+      } else {
+        context.closePath();
+      }
     }
-    getStyleFunction() {
-      const style2 = this.style;
-      if (typeof style2 === "function") return style2;
-      return () => {
-        return style2;
-      };
+    drawStroke(frameState, context, { style: style2, width: strokeWidth, position }) {
+      const { projection } = frameState.viewState;
+      context.lineWidth = strokeWidth;
+      context.strokeStyle = style2;
+      if (position === StrokePosition.INSIDE) {
+        context.lineWidth = strokeWidth * 2;
+        const geometries = this.feature.getProjectedGeometries(projection);
+        this.drawPath(geometries, context, true);
+      }
+      context.stroke();
     }
-    getExtent() {
-      if (this._extent) return this._extent;
-      const features = this.source.getFeatures();
-      const extent = features.reduce((combinedExtent, feature) => {
-        const featureExtent = feature.getExtent();
-        if (!combinedExtent) return featureExtent;
-        return combineExtents(featureExtent, combinedExtent);
+    createCanvas(width, height) {
+      const canvas = document.createElement("canvas");
+      canvas.width = width;
+      canvas.height = height;
+      return canvas;
+    }
+    getProjectedExtent(projection) {
+      const geometries = this.feature.getProjectedGeometries(projection);
+      const extent = geometries.reduce((combinedExtent, geometry) => {
+        const bounds = this.drawingFunction.bounds(geometry);
+        if (!combinedExtent) return bounds;
+        return combineExtents(bounds, combinedExtent);
       }, null);
-      this._extent = extent;
       return extent;
     }
-    findFeatures(coordinate) {
-      if (!this.hitDetectionEnabled) return;
-      return this.source.getFeaturesAtCoordinate(coordinate);
-    }
-    renderFrame(frameState, targetElement) {
-      return this.renderer.renderFrame(frameState, targetElement);
-    }
   }
-  function interpolateFeatures(currentFeatures, newFeatures, { interpolate: interpolate2, separate, combine }) {
-    if (currentFeatures.length !== newFeatures.length) {
-      throw new Error(
-        "interpolateFeatures expects an equal number of features for start and end"
-      );
+  class TextLayerRenderer {
+    constructor(layer) {
+      this.layer = layer;
+      this.featureRenderer = new FeatureRenderer();
+      this._element = document.createElement("div");
+      this._element.className = "gv-text-layer";
+      const style2 = this._element.style;
+      style2.position = "absolute";
+      style2.width = "100%";
+      style2.height = "100%";
+      style2.pointerEvents = "none";
+      style2.overflow = "hidden";
     }
-    const featureInterpolators = [];
-    for (let i = 0; i < currentFeatures.length; i++) {
-      const geometryInterpolators = [];
-      const currentGeometries = currentFeatures[i].geometries;
-      const newGeometries = newFeatures[i].geometries;
-      if (newGeometries.length === currentGeometries.length) {
-        for (let e = 0; e < currentGeometries.length; e++) {
-          const currentGeometry = currentGeometries[e];
-          const newGeometry = newGeometries[e];
-          if (currentGeometry.type !== "Polygon" || newGeometry.type !== "Polygon") {
-            throw new Error("interpolateFeatures expects only Polygon geometry");
-          }
-          const shapeInterpolator = interpolate2(
-            currentGeometries[e].getOuterRing(),
-            newGeometries[e].getOuterRing(),
-            { string: false }
+    renderFrame(frameState, targetElement) {
+      if (this.layer.opacity === 0) return targetElement;
+      const { declutterTree } = frameState;
+      const { projection, viewPortSize, sizeInPixels, visibleExtent, transform } = frameState.viewState;
+      this._element.style.opacity = this.layer.opacity;
+      const source = this.layer.source;
+      const features = source.getFeaturesInExtent(visibleExtent);
+      const textElements = [];
+      for (const feature of features) {
+        const geometries = feature.getProjectedGeometries(projection);
+        const point = geometries.find((d2) => d2.type === "Point");
+        if (!point) {
+          throw new Error(
+            `Expected Point geometry for feature in TextLayer: ${feature}`
           );
-          geometryInterpolators.push({
-            type: "default",
-            interpolator: shapeInterpolator
-          });
         }
-      } else if (currentGeometries.length === 1 && newGeometries.length > 1) {
-        const separationInterpolator = separate(
-          currentGeometries[0].getOuterRing(),
-          newGeometries.map((geometry) => geometry.getOuterRing()),
-          { string: false, single: true }
-        );
-        geometryInterpolators.push({
-          type: "separate",
-          interpolator: separationInterpolator
-        });
-      } else if (currentGeometries.length > 1 && newGeometries.length === 1) {
-        const combinationInterpolator = combine(
-          currentGeometries.map((geometry) => geometry.getOuterRing()),
-          newGeometries[0].getOuterRing(),
-          { string: false, single: true }
-        );
-        geometryInterpolators.push({
-          type: "combine",
-          interpolator: combinationInterpolator
+        const styleFunction2 = feature.getStyleFunction() || this.layer.getStyleFunction();
+        const featureStyle = styleFunction2(feature);
+        const textElement = this.getTextElementWithID(feature.uid);
+        textElement.innerText = featureStyle.text.content;
+        const [relativeX, relativeY] = transform.apply(point.coordinates).map((d2, i) => d2 / sizeInPixels[i]);
+        const position = {
+          left: `${relativeX * 100}%`,
+          top: `${relativeY * 100}%`
+        };
+        this.styleTextElement(textElement, featureStyle.text, position);
+        const bbox = this.getElementBBox(textElement, featureStyle.text, {
+          x: relativeX * viewPortSize[0],
+          y: relativeY * viewPortSize[1]
         });
-      } else {
-        throw new Error(
-          `Encountered an unexpected number of geometries: ${currentGeometries.length} and ${newGeometries.length}`
-        );
+        if (declutterTree.collides(bbox)) {
+          continue;
+        }
+        declutterTree.insert(bbox);
+        if (this.layer.drawCollisionBoxes) {
+          const collisionBoxDebugElement = this.getCollisionBoxElement(bbox);
+          textElements.push(collisionBoxDebugElement);
+        }
+        textElements.push(textElement);
       }
-      featureInterpolators.push(geometryInterpolators);
+      replaceChildren(this._element, textElements);
+      return this._element;
     }
-    return (t) => {
-      if (t >= 1) {
-        return newFeatures;
-      }
-      const features = [];
-      for (let i = 0; i < featureInterpolators.length; i++) {
-        const feature = newFeatures[i].clone();
-        const geometries = [];
-        const geometryInterpolators = featureInterpolators[i];
-        for (const [
-          index,
-          { type, interpolator }
-        ] of geometryInterpolators.entries()) {
-          let geometry = feature.geometries[index].clone();
-          let interpolated;
-          switch (type) {
-            case "separate":
-            case "combine":
-              interpolated = interpolator(t);
-              interpolated.forEach((d2) => {
-                const polygon = geometry.clone();
-                polygon.setCoordinates([d2]);
-                geometries.push(polygon);
-              });
-              break;
-            default:
-              geometry.setOuterRing(interpolator(t));
-              geometries.push(geometry);
-              break;
-          }
+    getTextElementWithID(id2) {
+      const elementId = `text-feature-${id2}`;
+      let textElement = this._element.querySelector(`#${elementId}`);
+      if (!textElement) {
+        textElement = document.createElement("div");
+        textElement.id = elementId;
+      }
+      return textElement;
+    }
+    styleTextElement(element, textStyle, position) {
+      const style2 = element.style;
+      style2.position = "absolute";
+      style2.left = position.left;
+      style2.top = position.top;
+      style2.textAlign = "center";
+      style2.whiteSpace = "nowrap";
+      style2.fontFamily = textStyle.fontFamily;
+      style2.fontSize = textStyle.fontSize;
+      style2.fontWeight = textStyle.fontWeight;
+      style2.lineHeight = textStyle.lineHeight;
+      style2.color = textStyle.color;
+      style2.textShadow = textStyle.textShadow;
+      const { width, height } = this.getElementSize(element);
+      style2.transform = textStyle.getTransform(width, height);
+    }
+    getElementSize(element) {
+      if (!element.parentElement) {
+        document.body.appendChild(element);
+      }
+      const { width, height } = element.getBoundingClientRect();
+      if (element.parentElement !== this._element) {
+        element.remove();
+      }
+      return { width, height };
+    }
+    getElementBBox(element, textStyle, position) {
+      const collissionPadding = {
+        top: 2,
+        right: 2,
+        bottom: 2,
+        left: 2
+      };
+      const { width, height } = this.getElementSize(element);
+      const { x: translateX, y: translateY } = textStyle.getTranslation(
+        width,
+        height
+      );
+      const minX = Math.floor(position.x + translateX - collissionPadding.left);
+      const minY = Math.floor(position.y + translateY - collissionPadding.top);
+      return {
+        minX,
+        minY,
+        maxX: Math.ceil(
+          minX + width + collissionPadding.left + collissionPadding.right
+        ),
+        maxY: Math.ceil(
+          minY + height + collissionPadding.top + collissionPadding.bottom
+        )
+      };
+    }
+    getCollisionBoxElement(bbox) {
+      const element = document.createElement("div");
+      const style2 = element.style;
+      style2.position = "absolute";
+      style2.left = `${bbox.minX}px`;
+      style2.top = `${bbox.minY}px`;
+      style2.width = `${bbox.maxX - bbox.minX}px`;
+      style2.height = `${bbox.maxY - bbox.minY}px`;
+      style2.border = "1px solid red";
+      return element;
+    }
+  }
+  class TinyQueue {
+    constructor(data = [], compare = defaultCompare) {
+      this.data = data;
+      this.length = this.data.length;
+      this.compare = compare;
+      if (this.length > 0) {
+        for (let i = (this.length >> 1) - 1; i >= 0; i--) this._down(i);
+      }
+    }
+    push(item) {
+      this.data.push(item);
+      this.length++;
+      this._up(this.length - 1);
+    }
+    pop() {
+      if (this.length === 0) return void 0;
+      const top = this.data[0];
+      const bottom = this.data.pop();
+      this.length--;
+      if (this.length > 0) {
+        this.data[0] = bottom;
+        this._down(0);
+      }
+      return top;
+    }
+    peek() {
+      return this.data[0];
+    }
+    _up(pos) {
+      const { data, compare } = this;
+      const item = data[pos];
+      while (pos > 0) {
+        const parent = pos - 1 >> 1;
+        const current = data[parent];
+        if (compare(item, current) >= 0) break;
+        data[pos] = current;
+        pos = parent;
+      }
+      data[pos] = item;
+    }
+    _down(pos) {
+      const { data, compare } = this;
+      const halfLength = this.length >> 1;
+      const item = data[pos];
+      while (pos < halfLength) {
+        let left = (pos << 1) + 1;
+        let best = data[left];
+        const right = left + 1;
+        if (right < this.length && compare(data[right], best) < 0) {
+          left = right;
+          best = data[right];
         }
-        feature.setGeometry(geometries);
-        features.push(feature);
+        if (compare(best, item) >= 0) break;
+        data[pos] = best;
+        pos = left;
       }
-      return features;
-    };
+      data[pos] = item;
+    }
   }
-  function interpolateStyles(firstStyle, secondStyle, interpolateColors, interpolateNumbers) {
-    const fillInterpolator = interpolateFill(
-      firstStyle.fill,
-      secondStyle.fill,
-      interpolateColors,
-      interpolateNumbers
-    );
-    const strokeInterpolator = interpolateStroke(
-      firstStyle.stroke,
-      secondStyle.stroke,
-      interpolateColors,
-      interpolateNumbers
-    );
-    return (t) => {
-      return new Style({
-        fill: fillInterpolator(t),
-        stroke: strokeInterpolator(t)
-      });
-    };
+  function defaultCompare(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
   }
-  function interpolateFill(fillA, fillB, interpolateColors, interpolateNumbers) {
-    const colorInterpolator = interpolateColors(
-      (fillA == null ? void 0 : fillA.color) ?? "transparent",
-      (fillB == null ? void 0 : fillB.color) ?? "transparent"
-    );
-    const opacityInterpolator = interpolateNumbers(
-      (fillA == null ? void 0 : fillA.opacity) ?? 1,
-      (fillB == null ? void 0 : fillB.opacity) ?? 1
-    );
-    return (t) => {
-      return new Fill({
-        color: colorInterpolator(t),
-        opacity: opacityInterpolator(t)
-      });
-    };
+  function knn(tree, x, y, n2, predicate, maxDistance) {
+    let node = tree.data;
+    const result = [];
+    const toBBox = tree.toBBox;
+    const queue = new TinyQueue(void 0, compareDist);
+    while (node) {
+      for (let i = 0; i < node.children.length; i++) {
+        const child = node.children[i];
+        const dist = boxDist(x, y, node.leaf ? toBBox(child) : child);
+        {
+          queue.push({
+            node: child,
+            isItem: node.leaf,
+            dist
+          });
+        }
+      }
+      while (queue.length && queue.peek().isItem) {
+        const candidate = queue.pop().node;
+        if (!predicate || predicate(candidate))
+          result.push(candidate);
+        if (result.length === n2) return result;
+      }
+      node = queue.pop();
+      if (node) node = node.node;
+    }
+    return result;
   }
-  function interpolateStroke(strokeA, strokeB, interpolateColors, interpolateNumbers) {
-    const colorInterpolator = interpolateColors(
-      (strokeA == null ? void 0 : strokeA.color) ?? "transparent",
-      (strokeB == null ? void 0 : strokeB.color) ?? "transparent"
-    );
-    const opacityInterpolator = interpolateNumbers(
-      (strokeA == null ? void 0 : strokeA.opacity) ?? 1,
-      (strokeB == null ? void 0 : strokeB.opacity) ?? 1
-    );
-    const widthInterpolator = interpolateNumbers(
-      (strokeA == null ? void 0 : strokeA.width) ?? 1,
-      (strokeB == null ? void 0 : strokeB.width) ?? 1
-    );
-    return (t) => {
-      return new Stroke({
-        color: colorInterpolator(t),
-        opacity: opacityInterpolator(t),
-        width: widthInterpolator(t)
+  function compareDist(a, b) {
+    return a.dist - b.dist;
+  }
+  function boxDist(x, y, box) {
+    const dx = axisDist(x, box.minX, box.maxX), dy = axisDist(y, box.minY, box.maxY);
+    return dx * dx + dy * dy;
+  }
+  function axisDist(k, min, max) {
+    return k < min ? min - k : k <= max ? 0 : k - max;
+  }
+  class VectorSource {
+    constructor({ features }) {
+      this.dispatcher = new Dispatcher(this);
+      this._featuresRtree = new RBush();
+      this.setFeatures(features);
+    }
+    tearDown() {
+      this.dispatcher = null;
+    }
+    getFeatures() {
+      return this._features;
+    }
+    getFeaturesAtCoordinate(coordinate) {
+      const [lon, lat] = coordinate;
+      const features = knn(
+        this._featuresRtree,
+        lon,
+        lat,
+        10,
+        (d2) => d2.feature.containsCoordinate(coordinate)
+      ).map((d2) => {
+        const midX = d2.minX + (d2.minX + d2.maxX) / 2;
+        const midY = d2.minY + (d2.minY + d2.maxY) / 2;
+        d2.distance = Math.hypot(midX - lon, midY - lat);
+        return d2;
       });
-    };
+      features.sort((a, b) => a.distance - b.distance);
+      return features.map((d2) => d2.feature);
+    }
+    getFeaturesInExtent(extent) {
+      const [minX, minY, maxX, maxY] = extent;
+      return this._featuresRtree.search({ minX, minY, maxX, maxY }).map((d2) => d2.feature);
+    }
+    setFeatures(features) {
+      this._featuresRtree.clear();
+      for (const feature of features) {
+        const [minX, minY, maxX, maxY] = feature.getExtent();
+        this._featuresRtree.insert({
+          minX: Math.floor(minX),
+          minY: Math.floor(minY),
+          maxX: Math.ceil(maxX),
+          maxY: Math.ceil(maxY),
+          feature
+        });
+      }
+      this._features = features;
+      this.dispatcher.dispatch(MapEvent.CHANGE);
+    }
   }
-  class Feature {
+  class TextLayer {
+    /** @param {TextLayerComponentProps} props */
+    static Component({
+      features: featureCollection,
+      style: style2,
+      minZoom,
+      opacity,
+      declutter,
+      drawCollisionBoxes
+    }) {
+      const { registerLayer } = hooks.useContext(MapContext);
+      const layer = hooks.useMemo(
+        () => {
+          const features = featureCollection instanceof FeatureCollection ? featureCollection.features : (
+            /** @type {import("../Feature").Feature[]} */
+            featureCollection
+          );
+          return TextLayer.with(features, {
+            style: style2,
+            minZoom,
+            opacity,
+            declutter,
+            drawCollisionBoxes
+          });
+        },
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        [featureCollection, minZoom, opacity, declutter, drawCollisionBoxes]
+      );
+      registerLayer(layer);
+      hooks.useEffect(() => {
+        layer.style = style2;
+      }, [style2]);
+      return null;
+    }
+    /**
+     * @param {import("../Feature").Feature[]} features
+     * @param {TextLayerOptions} options
+     */
+    static with(features, options) {
+      const source = new VectorSource({ features });
+      return new TextLayer({ source, ...options });
+    }
     /**
-     * Represents a feature on the map
      * @constructor
-     * @param {Object} props - The properties for the feature.
-     * @property {string} id - The unique identifier of the feature
-     * @property {Array} geometries - The geometries of the feature
-     * @property {Object} properties - The properties of the feature
-     * @property {import("./styles").Style | import("./styles").StyleFunction} style - The style of the feature
+     * @param {Object} params
+     * @param {VectorSource} params.source
+     * @param {Style | (() => Style)} [params.style=undefined]
+     * @param {number} [params.minZoom=0]
+     * @param {number} [params.opacity=1]
+     * @param {boolean} [params.declutter=true]
+     * @param {boolean} [params.drawCollisionBoxes=false]
      */
-    constructor({ id: id2, geometries, properties, style: style2 }) {
-      this.id = id2;
-      this.geometries = geometries;
-      this.properties = properties;
-      this.style = style2;
-      this.uid = createUid();
+    constructor({
+      source,
+      style: style2,
+      minZoom = 0,
+      opacity = 1,
+      declutter = true,
+      drawCollisionBoxes = false
+    }) {
+      this.source = source;
+      this._style = style2;
+      this.minZoom = minZoom;
+      this.opacity = opacity;
+      this.declutter = declutter;
+      this.drawCollisionBoxes = drawCollisionBoxes;
+      this.renderer = new TextLayerRenderer(this);
+      this.dispatcher = new Dispatcher(this);
+    }
+    tearDown() {
+      this.dispatcher = null;
+    }
+    get style() {
+      if (this._style) return this._style;
+      const defaultStyle = new Style({
+        text: new Text()
+      });
+      return defaultStyle;
+    }
+    set style(style2) {
+      this._style = style2;
+      this.dispatcher.dispatch(MapEvent.CHANGE);
     }
     getExtent() {
       if (this._extent) return this._extent;
-      const extent = this.geometries.reduce((combinedExtent, geometries) => {
-        if (!combinedExtent) return geometries.extent;
-        return combineExtents(geometries.extent, combinedExtent);
+      const features = this.source.getFeatures();
+      const extent = features.reduce((combinedExtent, feature) => {
+        const featureExtent = feature.getExtent();
+        if (!combinedExtent) return featureExtent;
+        return combineExtents(featureExtent, combinedExtent);
       }, null);
       this._extent = extent;
       return extent;
     }
-    setgeometries(geometries) {
-      this.geometries = geometries;
-      this._extent = void 0;
-    }
-    getProjectedGeometries(projection) {
-      return this.geometries.map(
-        (d2) => d2.getProjected(projection, projection.revision)
-      );
-    }
     getStyleFunction() {
       const style2 = this.style;
-      if (!style2) return null;
       if (typeof style2 === "function") return style2;
       return () => {
         return style2;
       };
     }
-    containsCoordinate(coordinate) {
-      if (!containsCoordinate(this.getExtent(), coordinate)) {
-        return false;
-      }
-      for (const geometries of this.geometries) {
-        if (d3Geo.geoContains(geometries.getGeoJSON(), coordinate)) {
-          return true;
+    renderFrame(frameState, targetElement) {
+      return this.renderer.renderFrame(frameState, targetElement);
+    }
+  }
+  class VectorLayerRenderer {
+    constructor(layer) {
+      this.layer = layer;
+      this.featureRenderer = new FeatureRenderer();
+    }
+    renderFrame(frameState, targetElement) {
+      if (this.layer.opacity === 0) return targetElement;
+      const { projection, sizeInPixels, visibleExtent, transform } = frameState.viewState;
+      const container2 = this.getOrCreateContainer(targetElement, sizeInPixels);
+      const context = container2.firstElementChild.getContext("2d");
+      context.save();
+      context.translate(transform.x, transform.y);
+      context.scale(transform.k, transform.k);
+      context.lineJoin = "round";
+      context.lineCap = "round";
+      context.globalAlpha = this.layer.opacity;
+      const source = this.layer.source;
+      const features = source.getFeaturesInExtent(visibleExtent);
+      for (const feature of features) {
+        const styleFunction2 = feature.getStyleFunction() || this.layer.getStyleFunction();
+        const featureStyle = styleFunction2(feature);
+        if ((featureStyle == null ? void 0 : featureStyle.stroke) || (featureStyle == null ? void 0 : featureStyle.fill)) {
+          context.save();
+          this.featureRenderer.setStyle(featureStyle);
+          this.featureRenderer.setFeature(feature);
+          this.featureRenderer.render(frameState, context);
+          context.restore();
         }
       }
-      return false;
-    }
-    clone() {
-      return new Feature({
-        id: this.id,
-        geometries: this.geometries.map((d2) => d2.clone()),
-        properties: this.properties,
-        style: this.style
-      });
-    }
-    /**
-     * Returns the geometries as a GeoJSON object
-     * @returns {Object} The GeoJSON representation of the geometries
-     */
-    getGeoJSON() {
-      const geometries = this.geometries.map((d2) => d2.getGeoJSON());
-      if (geometries.length === 1) return geometries[0];
-      return {
-        type: "Feature",
-        geometry: this._getGeometryGeoJSON(),
-        properties: this.properties
-      };
+      if (Object.prototype.hasOwnProperty.call(projection, "getCompositionBorders")) {
+        context.beginPath();
+        context.lineWidth = 1 / transform.k;
+        context.strokeStyle = "#999";
+        projection.drawCompositionBorders(context);
+        context.stroke();
+      }
+      context.restore();
+      return container2;
     }
-    _getGeometryGeoJSON() {
-      const geometries = this.geometries.map((d2) => d2.getGeoJSON());
-      if (geometries.length === 0) throw new Error("Feature has no geometries");
-      if (geometries.length === 1) return geometries[0];
-      if (geometries[0].type === "Polygon") {
-        return {
-          type: "MultiPolygon",
-          coordinates: geometries.map((d2) => d2.coordinates)
-        };
-      } else if (geometries[0].type === "LineString") {
-        return {
-          type: "MultiLineString",
-          coordinates: geometries.map((d2) => d2.coordinates)
-        };
-      } else if (geometries[0].type === "Point") {
-        return {
-          type: "MultiPoint",
-          coordinates: geometries.map((d2) => d2.coordinates)
-        };
+    getOrCreateContainer(targetElement, sizeInPixels) {
+      let container2 = null;
+      let containerReused = false;
+      let canvas = targetElement && targetElement.firstElementChild;
+      if (canvas instanceof HTMLCanvasElement) {
+        container2 = targetElement;
+        containerReused = true;
+      } else if (this._container) {
+        container2 = this._container;
+      } else {
+        container2 = this.createContainer();
       }
-      throw new Error("Could not determine geometry type");
+      if (!containerReused) {
+        const canvas2 = container2.firstElementChild;
+        canvas2.width = sizeInPixels[0];
+        canvas2.height = sizeInPixels[1];
+      }
+      this._container = container2;
+      return container2;
+    }
+    createContainer() {
+      const container2 = document.createElement("div");
+      container2.className = "gv-map-layer";
+      let style2 = container2.style;
+      style2.position = "absolute";
+      style2.width = "100%";
+      style2.height = "100%";
+      const canvas = document.createElement("canvas");
+      style2 = canvas.style;
+      style2.position = "absolute";
+      style2.width = "100%";
+      style2.height = "100%";
+      container2.appendChild(canvas);
+      return container2;
     }
   }
-  class Geometry {
-    /**
-     * Represents vector geometry
-     * @constructor
-     * @param {Object} options
-     * @param {string} options.type - The type of geometry (e.g., 'Point', 'LineString', 'Polygon')
-     * @param {Array} options.extent - The extent of the geometry (e.g., [xmin, ymin, xmax, ymax])
-     * @param {Array} options.coordinates - The coordinates of the geometry (e.g., [[x1, y1], [x2, y2], ...])
-     */
-    constructor({ type, extent, coordinates }) {
-      this.type = type;
-      this.extent = extent;
-      this.coordinates = coordinates;
-      this.getProjected = memoise(this._getProjected).bind(this);
+  class VectorLayer {
+    /** @param {VectorLayerComponentProps} props */
+    static Component({
+      features: featureCollection,
+      style: style2,
+      minZoom,
+      opacity,
+      hitDetectionEnabled = true
+    }) {
+      const { registerLayer } = hooks.useContext(MapContext);
+      const layer = hooks.useMemo(
+        () => {
+          const features = featureCollection instanceof FeatureCollection ? featureCollection.features : (
+            /** @type {import("../Feature").Feature[]} */
+            featureCollection
+          );
+          return VectorLayer.with(features, {
+            style: style2,
+            minZoom,
+            opacity,
+            hitDetectionEnabled
+          });
+        },
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        [featureCollection, minZoom, opacity, hitDetectionEnabled]
+      );
+      registerLayer(layer);
+      hooks.useEffect(() => {
+        layer.style = style2;
+      }, [style2]);
+      return null;
     }
     /**
-     * Returns the geometry as a GeoJSON object
-     * @function
-     * @param {import("../projection").Projection} projection - The projection to use for the geometry
-     * @returns {Object} A GeoJSON representation of the projected geometry
-     * @private
+     * @param {import("../Feature").Feature[]} features
+     * @param {VectorLayerOptions} options
      */
-    // eslint-disable-next-line no-unused-vars
-    _getProjected(projection) {
-      throw new Error("Not implemented");
+    static with(features, options) {
+      const source = new VectorSource({ features });
+      return new VectorLayer({ source, ...options });
     }
     /**
-     * Returns the geometry as a GeoJSON object
-     * @returns {Object} The GeoJSON representation of the geometry
+     * @param {Object} params
+     * @param {VectorSource} params.source
+     * @param {Style | (() => Style)} [params.style=undefined]
+     * @param {number} [params.minZoom=0]
+     * @param {number} [params.opacity=1]
+     * @param {boolean} [params.hitDetectionEnabled=true]
      */
-    getGeoJSON() {
-      return {
-        type: this.type,
-        coordinates: this.coordinates
-      };
+    constructor({
+      source,
+      style: style2,
+      minZoom = 0,
+      opacity = 1,
+      hitDetectionEnabled = true
+    }) {
+      this.dispatcher = new Dispatcher(this);
+      this.renderer = new VectorLayerRenderer(this);
+      this.source = source;
+      this._style = style2;
+      this.minZoom = minZoom;
+      this.opacity = opacity;
+      this.hitDetectionEnabled = hitDetectionEnabled;
     }
-  }
-  class LineString extends Geometry {
-    constructor({ type = "LineString", extent, coordinates }) {
-      super({ type, extent, coordinates });
+    get source() {
+      return this._source;
     }
-    _getProjected(projection) {
-      const projected = [];
-      for (const point of this.coordinates) {
-        projected.push(projection(point));
+    set source(source) {
+      if (this._source && source !== this._source) {
+        this._source.tearDown();
       }
-      return {
-        type: this.type,
-        coordinates: projected
-      };
+      this._source = source;
+      source.on(MapEvent.CHANGE, () => {
+        this._extent = null;
+        this.dispatcher.dispatch(MapEvent.CHANGE);
+      });
     }
-  }
-  class Polygon extends Geometry {
-    constructor({ type = "Polygon", extent, coordinates }) {
-      super({ type, extent, coordinates });
+    setRawProjection(projection) {
+      this.projection = projection;
     }
-    _getProjected(projection) {
-      const projected = [];
-      const rings = this.coordinates;
-      for (const ring of rings) {
-        const projectedRing = [];
-        for (const point of ring) {
-          const projectedPoint = projection(point);
-          if (projectedPoint) {
-            projectedRing.push(projectedPoint);
-          } else {
-            break;
-          }
-        }
-        if (projectedRing.length > 0) {
-          projected.push(projectedRing);
-        }
-      }
-      return {
-        type: this.type,
-        coordinates: projected
+    tearDown() {
+      this.dispatcher = null;
+    }
+    get style() {
+      if (this._style) return this._style;
+      const defaultStyle = new Style({
+        stroke: new Stroke()
+      });
+      return defaultStyle;
+    }
+    set style(style2) {
+      this._style = style2;
+      this.dispatcher.dispatch(MapEvent.CHANGE);
+    }
+    getStyleFunction() {
+      const style2 = this.style;
+      if (typeof style2 === "function") return style2;
+      return () => {
+        return style2;
       };
     }
-    getOuterRing() {
-      return this.coordinates[0];
-    }
-    setOuterRing(coordinates) {
-      this.coordinates[0] = coordinates;
+    getExtent() {
+      if (this._extent) return this._extent;
+      const features = this.source.getFeatures();
+      const extent = features.reduce((combinedExtent, feature) => {
+        const featureExtent = feature.getExtent();
+        if (!combinedExtent) return featureExtent;
+        return combineExtents(featureExtent, combinedExtent);
+      }, null);
+      this._extent = extent;
+      return extent;
     }
-    setCoordinates(coordinates) {
-      this.coordinates = coordinates;
+    findFeatures(coordinate) {
+      if (!this.hitDetectionEnabled) return;
+      return this.source.getFeaturesAtCoordinate(coordinate);
     }
-    clone() {
-      return new Polygon({
-        extent: this.extent,
-        coordinates: JSON.parse(JSON.stringify(this.coordinates))
-      });
+    renderFrame(frameState, targetElement) {
+      return this.renderer.renderFrame(frameState, targetElement);
     }
   }
-  class Point extends Geometry {
-    constructor({ type = "Point", coordinates }) {
-      super({ type, extent: null, coordinates });
-      this.extent = [...coordinates, ...coordinates];
-    }
-    _getProjected(projection) {
-      return {
-        type: this.type,
-        coordinates: projection(this.coordinates)
-      };
+  function interpolateFeatures(currentFeatures, newFeatures, { interpolate: interpolate2, separate, combine }) {
+    if (currentFeatures.length !== newFeatures.length) {
+      throw new Error(
+        "interpolateFeatures expects an equal number of features for start and end"
+      );
     }
-  }
-  class GeoJSON {
-    readFeaturesFromObject(object) {
-      const geoJSONObject = object;
-      let features = null;
-      if (geoJSONObject["type"] === "FeatureCollection") {
-        const geoJSONFeatureCollection = object;
-        features = [];
-        const geoJSONFeatures = geoJSONFeatureCollection["features"];
-        for (let i = 0, ii = geoJSONFeatures.length; i < ii; ++i) {
-          const featureObject = this.readFeatureFromObject(geoJSONFeatures[i]);
-          if (!featureObject) {
-            continue;
-          }
-          features.push(featureObject);
-        }
-      } else if (geoJSONObject["type"] === "Feature") {
-        features = [this.readFeatureFromObject(geoJSONObject)];
-      } else if (Array.isArray(geoJSONObject)) {
-        features = [];
-        for (let i = 0, ii = geoJSONObject.length; i < ii; ++i) {
-          const featureObject = this.readFeatureFromObject(geoJSONObject[i]);
-          if (!featureObject) {
-            continue;
+    const featureInterpolators = [];
+    for (let i = 0; i < currentFeatures.length; i++) {
+      const geometryInterpolators = [];
+      const currentGeometries = currentFeatures[i].geometries;
+      const newGeometries = newFeatures[i].geometries;
+      if (newGeometries.length === currentGeometries.length) {
+        for (let e = 0; e < currentGeometries.length; e++) {
+          const currentGeometry = currentGeometries[e];
+          const newGeometry = newGeometries[e];
+          if (currentGeometry.type !== "Polygon" || newGeometry.type !== "Polygon") {
+            throw new Error("interpolateFeatures expects only Polygon geometry");
           }
-          features.push(featureObject);
+          const shapeInterpolator = interpolate2(
+            currentGeometries[e].getOuterRing(),
+            newGeometries[e].getOuterRing(),
+            { string: false }
+          );
+          geometryInterpolators.push({
+            type: "default",
+            interpolator: shapeInterpolator
+          });
         }
+      } else if (currentGeometries.length === 1 && newGeometries.length > 1) {
+        const separationInterpolator = separate(
+          currentGeometries[0].getOuterRing(),
+          newGeometries.map((geometry) => geometry.getOuterRing()),
+          { string: false, single: true }
+        );
+        geometryInterpolators.push({
+          type: "separate",
+          interpolator: separationInterpolator
+        });
+      } else if (currentGeometries.length > 1 && newGeometries.length === 1) {
+        const combinationInterpolator = combine(
+          currentGeometries.map((geometry) => geometry.getOuterRing()),
+          newGeometries[0].getOuterRing(),
+          { string: false, single: true }
+        );
+        geometryInterpolators.push({
+          type: "combine",
+          interpolator: combinationInterpolator
+        });
       } else {
-        try {
-          const geometries = this.readGeometriesFromObject(geoJSONObject);
-          const feature = new Feature({ geometries });
-          features = [feature];
-        } catch {
-          console.warn("Unable to interpret GeoJSON:", geoJSONObject);
-          return;
-        }
+        throw new Error(
+          `Encountered an unexpected number of geometries: ${currentGeometries.length} and ${newGeometries.length}`
+        );
       }
-      return features.flat();
+      featureInterpolators.push(geometryInterpolators);
     }
-    readFeatureFromObject(geoJSONObject) {
-      const geometries = this.readGeometriesFromObject(geoJSONObject["geometry"]);
-      if (geometries.length > 0) {
-        return new Feature({
-          id: geoJSONObject["id"],
-          geometries,
-          properties: geoJSONObject["properties"]
-        });
+    return (t) => {
+      if (t >= 1) {
+        return newFeatures;
       }
-      return null;
-    }
-    readGeometriesFromObject(geometry) {
-      const geometries = [];
-      if (geometry.type === "Polygon") {
-        const polygon = this.readPolygonForCoordinates(geometry.coordinates);
-        geometries.push(polygon);
-      } else if (geometry.type === "MultiPolygon") {
-        for (const polygonCoordinates of geometry.coordinates) {
-          const polygon = this.readPolygonForCoordinates(polygonCoordinates);
-          geometries.push(polygon);
-        }
-      } else if (geometry.type === "LineString") {
-        const lineString = this.readLineStringForCoordinates(geometry.coordinates);
-        geometries.push(lineString);
-      } else if (geometry.type === "MultiLineString") {
-        for (const lineStringCoordinates of geometry.coordinates) {
-          const lineString = this.readLineStringForCoordinates(
-            lineStringCoordinates
-          );
-          geometries.push(lineString);
+      const features = [];
+      for (let i = 0; i < featureInterpolators.length; i++) {
+        const feature = newFeatures[i].clone();
+        const geometries = [];
+        const geometryInterpolators = featureInterpolators[i];
+        for (const [
+          index,
+          { type, interpolator }
+        ] of geometryInterpolators.entries()) {
+          let geometry = feature.geometries[index].clone();
+          let interpolated;
+          switch (type) {
+            case "separate":
+            case "combine":
+              interpolated = interpolator(t);
+              interpolated.forEach((d2) => {
+                const polygon = geometry.clone();
+                polygon.setCoordinates([d2]);
+                geometries.push(polygon);
+              });
+              break;
+            default:
+              geometry.setOuterRing(interpolator(t));
+              geometries.push(geometry);
+              break;
+          }
         }
-      } else if (geometry.type === "Point") {
-        const point = this.readPointForCoordinates(geometry.coordinates);
-        geometries.push(point);
+        feature.setGeometry(geometries);
+        features.push(feature);
       }
-      return geometries;
-    }
-    readPolygonForCoordinates(coordinates) {
-      const outerRing = coordinates[0];
-      const extent = extentForCoordinates(outerRing);
-      return new Polygon({ extent, coordinates });
-    }
-    readLineStringForCoordinates(coordinates) {
-      const extent = extentForCoordinates(coordinates);
-      return new LineString({ extent, coordinates });
-    }
-    readPointForCoordinates(coordinates) {
-      return new Point({ coordinates });
-    }
+      return features;
+    };
+  }
+  function interpolateStyles(firstStyle, secondStyle, interpolateColors, interpolateNumbers) {
+    const fillInterpolator = interpolateFill(
+      firstStyle.fill,
+      secondStyle.fill,
+      interpolateColors,
+      interpolateNumbers
+    );
+    const strokeInterpolator = interpolateStroke(
+      firstStyle.stroke,
+      secondStyle.stroke,
+      interpolateColors,
+      interpolateNumbers
+    );
+    return (t) => {
+      return new Style({
+        fill: fillInterpolator(t),
+        stroke: strokeInterpolator(t)
+      });
+    };
+  }
+  function interpolateFill(fillA, fillB, interpolateColors, interpolateNumbers) {
+    const colorInterpolator = interpolateColors(
+      (fillA == null ? void 0 : fillA.color) ?? "transparent",
+      (fillB == null ? void 0 : fillB.color) ?? "transparent"
+    );
+    const opacityInterpolator = interpolateNumbers(
+      (fillA == null ? void 0 : fillA.opacity) ?? 1,
+      (fillB == null ? void 0 : fillB.opacity) ?? 1
+    );
+    return (t) => {
+      return new Fill({
+        color: colorInterpolator(t),
+        opacity: opacityInterpolator(t)
+      });
+    };
+  }
+  function interpolateStroke(strokeA, strokeB, interpolateColors, interpolateNumbers) {
+    const colorInterpolator = interpolateColors(
+      (strokeA == null ? void 0 : strokeA.color) ?? "transparent",
+      (strokeB == null ? void 0 : strokeB.color) ?? "transparent"
+    );
+    const opacityInterpolator = interpolateNumbers(
+      (strokeA == null ? void 0 : strokeA.opacity) ?? 1,
+      (strokeB == null ? void 0 : strokeB.opacity) ?? 1
+    );
+    const widthInterpolator = interpolateNumbers(
+      (strokeA == null ? void 0 : strokeA.width) ?? 1,
+      (strokeB == null ? void 0 : strokeB.width) ?? 1
+    );
+    return (t) => {
+      return new Stroke({
+        color: colorInterpolator(t),
+        opacity: opacityInterpolator(t),
+        width: widthInterpolator(t)
+      });
+    };
   }
   function useWindowSize() {
     const [windowSize, setWindowSize] = hooks.useState(() => {
@@ -7725,6 +7930,8 @@
   exports2.ControlChange = ControlChange;
   exports2.Dispatcher = Dispatcher;
   exports2.Dropdown = Dropdown;
+  exports2.Feature = Feature;
+  exports2.FeatureCollection = FeatureCollection;
   exports2.Fill = Fill;
   exports2.FirstPastThePostWaffle = FirstPastThePostWaffle;
   exports2.GeoJSON = GeoJSON;
@@ -7755,6 +7962,7 @@
   exports2.StackedBar = StackedBar;
   exports2.StackedGrid = StackedGrid;
   exports2.Stroke = Stroke;
+  exports2.StrokePosition = StrokePosition;
   exports2.Style = Style;
   exports2.Table = Table;
   exports2.Text = Text;