@nasa-terra/components 0.0.178 → 0.0.179

package/cdn/chunks/chunk.RCPXD7AS.js

@@ -0,0 +1,3155 @@
+import {
+  __publicField,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// node_modules/ol/extent.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/ol/extent/Relationship.js
+init_dirname();
+init_buffer();
+init_process();
+var Relationship_default = {
+  UNKNOWN: 0,
+  INTERSECTING: 1,
+  ABOVE: 2,
+  RIGHT: 4,
+  BELOW: 8,
+  LEFT: 16
+};
+
+// node_modules/ol/extent.js
+function boundingExtent(coordinates) {
+  const extent = createEmpty();
+  for (let i = 0, ii = coordinates.length; i < ii; ++i) {
+    extendCoordinate(extent, coordinates[i]);
+  }
+  return extent;
+}
+function _boundingExtentXYs(xs, ys, dest) {
+  const minX = Math.min.apply(null, xs);
+  const minY = Math.min.apply(null, ys);
+  const maxX = Math.max.apply(null, xs);
+  const maxY = Math.max.apply(null, ys);
+  return createOrUpdate(minX, minY, maxX, maxY, dest);
+}
+function buffer(extent, value, dest) {
+  if (dest) {
+    dest[0] = extent[0] - value;
+    dest[1] = extent[1] - value;
+    dest[2] = extent[2] + value;
+    dest[3] = extent[3] + value;
+    return dest;
+  }
+  return [
+    extent[0] - value,
+    extent[1] - value,
+    extent[2] + value,
+    extent[3] + value
+  ];
+}
+function clone(extent, dest) {
+  if (dest) {
+    dest[0] = extent[0];
+    dest[1] = extent[1];
+    dest[2] = extent[2];
+    dest[3] = extent[3];
+    return dest;
+  }
+  return extent.slice();
+}
+function closestSquaredDistanceXY(extent, x, y) {
+  let dx, dy;
+  if (x < extent[0]) {
+    dx = extent[0] - x;
+  } else if (extent[2] < x) {
+    dx = x - extent[2];
+  } else {
+    dx = 0;
+  }
+  if (y < extent[1]) {
+    dy = extent[1] - y;
+  } else if (extent[3] < y) {
+    dy = y - extent[3];
+  } else {
+    dy = 0;
+  }
+  return dx * dx + dy * dy;
+}
+function containsCoordinate(extent, coordinate) {
+  return containsXY(extent, coordinate[0], coordinate[1]);
+}
+function containsExtent(extent1, extent2) {
+  return extent1[0] <= extent2[0] && extent2[2] <= extent1[2] && extent1[1] <= extent2[1] && extent2[3] <= extent1[3];
+}
+function containsXY(extent, x, y) {
+  return extent[0] <= x && x <= extent[2] && extent[1] <= y && y <= extent[3];
+}
+function coordinateRelationship(extent, coordinate) {
+  const minX = extent[0];
+  const minY = extent[1];
+  const maxX = extent[2];
+  const maxY = extent[3];
+  const x = coordinate[0];
+  const y = coordinate[1];
+  let relationship = Relationship_default.UNKNOWN;
+  if (x < minX) {
+    relationship = relationship | Relationship_default.LEFT;
+  } else if (x > maxX) {
+    relationship = relationship | Relationship_default.RIGHT;
+  }
+  if (y < minY) {
+    relationship = relationship | Relationship_default.BELOW;
+  } else if (y > maxY) {
+    relationship = relationship | Relationship_default.ABOVE;
+  }
+  if (relationship === Relationship_default.UNKNOWN) {
+    relationship = Relationship_default.INTERSECTING;
+  }
+  return relationship;
+}
+function createEmpty() {
+  return [Infinity, Infinity, -Infinity, -Infinity];
+}
+function createOrUpdate(minX, minY, maxX, maxY, dest) {
+  if (dest) {
+    dest[0] = minX;
+    dest[1] = minY;
+    dest[2] = maxX;
+    dest[3] = maxY;
+    return dest;
+  }
+  return [minX, minY, maxX, maxY];
+}
+function createOrUpdateEmpty(dest) {
+  return createOrUpdate(Infinity, Infinity, -Infinity, -Infinity, dest);
+}
+function createOrUpdateFromCoordinate(coordinate, dest) {
+  const x = coordinate[0];
+  const y = coordinate[1];
+  return createOrUpdate(x, y, x, y, dest);
+}
+function createOrUpdateFromFlatCoordinates(flatCoordinates, offset, end, stride, dest) {
+  const extent = createOrUpdateEmpty(dest);
+  return extendFlatCoordinates(extent, flatCoordinates, offset, end, stride);
+}
+function equals(extent1, extent2) {
+  return extent1[0] == extent2[0] && extent1[2] == extent2[2] && extent1[1] == extent2[1] && extent1[3] == extent2[3];
+}
+function approximatelyEquals(extent1, extent2, tolerance) {
+  return Math.abs(extent1[0] - extent2[0]) < tolerance && Math.abs(extent1[2] - extent2[2]) < tolerance && Math.abs(extent1[1] - extent2[1]) < tolerance && Math.abs(extent1[3] - extent2[3]) < tolerance;
+}
+function extend(extent1, extent2) {
+  if (extent2[0] < extent1[0]) {
+    extent1[0] = extent2[0];
+  }
+  if (extent2[2] > extent1[2]) {
+    extent1[2] = extent2[2];
+  }
+  if (extent2[1] < extent1[1]) {
+    extent1[1] = extent2[1];
+  }
+  if (extent2[3] > extent1[3]) {
+    extent1[3] = extent2[3];
+  }
+  return extent1;
+}
+function extendCoordinate(extent, coordinate) {
+  if (coordinate[0] < extent[0]) {
+    extent[0] = coordinate[0];
+  }
+  if (coordinate[0] > extent[2]) {
+    extent[2] = coordinate[0];
+  }
+  if (coordinate[1] < extent[1]) {
+    extent[1] = coordinate[1];
+  }
+  if (coordinate[1] > extent[3]) {
+    extent[3] = coordinate[1];
+  }
+}
+function extendFlatCoordinates(extent, flatCoordinates, offset, end, stride) {
+  for (; offset < end; offset += stride) {
+    extendXY(extent, flatCoordinates[offset], flatCoordinates[offset + 1]);
+  }
+  return extent;
+}
+function extendXY(extent, x, y) {
+  extent[0] = Math.min(extent[0], x);
+  extent[1] = Math.min(extent[1], y);
+  extent[2] = Math.max(extent[2], x);
+  extent[3] = Math.max(extent[3], y);
+}
+function forEachCorner(extent, callback) {
+  let val;
+  val = callback(getBottomLeft(extent));
+  if (val) {
+    return val;
+  }
+  val = callback(getBottomRight(extent));
+  if (val) {
+    return val;
+  }
+  val = callback(getTopRight(extent));
+  if (val) {
+    return val;
+  }
+  val = callback(getTopLeft(extent));
+  if (val) {
+    return val;
+  }
+  return false;
+}
+function getArea(extent) {
+  let area = 0;
+  if (!isEmpty(extent)) {
+    area = getWidth(extent) * getHeight(extent);
+  }
+  return area;
+}
+function getBottomLeft(extent) {
+  return [extent[0], extent[1]];
+}
+function getBottomRight(extent) {
+  return [extent[2], extent[1]];
+}
+function getCenter(extent) {
+  return [(extent[0] + extent[2]) / 2, (extent[1] + extent[3]) / 2];
+}
+function getCorner(extent, corner) {
+  let coordinate;
+  if (corner === "bottom-left") {
+    coordinate = getBottomLeft(extent);
+  } else if (corner === "bottom-right") {
+    coordinate = getBottomRight(extent);
+  } else if (corner === "top-left") {
+    coordinate = getTopLeft(extent);
+  } else if (corner === "top-right") {
+    coordinate = getTopRight(extent);
+  } else {
+    throw new Error("Invalid corner");
+  }
+  return coordinate;
+}
+function getForViewAndSize(center, resolution, rotation, size, dest) {
+  const [x0, y0, x1, y1, x2, y2, x3, y3] = getRotatedViewport(
+    center,
+    resolution,
+    rotation,
+    size
+  );
+  return createOrUpdate(
+    Math.min(x0, x1, x2, x3),
+    Math.min(y0, y1, y2, y3),
+    Math.max(x0, x1, x2, x3),
+    Math.max(y0, y1, y2, y3),
+    dest
+  );
+}
+function getRotatedViewport(center, resolution, rotation, size) {
+  const dx = resolution * size[0] / 2;
+  const dy = resolution * size[1] / 2;
+  const cosRotation = Math.cos(rotation);
+  const sinRotation = Math.sin(rotation);
+  const xCos = dx * cosRotation;
+  const xSin = dx * sinRotation;
+  const yCos = dy * cosRotation;
+  const ySin = dy * sinRotation;
+  const x = center[0];
+  const y = center[1];
+  return [
+    x - xCos + ySin,
+    y - xSin - yCos,
+    x - xCos - ySin,
+    y - xSin + yCos,
+    x + xCos - ySin,
+    y + xSin + yCos,
+    x + xCos + ySin,
+    y + xSin - yCos,
+    x - xCos + ySin,
+    y - xSin - yCos
+  ];
+}
+function getHeight(extent) {
+  return extent[3] - extent[1];
+}
+function getIntersection(extent1, extent2, dest) {
+  const intersection = dest ? dest : createEmpty();
+  if (intersects(extent1, extent2)) {
+    if (extent1[0] > extent2[0]) {
+      intersection[0] = extent1[0];
+    } else {
+      intersection[0] = extent2[0];
+    }
+    if (extent1[1] > extent2[1]) {
+      intersection[1] = extent1[1];
+    } else {
+      intersection[1] = extent2[1];
+    }
+    if (extent1[2] < extent2[2]) {
+      intersection[2] = extent1[2];
+    } else {
+      intersection[2] = extent2[2];
+    }
+    if (extent1[3] < extent2[3]) {
+      intersection[3] = extent1[3];
+    } else {
+      intersection[3] = extent2[3];
+    }
+  } else {
+    createOrUpdateEmpty(intersection);
+  }
+  return intersection;
+}
+function getTopLeft(extent) {
+  return [extent[0], extent[3]];
+}
+function getTopRight(extent) {
+  return [extent[2], extent[3]];
+}
+function getWidth(extent) {
+  return extent[2] - extent[0];
+}
+function intersects(extent1, extent2) {
+  return extent1[0] <= extent2[2] && extent1[2] >= extent2[0] && extent1[1] <= extent2[3] && extent1[3] >= extent2[1];
+}
+function isEmpty(extent) {
+  return extent[2] < extent[0] || extent[3] < extent[1];
+}
+function returnOrUpdate(extent, dest) {
+  if (dest) {
+    dest[0] = extent[0];
+    dest[1] = extent[1];
+    dest[2] = extent[2];
+    dest[3] = extent[3];
+    return dest;
+  }
+  return extent;
+}
+function intersectsSegment(extent, start, end) {
+  let intersects2 = false;
+  const startRel = coordinateRelationship(extent, start);
+  const endRel = coordinateRelationship(extent, end);
+  if (startRel === Relationship_default.INTERSECTING || endRel === Relationship_default.INTERSECTING) {
+    intersects2 = true;
+  } else {
+    const minX = extent[0];
+    const minY = extent[1];
+    const maxX = extent[2];
+    const maxY = extent[3];
+    const startX = start[0];
+    const startY = start[1];
+    const endX = end[0];
+    const endY = end[1];
+    const slope = (endY - startY) / (endX - startX);
+    let x, y;
+    if (!!(endRel & Relationship_default.ABOVE) && !(startRel & Relationship_default.ABOVE)) {
+      x = endX - (endY - maxY) / slope;
+      intersects2 = x >= minX && x <= maxX;
+    }
+    if (!intersects2 && !!(endRel & Relationship_default.RIGHT) && !(startRel & Relationship_default.RIGHT)) {
+      y = endY - (endX - maxX) * slope;
+      intersects2 = y >= minY && y <= maxY;
+    }
+    if (!intersects2 && !!(endRel & Relationship_default.BELOW) && !(startRel & Relationship_default.BELOW)) {
+      x = endX - (endY - minY) / slope;
+      intersects2 = x >= minX && x <= maxX;
+    }
+    if (!intersects2 && !!(endRel & Relationship_default.LEFT) && !(startRel & Relationship_default.LEFT)) {
+      y = endY - (endX - minX) * slope;
+      intersects2 = y >= minY && y <= maxY;
+    }
+  }
+  return intersects2;
+}
+function applyTransform(extent, transformFn, dest, stops) {
+  if (isEmpty(extent)) {
+    return createOrUpdateEmpty(dest);
+  }
+  let coordinates = [];
+  if (stops > 1) {
+    const width = extent[2] - extent[0];
+    const height = extent[3] - extent[1];
+    for (let i = 0; i < stops; ++i) {
+      coordinates.push(
+        extent[0] + width * i / stops,
+        extent[1],
+        extent[2],
+        extent[1] + height * i / stops,
+        extent[2] - width * i / stops,
+        extent[3],
+        extent[0],
+        extent[3] - height * i / stops
+      );
+    }
+  } else {
+    coordinates = [
+      extent[0],
+      extent[1],
+      extent[2],
+      extent[1],
+      extent[2],
+      extent[3],
+      extent[0],
+      extent[3]
+    ];
+  }
+  transformFn(coordinates, coordinates, 2);
+  const xs = [];
+  const ys = [];
+  for (let i = 0, l = coordinates.length; i < l; i += 2) {
+    xs.push(coordinates[i]);
+    ys.push(coordinates[i + 1]);
+  }
+  return _boundingExtentXYs(xs, ys, dest);
+}
+function wrapX(extent, projection) {
+  const projectionExtent = projection.getExtent();
+  const center = getCenter(extent);
+  if (projection.canWrapX() && (center[0] < projectionExtent[0] || center[0] >= projectionExtent[2])) {
+    const worldWidth = getWidth(projectionExtent);
+    const worldsAway = Math.floor(
+      (center[0] - projectionExtent[0]) / worldWidth
+    );
+    const offset = worldsAway * worldWidth;
+    extent[0] -= offset;
+    extent[2] -= offset;
+  }
+  return extent;
+}
+function wrapAndSliceX(extent, projection, multiWorld) {
+  if (projection.canWrapX()) {
+    const projectionExtent = projection.getExtent();
+    if (!isFinite(extent[0]) || !isFinite(extent[2])) {
+      return [[projectionExtent[0], extent[1], projectionExtent[2], extent[3]]];
+    }
+    wrapX(extent, projection);
+    const worldWidth = getWidth(projectionExtent);
+    if (getWidth(extent) > worldWidth && !multiWorld) {
+      return [[projectionExtent[0], extent[1], projectionExtent[2], extent[3]]];
+    }
+    if (extent[0] < projectionExtent[0]) {
+      return [
+        [extent[0] + worldWidth, extent[1], projectionExtent[2], extent[3]],
+        [projectionExtent[0], extent[1], extent[2], extent[3]]
+      ];
+    }
+    if (extent[2] > projectionExtent[2]) {
+      return [
+        [extent[0], extent[1], projectionExtent[2], extent[3]],
+        [projectionExtent[0], extent[1], extent[2] - worldWidth, extent[3]]
+      ];
+    }
+  }
+  return [extent];
+}
+
+// node_modules/ol/math.js
+init_dirname();
+init_buffer();
+init_process();
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function squaredSegmentDistance(x, y, x1, y1, x2, y2) {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  if (dx !== 0 || dy !== 0) {
+    const t = ((x - x1) * dx + (y - y1) * dy) / (dx * dx + dy * dy);
+    if (t > 1) {
+      x1 = x2;
+      y1 = y2;
+    } else if (t > 0) {
+      x1 += dx * t;
+      y1 += dy * t;
+    }
+  }
+  return squaredDistance(x, y, x1, y1);
+}
+function squaredDistance(x1, y1, x2, y2) {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  return dx * dx + dy * dy;
+}
+function solveLinearSystem(mat) {
+  const n = mat.length;
+  for (let i = 0; i < n; i++) {
+    let maxRow = i;
+    let maxEl = Math.abs(mat[i][i]);
+    for (let r = i + 1; r < n; r++) {
+      const absValue = Math.abs(mat[r][i]);
+      if (absValue > maxEl) {
+        maxEl = absValue;
+        maxRow = r;
+      }
+    }
+    if (maxEl === 0) {
+      return null;
+    }
+    const tmp = mat[maxRow];
+    mat[maxRow] = mat[i];
+    mat[i] = tmp;
+    for (let j = i + 1; j < n; j++) {
+      const coef = -mat[j][i] / mat[i][i];
+      for (let k = i; k < n + 1; k++) {
+        if (i == k) {
+          mat[j][k] = 0;
+        } else {
+          mat[j][k] += coef * mat[i][k];
+        }
+      }
+    }
+  }
+  const x = new Array(n);
+  for (let l = n - 1; l >= 0; l--) {
+    x[l] = mat[l][n] / mat[l][l];
+    for (let m = l - 1; m >= 0; m--) {
+      mat[m][n] -= mat[m][l] * x[l];
+    }
+  }
+  return x;
+}
+function toDegrees(angleInRadians) {
+  return angleInRadians * 180 / Math.PI;
+}
+function toRadians(angleInDegrees) {
+  return angleInDegrees * Math.PI / 180;
+}
+function modulo(a, b) {
+  const r = a % b;
+  return r * b < 0 ? r + b : r;
+}
+function lerp(a, b, x) {
+  return a + x * (b - a);
+}
+function toFixed(n, decimals) {
+  const factor = Math.pow(10, decimals);
+  return Math.round(n * factor) / factor;
+}
+function floor(n, decimals) {
+  return Math.floor(toFixed(n, decimals));
+}
+function ceil(n, decimals) {
+  return Math.ceil(toFixed(n, decimals));
+}
+function wrap(n, min, max) {
+  if (n >= min && n < max) {
+    return n;
+  }
+  const range = max - min;
+  return ((n - min) % range + range) % range + min;
+}
+
+// node_modules/ol/sphere.js
+init_dirname();
+init_buffer();
+init_process();
+var DEFAULT_RADIUS = 63710088e-1;
+function getDistance(c1, c2, radius) {
+  radius = radius || DEFAULT_RADIUS;
+  const lat1 = toRadians(c1[1]);
+  const lat2 = toRadians(c2[1]);
+  const deltaLatBy2 = (lat2 - lat1) / 2;
+  const deltaLonBy2 = toRadians(c2[0] - c1[0]) / 2;
+  const a = Math.sin(deltaLatBy2) * Math.sin(deltaLatBy2) + Math.sin(deltaLonBy2) * Math.sin(deltaLonBy2) * Math.cos(lat1) * Math.cos(lat2);
+  return 2 * radius * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+}
+function getLengthInternal(coordinates, radius) {
+  let length = 0;
+  for (let i = 0, ii = coordinates.length; i < ii - 1; ++i) {
+    length += getDistance(coordinates[i], coordinates[i + 1], radius);
+  }
+  return length;
+}
+function getLength(geometry, options) {
+  options = options || {};
+  const radius = options.radius || DEFAULT_RADIUS;
+  const projection = options.projection || "EPSG:3857";
+  const type = geometry.getType();
+  if (type !== "GeometryCollection") {
+    geometry = geometry.clone().transform(projection, "EPSG:4326");
+  }
+  let length = 0;
+  let coordinates, coords, i, ii, j, jj;
+  switch (type) {
+    case "Point":
+    case "MultiPoint": {
+      break;
+    }
+    case "LineString":
+    case "LinearRing": {
+      coordinates = /** @type {import("./geom/SimpleGeometry.js").default} */
+      geometry.getCoordinates();
+      length = getLengthInternal(coordinates, radius);
+      break;
+    }
+    case "MultiLineString":
+    case "Polygon": {
+      coordinates = /** @type {import("./geom/SimpleGeometry.js").default} */
+      geometry.getCoordinates();
+      for (i = 0, ii = coordinates.length; i < ii; ++i) {
+        length += getLengthInternal(coordinates[i], radius);
+      }
+      break;
+    }
+    case "MultiPolygon": {
+      coordinates = /** @type {import("./geom/SimpleGeometry.js").default} */
+      geometry.getCoordinates();
+      for (i = 0, ii = coordinates.length; i < ii; ++i) {
+        coords = coordinates[i];
+        for (j = 0, jj = coords.length; j < jj; ++j) {
+          length += getLengthInternal(coords[j], radius);
+        }
+      }
+      break;
+    }
+    case "GeometryCollection": {
+      const geometries = (
+        /** @type {import("./geom/GeometryCollection.js").default} */
+        geometry.getGeometries()
+      );
+      for (i = 0, ii = geometries.length; i < ii; ++i) {
+        length += getLength(geometries[i], options);
+      }
+      break;
+    }
+    default: {
+      throw new Error("Unsupported geometry type: " + type);
+    }
+  }
+  return length;
+}
+
+// node_modules/ol/console.js
+init_dirname();
+init_buffer();
+init_process();
+var levels = {
+  info: 1,
+  warn: 2,
+  error: 3,
+  none: 4
+};
+var level = levels.info;
+function warn(...args) {
+  if (level > levels.warn) {
+    return;
+  }
+  console.warn(...args);
+}
+function error(...args) {
+  if (level > levels.error) {
+    return;
+  }
+  console.error(...args);
+}
+
+// node_modules/ol/proj/Units.js
+init_dirname();
+init_buffer();
+init_process();
+var unitByCode = {
+  "9001": "m",
+  "9002": "ft",
+  "9003": "us-ft",
+  "9101": "radians",
+  "9102": "degrees"
+};
+function fromCode(code) {
+  return unitByCode[code];
+}
+var METERS_PER_UNIT = {
+  // use the radius of the Normal sphere
+  "radians": 6370997 / (2 * Math.PI),
+  "degrees": 2 * Math.PI * 6370997 / 360,
+  "ft": 0.3048,
+  "m": 1,
+  "us-ft": 1200 / 3937
+};
+
+// node_modules/ol/proj/Projection.js
+init_dirname();
+init_buffer();
+init_process();
+var Projection = class {
+  /**
+   * @param {Options} options Projection options.
+   */
+  constructor(options) {
+    this.code_ = options.code;
+    this.units_ = /** @type {import("./Units.js").Units} */
+    options.units;
+    this.extent_ = options.extent !== void 0 ? options.extent : null;
+    this.worldExtent_ = options.worldExtent !== void 0 ? options.worldExtent : null;
+    this.axisOrientation_ = options.axisOrientation !== void 0 ? options.axisOrientation : "enu";
+    this.global_ = options.global !== void 0 ? options.global : false;
+    this.canWrapX_ = !!(this.global_ && this.extent_);
+    this.getPointResolutionFunc_ = options.getPointResolution;
+    this.defaultTileGrid_ = null;
+    this.metersPerUnit_ = options.metersPerUnit;
+  }
+  /**
+   * @return {boolean} The projection is suitable for wrapping the x-axis
+   */
+  canWrapX() {
+    return this.canWrapX_;
+  }
+  /**
+   * Get the code for this projection, e.g. 'EPSG:4326'.
+   * @return {string} Code.
+   * @api
+   */
+  getCode() {
+    return this.code_;
+  }
+  /**
+   * Get the validity extent for this projection.
+   * @return {import("../extent.js").Extent} Extent.
+   * @api
+   */
+  getExtent() {
+    return this.extent_;
+  }
+  /**
+   * Get the units of this projection.
+   * @return {import("./Units.js").Units} Units.
+   * @api
+   */
+  getUnits() {
+    return this.units_;
+  }
+  /**
+   * Get the amount of meters per unit of this projection.  If the projection is
+   * not configured with `metersPerUnit` or a units identifier, the return is
+   * `undefined`.
+   * @return {number|undefined} Meters.
+   * @api
+   */
+  getMetersPerUnit() {
+    return this.metersPerUnit_ || METERS_PER_UNIT[this.units_];
+  }
+  /**
+   * Get the world extent for this projection.
+   * @return {import("../extent.js").Extent} Extent.
+   * @api
+   */
+  getWorldExtent() {
+    return this.worldExtent_;
+  }
+  /**
+   * Get the axis orientation of this projection.
+   * Example values are:
+   * enu - the default easting, northing, elevation.
+   * neu - northing, easting, up - useful for "lat/long" geographic coordinates,
+   *     or south orientated transverse mercator.
+   * wnu - westing, northing, up - some planetary coordinate systems have
+   *     "west positive" coordinate systems
+   * @return {string} Axis orientation.
+   * @api
+   */
+  getAxisOrientation() {
+    return this.axisOrientation_;
+  }
+  /**
+   * Is this projection a global projection which spans the whole world?
+   * @return {boolean} Whether the projection is global.
+   * @api
+   */
+  isGlobal() {
+    return this.global_;
+  }
+  /**
+   * Set if the projection is a global projection which spans the whole world
+   * @param {boolean} global Whether the projection is global.
+   * @api
+   */
+  setGlobal(global) {
+    this.global_ = global;
+    this.canWrapX_ = !!(global && this.extent_);
+  }
+  /**
+   * @return {import("../tilegrid/TileGrid.js").default} The default tile grid.
+   */
+  getDefaultTileGrid() {
+    return this.defaultTileGrid_;
+  }
+  /**
+   * @param {import("../tilegrid/TileGrid.js").default} tileGrid The default tile grid.
+   */
+  setDefaultTileGrid(tileGrid) {
+    this.defaultTileGrid_ = tileGrid;
+  }
+  /**
+   * Set the validity extent for this projection.
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @api
+   */
+  setExtent(extent) {
+    this.extent_ = extent;
+    this.canWrapX_ = !!(this.global_ && extent);
+  }
+  /**
+   * Set the world extent for this projection.
+   * @param {import("../extent.js").Extent} worldExtent World extent
+   *     [minlon, minlat, maxlon, maxlat].
+   * @api
+   */
+  setWorldExtent(worldExtent) {
+    this.worldExtent_ = worldExtent;
+  }
+  /**
+   * Set the getPointResolution function (see {@link module:ol/proj.getPointResolution}
+   * for this projection.
+   * @param {function(number, import("../coordinate.js").Coordinate):number} func Function
+   * @api
+   */
+  setGetPointResolution(func) {
+    this.getPointResolutionFunc_ = func;
+  }
+  /**
+   * Get the custom point resolution function for this projection (if set).
+   * @return {GetPointResolution|undefined} The custom point
+   * resolution function (if set).
+   */
+  getPointResolutionFunc() {
+    return this.getPointResolutionFunc_;
+  }
+};
+var Projection_default = Projection;
+
+// node_modules/ol/proj.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/ol/coordinate.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/ol/string.js
+init_dirname();
+init_buffer();
+init_process();
+function padNumber(number, width, precision) {
+  const numberString = precision !== void 0 ? number.toFixed(precision) : "" + number;
+  let decimal = numberString.indexOf(".");
+  decimal = decimal === -1 ? numberString.length : decimal;
+  return decimal > width ? numberString : new Array(1 + width - decimal).join("0") + numberString;
+}
+
+// node_modules/ol/coordinate.js
+function add(coordinate, delta) {
+  coordinate[0] += +delta[0];
+  coordinate[1] += +delta[1];
+  return coordinate;
+}
+function degreesToStringHDMS(hemispheres, degrees, fractionDigits) {
+  const normalizedDegrees = modulo(degrees + 180, 360) - 180;
+  const x = Math.abs(3600 * normalizedDegrees);
+  const decimals = fractionDigits || 0;
+  let deg = Math.floor(x / 3600);
+  let min = Math.floor((x - deg * 3600) / 60);
+  let sec = toFixed(x - deg * 3600 - min * 60, decimals);
+  if (sec >= 60) {
+    sec = 0;
+    min += 1;
+  }
+  if (min >= 60) {
+    min = 0;
+    deg += 1;
+  }
+  let hdms = deg + "\xB0";
+  if (min !== 0 || sec !== 0) {
+    hdms += " " + padNumber(min, 2) + "\u2032";
+  }
+  if (sec !== 0) {
+    hdms += " " + padNumber(sec, 2, decimals) + "\u2033";
+  }
+  if (normalizedDegrees !== 0) {
+    hdms += " " + hemispheres.charAt(normalizedDegrees < 0 ? 1 : 0);
+  }
+  return hdms;
+}
+function equals2(coordinate1, coordinate2) {
+  let equals4 = true;
+  for (let i = coordinate1.length - 1; i >= 0; --i) {
+    if (coordinate1[i] != coordinate2[i]) {
+      equals4 = false;
+      break;
+    }
+  }
+  return equals4;
+}
+function rotate(coordinate, angle) {
+  const cosAngle = Math.cos(angle);
+  const sinAngle = Math.sin(angle);
+  const x = coordinate[0] * cosAngle - coordinate[1] * sinAngle;
+  const y = coordinate[1] * cosAngle + coordinate[0] * sinAngle;
+  coordinate[0] = x;
+  coordinate[1] = y;
+  return coordinate;
+}
+function scale(coordinate, scale4) {
+  coordinate[0] *= scale4;
+  coordinate[1] *= scale4;
+  return coordinate;
+}
+function squaredDistance2(coord1, coord2) {
+  const dx = coord1[0] - coord2[0];
+  const dy = coord1[1] - coord2[1];
+  return dx * dx + dy * dy;
+}
+function distance(coord1, coord2) {
+  return Math.sqrt(squaredDistance2(coord1, coord2));
+}
+function wrapX2(coordinate, projection) {
+  if (projection.canWrapX()) {
+    const worldWidth = getWidth(projection.getExtent());
+    const worldsAway = getWorldsAway(coordinate, projection, worldWidth);
+    if (worldsAway) {
+      coordinate[0] -= worldsAway * worldWidth;
+    }
+  }
+  return coordinate;
+}
+function getWorldsAway(coordinate, projection, sourceExtentWidth) {
+  const projectionExtent = projection.getExtent();
+  let worldsAway = 0;
+  if (projection.canWrapX() && (coordinate[0] < projectionExtent[0] || coordinate[0] > projectionExtent[2])) {
+    sourceExtentWidth = sourceExtentWidth || getWidth(projectionExtent);
+    worldsAway = Math.floor(
+      (coordinate[0] - projectionExtent[0]) / sourceExtentWidth
+    );
+  }
+  return worldsAway;
+}
+function angleBetween(p0, pA, pB) {
+  const lenA = Math.sqrt(
+    (pA[0] - p0[0]) * (pA[0] - p0[0]) + (pA[1] - p0[1]) * (pA[1] - p0[1])
+  );
+  const tangentA = [(pA[0] - p0[0]) / lenA, (pA[1] - p0[1]) / lenA];
+  const orthoA = [-tangentA[1], tangentA[0]];
+  const lenB = Math.sqrt(
+    (pB[0] - p0[0]) * (pB[0] - p0[0]) + (pB[1] - p0[1]) * (pB[1] - p0[1])
+  );
+  const tangentB = [(pB[0] - p0[0]) / lenB, (pB[1] - p0[1]) / lenB];
+  let angle = lenA === 0 || lenB === 0 ? 0 : Math.acos(
+    clamp(tangentB[0] * tangentA[0] + tangentB[1] * tangentA[1], -1, 1)
+  );
+  angle = Math.max(angle, 1e-5);
+  const isClockwise = tangentB[0] * orthoA[0] + tangentB[1] * orthoA[1] > 0;
+  return !isClockwise ? Math.PI * 2 - angle : angle;
+}
+
+// node_modules/ol/proj/epsg3857.js
+init_dirname();
+init_buffer();
+init_process();
+var RADIUS = 6378137;
+var HALF_SIZE = Math.PI * RADIUS;
+var EXTENT = [-HALF_SIZE, -HALF_SIZE, HALF_SIZE, HALF_SIZE];
+var WORLD_EXTENT = [-180, -85, 180, 85];
+var MAX_SAFE_Y = RADIUS * Math.log(Math.tan(Math.PI / 2));
+var EPSG3857Projection = class extends Projection_default {
+  /**
+   * @param {string} code Code.
+   */
+  constructor(code) {
+    super({
+      code,
+      units: "m",
+      extent: EXTENT,
+      global: true,
+      worldExtent: WORLD_EXTENT,
+      getPointResolution: function(resolution, point) {
+        return resolution / Math.cosh(point[1] / RADIUS);
+      }
+    });
+  }
+};
+var PROJECTIONS = [
+  new EPSG3857Projection("EPSG:3857"),
+  new EPSG3857Projection("EPSG:102100"),
+  new EPSG3857Projection("EPSG:102113"),
+  new EPSG3857Projection("EPSG:900913"),
+  new EPSG3857Projection("http://www.opengis.net/def/crs/EPSG/0/3857"),
+  new EPSG3857Projection("http://www.opengis.net/gml/srs/epsg.xml#3857")
+];
+function fromEPSG4326(input, output, dimension, stride) {
+  const length = input.length;
+  dimension = dimension > 1 ? dimension : 2;
+  stride = stride != null ? stride : dimension;
+  if (output === void 0) {
+    if (dimension > 2) {
+      output = input.slice();
+    } else {
+      output = new Array(length);
+    }
+  }
+  for (let i = 0; i < length; i += stride) {
+    output[i] = HALF_SIZE * input[i] / 180;
+    let y = RADIUS * Math.log(Math.tan(Math.PI * (+input[i + 1] + 90) / 360));
+    if (y > MAX_SAFE_Y) {
+      y = MAX_SAFE_Y;
+    } else if (y < -MAX_SAFE_Y) {
+      y = -MAX_SAFE_Y;
+    }
+    output[i + 1] = y;
+  }
+  return output;
+}
+function toEPSG4326(input, output, dimension, stride) {
+  const length = input.length;
+  dimension = dimension > 1 ? dimension : 2;
+  stride = stride != null ? stride : dimension;
+  if (output === void 0) {
+    if (dimension > 2) {
+      output = input.slice();
+    } else {
+      output = new Array(length);
+    }
+  }
+  for (let i = 0; i < length; i += stride) {
+    output[i] = 180 * input[i] / HALF_SIZE;
+    output[i + 1] = 360 * Math.atan(Math.exp(input[i + 1] / RADIUS)) / Math.PI - 90;
+  }
+  return output;
+}
+
+// node_modules/ol/proj/epsg4326.js
+init_dirname();
+init_buffer();
+init_process();
+var RADIUS2 = 6378137;
+var EXTENT2 = [-180, -90, 180, 90];
+var METERS_PER_UNIT2 = Math.PI * RADIUS2 / 180;
+var EPSG4326Projection = class extends Projection_default {
+  /**
+   * @param {string} code Code.
+   * @param {string} [axisOrientation] Axis orientation.
+   */
+  constructor(code, axisOrientation) {
+    super({
+      code,
+      units: "degrees",
+      extent: EXTENT2,
+      axisOrientation,
+      global: true,
+      metersPerUnit: METERS_PER_UNIT2,
+      worldExtent: EXTENT2
+    });
+  }
+};
+var PROJECTIONS2 = [
+  new EPSG4326Projection("CRS:84"),
+  new EPSG4326Projection("EPSG:4326", "neu"),
+  new EPSG4326Projection("urn:ogc:def:crs:OGC:1.3:CRS84"),
+  new EPSG4326Projection("urn:ogc:def:crs:OGC:2:84"),
+  new EPSG4326Projection("http://www.opengis.net/def/crs/OGC/1.3/CRS84"),
+  new EPSG4326Projection("http://www.opengis.net/gml/srs/epsg.xml#4326", "neu"),
+  new EPSG4326Projection("http://www.opengis.net/def/crs/EPSG/0/4326", "neu")
+];
+
+// node_modules/ol/proj/projections.js
+init_dirname();
+init_buffer();
+init_process();
+var cache = {};
+function get(code) {
+  return cache[code] || cache[code.replace(/urn:(x-)?ogc:def:crs:EPSG:(.*:)?(\w+)$/, "EPSG:$3")] || null;
+}
+function add2(code, projection) {
+  cache[code] = projection;
+}
+
+// node_modules/ol/proj/transforms.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/ol/obj.js
+init_dirname();
+init_buffer();
+init_process();
+function clear(object) {
+  for (const property in object) {
+    delete object[property];
+  }
+}
+function isEmpty2(object) {
+  let property;
+  for (property in object) {
+    return false;
+  }
+  return !property;
+}
+
+// node_modules/ol/proj/transforms.js
+var transforms = {};
+function add3(source, destination, transformFn) {
+  const sourceCode = source.getCode();
+  const destinationCode = destination.getCode();
+  if (!(sourceCode in transforms)) {
+    transforms[sourceCode] = {};
+  }
+  transforms[sourceCode][destinationCode] = transformFn;
+}
+function get2(sourceCode, destinationCode) {
+  if (sourceCode in transforms && destinationCode in transforms[sourceCode]) {
+    return transforms[sourceCode][destinationCode];
+  }
+  return null;
+}
+
+// node_modules/ol/proj/utm.js
+init_dirname();
+init_buffer();
+init_process();
+var K0 = 0.9996;
+var E = 669438e-8;
+var E2 = E * E;
+var E3 = E2 * E;
+var E_P2 = E / (1 - E);
+var SQRT_E = Math.sqrt(1 - E);
+var _E = (1 - SQRT_E) / (1 + SQRT_E);
+var _E2 = _E * _E;
+var _E3 = _E2 * _E;
+var _E4 = _E3 * _E;
+var _E5 = _E4 * _E;
+var M1 = 1 - E / 4 - 3 * E2 / 64 - 5 * E3 / 256;
+var M2 = 3 * E / 8 + 3 * E2 / 32 + 45 * E3 / 1024;
+var M3 = 15 * E2 / 256 + 45 * E3 / 1024;
+var M4 = 35 * E3 / 3072;
+var P2 = 3 / 2 * _E - 27 / 32 * _E3 + 269 / 512 * _E5;
+var P3 = 21 / 16 * _E2 - 55 / 32 * _E4;
+var P4 = 151 / 96 * _E3 - 417 / 128 * _E5;
+var P5 = 1097 / 512 * _E4;
+var R = 6378137;
+function toLonLat(easting, northing, zone) {
+  const x = easting - 5e5;
+  const y = zone.north ? northing : northing - 1e7;
+  const m = y / K0;
+  const mu = m / (R * M1);
+  const pRad = mu + P2 * Math.sin(2 * mu) + P3 * Math.sin(4 * mu) + P4 * Math.sin(6 * mu) + P5 * Math.sin(8 * mu);
+  const pSin = Math.sin(pRad);
+  const pSin2 = pSin * pSin;
+  const pCos = Math.cos(pRad);
+  const pTan = pSin / pCos;
+  const pTan2 = pTan * pTan;
+  const pTan4 = pTan2 * pTan2;
+  const epSin = 1 - E * pSin2;
+  const epSinSqrt = Math.sqrt(1 - E * pSin2);
+  const n = R / epSinSqrt;
+  const r = (1 - E) / epSin;
+  const c = E_P2 * pCos ** 2;
+  const c2 = c * c;
+  const d = x / (n * K0);
+  const d2 = d * d;
+  const d3 = d2 * d;
+  const d4 = d3 * d;
+  const d5 = d4 * d;
+  const d6 = d5 * d;
+  const latitude = pRad - pTan / r * (d2 / 2 - d4 / 24 * (5 + 3 * pTan2 + 10 * c - 4 * c2 - 9 * E_P2)) + d6 / 720 * (61 + 90 * pTan2 + 298 * c + 45 * pTan4 - 252 * E_P2 - 3 * c2);
+  let longitude = (d - d3 / 6 * (1 + 2 * pTan2 + c) + d5 / 120 * (5 - 2 * c + 28 * pTan2 - 3 * c2 + 8 * E_P2 + 24 * pTan4)) / pCos;
+  longitude = wrap(
+    longitude + toRadians(zoneToCentralLongitude(zone.number)),
+    -Math.PI,
+    Math.PI
+  );
+  return [toDegrees(longitude), toDegrees(latitude)];
+}
+var MIN_LATITUDE = -80;
+var MAX_LATITUDE = 84;
+var MIN_LONGITUDE = -180;
+var MAX_LONGITUDE = 180;
+function fromLonLat(longitude, latitude, zone) {
+  longitude = wrap(longitude, MIN_LONGITUDE, MAX_LONGITUDE);
+  if (latitude < MIN_LATITUDE) {
+    latitude = MIN_LATITUDE;
+  } else if (latitude > MAX_LATITUDE) {
+    latitude = MAX_LATITUDE;
+  }
+  const latRad = toRadians(latitude);
+  const latSin = Math.sin(latRad);
+  const latCos = Math.cos(latRad);
+  const latTan = latSin / latCos;
+  const latTan2 = latTan * latTan;
+  const latTan4 = latTan2 * latTan2;
+  const lonRad = toRadians(longitude);
+  const centralLon = zoneToCentralLongitude(zone.number);
+  const centralLonRad = toRadians(centralLon);
+  const n = R / Math.sqrt(1 - E * latSin ** 2);
+  const c = E_P2 * latCos ** 2;
+  const a = latCos * wrap(lonRad - centralLonRad, -Math.PI, Math.PI);
+  const a2 = a * a;
+  const a3 = a2 * a;
+  const a4 = a3 * a;
+  const a5 = a4 * a;
+  const a6 = a5 * a;
+  const m = R * (M1 * latRad - M2 * Math.sin(2 * latRad) + M3 * Math.sin(4 * latRad) - M4 * Math.sin(6 * latRad));
+  const easting = K0 * n * (a + a3 / 6 * (1 - latTan2 + c) + a5 / 120 * (5 - 18 * latTan2 + latTan4 + 72 * c - 58 * E_P2)) + 5e5;
+  let northing = K0 * (m + n * latTan * (a2 / 2 + a4 / 24 * (5 - latTan2 + 9 * c + 4 * c ** 2) + a6 / 720 * (61 - 58 * latTan2 + latTan4 + 600 * c - 330 * E_P2)));
+  if (!zone.north) {
+    northing += 1e7;
+  }
+  return [easting, northing];
+}
+function zoneToCentralLongitude(zone) {
+  return (zone - 1) * 6 - 180 + 3;
+}
+var epsgRegExes = [
+  /^EPSG:(\d+)$/,
+  /^urn:ogc:def:crs:EPSG::(\d+)$/,
+  /^http:\/\/www\.opengis\.net\/def\/crs\/EPSG\/0\/(\d+)$/
+];
+function zoneFromCode(code) {
+  let epsgId = 0;
+  for (const re of epsgRegExes) {
+    const match = code.match(re);
+    if (match) {
+      epsgId = parseInt(match[1]);
+      break;
+    }
+  }
+  if (!epsgId) {
+    return null;
+  }
+  let number = 0;
+  let north = false;
+  if (epsgId > 32700 && epsgId < 32761) {
+    number = epsgId - 32700;
+  } else if (epsgId > 32600 && epsgId < 32661) {
+    north = true;
+    number = epsgId - 32600;
+  }
+  if (!number) {
+    return null;
+  }
+  return { number, north };
+}
+function makeTransformFunction(transformer, zone) {
+  return function(input, output, dimension, stride) {
+    const length = input.length;
+    dimension = dimension > 1 ? dimension : 2;
+    stride = stride != null ? stride : dimension;
+    if (!output) {
+      if (dimension > 2) {
+        output = input.slice();
+      } else {
+        output = new Array(length);
+      }
+    }
+    for (let i = 0; i < length; i += stride) {
+      const x = input[i];
+      const y = input[i + 1];
+      const coord = transformer(x, y, zone);
+      output[i] = coord[0];
+      output[i + 1] = coord[1];
+    }
+    return output;
+  };
+}
+function makeProjection(code) {
+  const zone = zoneFromCode(code);
+  if (!zone) {
+    return null;
+  }
+  return new Projection_default({ code, units: "m" });
+}
+function makeTransforms(projection) {
+  const zone = zoneFromCode(projection.getCode());
+  if (!zone) {
+    return null;
+  }
+  return {
+    forward: makeTransformFunction(fromLonLat, zone),
+    inverse: makeTransformFunction(toLonLat, zone)
+  };
+}
+
+// node_modules/ol/proj.js
+var transformFactories = [makeTransforms];
+var projectionFactories = [makeProjection];
+var showCoordinateWarning = true;
+function disableCoordinateWarning(disable) {
+  const hide = disable === void 0 ? true : disable;
+  showCoordinateWarning = !hide;
+}
+function cloneTransform(input, output) {
+  if (output !== void 0) {
+    for (let i = 0, ii = input.length; i < ii; ++i) {
+      output[i] = input[i];
+    }
+    output = output;
+  } else {
+    output = input.slice();
+  }
+  return output;
+}
+function addProjection(projection) {
+  add2(projection.getCode(), projection);
+  add3(projection, projection, cloneTransform);
+}
+function addProjections(projections) {
+  projections.forEach(addProjection);
+}
+function get3(projectionLike) {
+  if (!(typeof projectionLike === "string")) {
+    return projectionLike;
+  }
+  const projection = get(projectionLike);
+  if (projection) {
+    return projection;
+  }
+  for (const makeProjection2 of projectionFactories) {
+    const projection2 = makeProjection2(projectionLike);
+    if (projection2) {
+      return projection2;
+    }
+  }
+  return null;
+}
+function getPointResolution(projection, resolution, point, units) {
+  projection = get3(projection);
+  let pointResolution;
+  const getter = projection.getPointResolutionFunc();
+  if (getter) {
+    pointResolution = getter(resolution, point);
+    if (units && units !== projection.getUnits()) {
+      const metersPerUnit = projection.getMetersPerUnit();
+      if (metersPerUnit) {
+        pointResolution = pointResolution * metersPerUnit / METERS_PER_UNIT[units];
+      }
+    }
+  } else {
+    const projUnits = projection.getUnits();
+    if (projUnits == "degrees" && !units || units == "degrees") {
+      pointResolution = resolution;
+    } else {
+      const toEPSG43262 = getTransformFromProjections(
+        projection,
+        get3("EPSG:4326")
+      );
+      if (!toEPSG43262 && projUnits !== "degrees") {
+        pointResolution = resolution * projection.getMetersPerUnit();
+      } else {
+        let vertices = [
+          point[0] - resolution / 2,
+          point[1],
+          point[0] + resolution / 2,
+          point[1],
+          point[0],
+          point[1] - resolution / 2,
+          point[0],
+          point[1] + resolution / 2
+        ];
+        vertices = toEPSG43262(vertices, vertices, 2);
+        const width = getDistance(vertices.slice(0, 2), vertices.slice(2, 4));
+        const height = getDistance(vertices.slice(4, 6), vertices.slice(6, 8));
+        pointResolution = (width + height) / 2;
+      }
+      const metersPerUnit = units ? METERS_PER_UNIT[units] : projection.getMetersPerUnit();
+      if (metersPerUnit !== void 0) {
+        pointResolution /= metersPerUnit;
+      }
+    }
+  }
+  return pointResolution;
+}
+function addEquivalentProjections(projections) {
+  addProjections(projections);
+  projections.forEach(function(source) {
+    projections.forEach(function(destination) {
+      if (source !== destination) {
+        add3(source, destination, cloneTransform);
+      }
+    });
+  });
+}
+function addEquivalentTransforms(projections1, projections2, forwardTransform, inverseTransform) {
+  projections1.forEach(function(projection1) {
+    projections2.forEach(function(projection2) {
+      add3(projection1, projection2, forwardTransform);
+      add3(projection2, projection1, inverseTransform);
+    });
+  });
+}
+function createProjection(projection, defaultCode) {
+  if (!projection) {
+    return get3(defaultCode);
+  }
+  if (typeof projection === "string") {
+    return get3(projection);
+  }
+  return (
+    /** @type {Projection} */
+    projection
+  );
+}
+function createTransformFromCoordinateTransform(coordTransform) {
+  return (
+    /**
+     * @param {Array<number>} input Input.
+     * @param {Array<number>} [output] Output.
+     * @param {number} [dimension] Dimensions that should be transformed.
+     * @param {number} [stride] Stride.
+     * @return {Array<number>} Output.
+     */
+    function(input, output, dimension, stride) {
+      const length = input.length;
+      dimension = dimension !== void 0 ? dimension : 2;
+      stride = stride != null ? stride : dimension;
+      output = output !== void 0 ? output : new Array(length);
+      for (let i = 0; i < length; i += stride) {
+        const point = coordTransform(input.slice(i, i + dimension));
+        const pointLength = point.length;
+        for (let j = 0, jj = stride; j < jj; ++j) {
+          output[i + j] = j >= pointLength ? input[i + j] : point[j];
+        }
+      }
+      return output;
+    }
+  );
+}
+function toLonLat2(coordinate, projection) {
+  const lonLat = transform(
+    coordinate,
+    projection !== void 0 ? projection : "EPSG:3857",
+    "EPSG:4326"
+  );
+  const lon = lonLat[0];
+  if (lon < -180 || lon > 180) {
+    lonLat[0] = modulo(lon + 180, 360) - 180;
+  }
+  return lonLat;
+}
+function equivalent(projection1, projection2) {
+  if (projection1 === projection2) {
+    return true;
+  }
+  const equalUnits = projection1.getUnits() === projection2.getUnits();
+  if (projection1.getCode() === projection2.getCode()) {
+    return equalUnits;
+  }
+  const transformFunc = getTransformFromProjections(projection1, projection2);
+  return transformFunc === cloneTransform && equalUnits;
+}
+function getTransformFromProjections(source, destination) {
+  const sourceCode = source.getCode();
+  const destinationCode = destination.getCode();
+  let transformFunc = get2(sourceCode, destinationCode);
+  if (transformFunc) {
+    return transformFunc;
+  }
+  let sourceTransforms = null;
+  let destinationTransforms = null;
+  for (const makeTransforms2 of transformFactories) {
+    if (!sourceTransforms) {
+      sourceTransforms = makeTransforms2(source);
+    }
+    if (!destinationTransforms) {
+      destinationTransforms = makeTransforms2(destination);
+    }
+  }
+  if (!sourceTransforms && !destinationTransforms) {
+    return null;
+  }
+  const intermediateCode = "EPSG:4326";
+  if (!destinationTransforms) {
+    const toDestination = get2(intermediateCode, destinationCode);
+    if (toDestination) {
+      transformFunc = composeTransformFuncs(
+        sourceTransforms.inverse,
+        toDestination
+      );
+    }
+  } else if (!sourceTransforms) {
+    const fromSource = get2(sourceCode, intermediateCode);
+    if (fromSource) {
+      transformFunc = composeTransformFuncs(
+        fromSource,
+        destinationTransforms.forward
+      );
+    }
+  } else {
+    transformFunc = composeTransformFuncs(
+      sourceTransforms.inverse,
+      destinationTransforms.forward
+    );
+  }
+  if (transformFunc) {
+    addProjection(source);
+    addProjection(destination);
+    add3(source, destination, transformFunc);
+  }
+  return transformFunc;
+}
+function composeTransformFuncs(t1, t2) {
+  return function(input, output, dimensions, stride) {
+    output = t1(input, output, dimensions, stride);
+    return t2(output, output, dimensions, stride);
+  };
+}
+function getTransform(source, destination) {
+  const sourceProjection = get3(source);
+  const destinationProjection = get3(destination);
+  return getTransformFromProjections(sourceProjection, destinationProjection);
+}
+function transform(coordinate, source, destination) {
+  const transformFunc = getTransform(source, destination);
+  if (!transformFunc) {
+    const sourceCode = get3(source).getCode();
+    const destinationCode = get3(destination).getCode();
+    throw new Error(
+      `No transform available between ${sourceCode} and ${destinationCode}`
+    );
+  }
+  return transformFunc(coordinate, void 0, coordinate.length);
+}
+function transformExtent(extent, source, destination, stops) {
+  const transformFunc = getTransform(source, destination);
+  return applyTransform(extent, transformFunc, void 0, stops);
+}
+var userProjection = null;
+function getUserProjection() {
+  return userProjection;
+}
+function toUserCoordinate(coordinate, sourceProjection) {
+  if (!userProjection) {
+    return coordinate;
+  }
+  return transform(coordinate, sourceProjection, userProjection);
+}
+function fromUserCoordinate(coordinate, destProjection) {
+  if (!userProjection) {
+    if (showCoordinateWarning && !equals2(coordinate, [0, 0]) && coordinate[0] >= -180 && coordinate[0] <= 180 && coordinate[1] >= -90 && coordinate[1] <= 90) {
+      showCoordinateWarning = false;
+      warn(
+        "Call useGeographic() from ol/proj once to work with [longitude, latitude] coordinates."
+      );
+    }
+    return coordinate;
+  }
+  return transform(coordinate, userProjection, destProjection);
+}
+function toUserExtent(extent, sourceProjection) {
+  if (!userProjection) {
+    return extent;
+  }
+  return transformExtent(extent, sourceProjection, userProjection);
+}
+function fromUserExtent(extent, destProjection) {
+  if (!userProjection) {
+    return extent;
+  }
+  return transformExtent(extent, userProjection, destProjection);
+}
+function toUserResolution(resolution, sourceProjection) {
+  if (!userProjection) {
+    return resolution;
+  }
+  const sourceMetersPerUnit = get3(sourceProjection).getMetersPerUnit();
+  const userMetersPerUnit = userProjection.getMetersPerUnit();
+  return sourceMetersPerUnit && userMetersPerUnit ? resolution * sourceMetersPerUnit / userMetersPerUnit : resolution;
+}
+function addCommon() {
+  addEquivalentProjections(PROJECTIONS);
+  addEquivalentProjections(PROJECTIONS2);
+  addEquivalentTransforms(
+    PROJECTIONS2,
+    PROJECTIONS,
+    fromEPSG4326,
+    toEPSG4326
+  );
+}
+addCommon();
+
+// node_modules/ol/transform.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/ol/asserts.js
+init_dirname();
+init_buffer();
+init_process();
+function assert(assertion, errorMessage) {
+  if (!assertion) {
+    throw new Error(errorMessage);
+  }
+}
+
+// node_modules/ol/transform.js
+var tmp_ = new Array(6);
+function create() {
+  return [1, 0, 0, 1, 0, 0];
+}
+function reset(transform2) {
+  return set(transform2, 1, 0, 0, 1, 0, 0);
+}
+function multiply(transform1, transform2) {
+  const a1 = transform1[0];
+  const b1 = transform1[1];
+  const c1 = transform1[2];
+  const d1 = transform1[3];
+  const e1 = transform1[4];
+  const f1 = transform1[5];
+  const a2 = transform2[0];
+  const b2 = transform2[1];
+  const c2 = transform2[2];
+  const d2 = transform2[3];
+  const e2 = transform2[4];
+  const f2 = transform2[5];
+  transform1[0] = a1 * a2 + c1 * b2;
+  transform1[1] = b1 * a2 + d1 * b2;
+  transform1[2] = a1 * c2 + c1 * d2;
+  transform1[3] = b1 * c2 + d1 * d2;
+  transform1[4] = a1 * e2 + c1 * f2 + e1;
+  transform1[5] = b1 * e2 + d1 * f2 + f1;
+  return transform1;
+}
+function set(transform2, a, b, c, d, e, f) {
+  transform2[0] = a;
+  transform2[1] = b;
+  transform2[2] = c;
+  transform2[3] = d;
+  transform2[4] = e;
+  transform2[5] = f;
+  return transform2;
+}
+function setFromArray(transform1, transform2) {
+  transform1[0] = transform2[0];
+  transform1[1] = transform2[1];
+  transform1[2] = transform2[2];
+  transform1[3] = transform2[3];
+  transform1[4] = transform2[4];
+  transform1[5] = transform2[5];
+  return transform1;
+}
+function apply(transform2, coordinate) {
+  const x = coordinate[0];
+  const y = coordinate[1];
+  coordinate[0] = transform2[0] * x + transform2[2] * y + transform2[4];
+  coordinate[1] = transform2[1] * x + transform2[3] * y + transform2[5];
+  return coordinate;
+}
+function rotate2(transform2, angle) {
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  return multiply(transform2, set(tmp_, cos, sin, -sin, cos, 0, 0));
+}
+function scale2(transform2, x, y) {
+  return multiply(transform2, set(tmp_, x, 0, 0, y, 0, 0));
+}
+function translate(transform2, dx, dy) {
+  return multiply(transform2, set(tmp_, 1, 0, 0, 1, dx, dy));
+}
+function compose(transform2, dx1, dy1, sx, sy, angle, dx2, dy2) {
+  const sin = Math.sin(angle);
+  const cos = Math.cos(angle);
+  transform2[0] = sx * cos;
+  transform2[1] = sy * sin;
+  transform2[2] = -sx * sin;
+  transform2[3] = sy * cos;
+  transform2[4] = dx2 * sx * cos - dy2 * sx * sin + dx1;
+  transform2[5] = dx2 * sy * sin + dy2 * sy * cos + dy1;
+  return transform2;
+}
+function makeInverse(target, source) {
+  const det = determinant(source);
+  assert(det !== 0, "Transformation matrix cannot be inverted");
+  const a = source[0];
+  const b = source[1];
+  const c = source[2];
+  const d = source[3];
+  const e = source[4];
+  const f = source[5];
+  target[0] = d / det;
+  target[1] = -b / det;
+  target[2] = -c / det;
+  target[3] = a / det;
+  target[4] = (c * f - d * e) / det;
+  target[5] = -(a * f - b * e) / det;
+  return target;
+}
+function determinant(mat) {
+  return mat[0] * mat[3] - mat[1] * mat[2];
+}
+var matrixPrecision = [1e5, 1e5, 1e5, 1e5, 2, 2];
+function toString(mat) {
+  const transformString = "matrix(" + mat.join(", ") + ")";
+  return transformString;
+}
+function fromString(cssTransform) {
+  const values = cssTransform.substring(7, cssTransform.length - 1).split(",");
+  return values.map(parseFloat);
+}
+function equivalent2(cssTransform1, cssTransform2) {
+  const mat1 = fromString(cssTransform1);
+  const mat2 = fromString(cssTransform2);
+  for (let i = 0; i < 6; ++i) {
+    if (Math.round((mat1[i] - mat2[i]) * matrixPrecision[i]) !== 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// node_modules/ol/ObjectEventType.js
+init_dirname();
+init_buffer();
+init_process();
+var ObjectEventType_default = {
+  /**
+   * Triggered when a property is changed.
+   * @event module:ol/Object.ObjectEvent#propertychange
+   * @api
+   */
+  PROPERTYCHANGE: "propertychange"
+};
+
+// node_modules/ol/events/EventType.js
+init_dirname();
+init_buffer();
+init_process();
+var EventType_default = {
+  /**
+   * Generic change event. Triggered when the revision counter is increased.
+   * @event module:ol/events/Event~BaseEvent#change
+   * @api
+   */
+  CHANGE: "change",
+  /**
+   * Generic error event. Triggered when an error occurs.
+   * @event module:ol/events/Event~BaseEvent#error
+   * @api
+   */
+  ERROR: "error",
+  BLUR: "blur",
+  CLEAR: "clear",
+  CONTEXTMENU: "contextmenu",
+  CLICK: "click",
+  DBLCLICK: "dblclick",
+  DRAGENTER: "dragenter",
+  DRAGOVER: "dragover",
+  DROP: "drop",
+  FOCUS: "focus",
+  KEYDOWN: "keydown",
+  KEYPRESS: "keypress",
+  LOAD: "load",
+  RESIZE: "resize",
+  TOUCHMOVE: "touchmove",
+  WHEEL: "wheel"
+};
+
+// node_modules/ol/Disposable.js
+init_dirname();
+init_buffer();
+init_process();
+var Disposable = class {
+  constructor() {
+    this.disposed = false;
+  }
+  /**
+   * Clean up.
+   */
+  dispose() {
+    if (!this.disposed) {
+      this.disposed = true;
+      this.disposeInternal();
+    }
+  }
+  /**
+   * Extension point for disposable objects.
+   * @protected
+   */
+  disposeInternal() {
+  }
+};
+var Disposable_default = Disposable;
+
+// node_modules/ol/array.js
+init_dirname();
+init_buffer();
+init_process();
+function binarySearch(haystack, needle, comparator) {
+  let mid, cmp;
+  comparator = comparator || ascending;
+  let low = 0;
+  let high = haystack.length;
+  let found = false;
+  while (low < high) {
+    mid = low + (high - low >> 1);
+    cmp = +comparator(haystack[mid], needle);
+    if (cmp < 0) {
+      low = mid + 1;
+    } else {
+      high = mid;
+      found = !cmp;
+    }
+  }
+  return found ? low : ~low;
+}
+function ascending(a, b) {
+  return a > b ? 1 : a < b ? -1 : 0;
+}
+function descending(a, b) {
+  return a < b ? 1 : a > b ? -1 : 0;
+}
+function linearFindNearest(arr, target, direction) {
+  if (arr[0] <= target) {
+    return 0;
+  }
+  const n = arr.length;
+  if (target <= arr[n - 1]) {
+    return n - 1;
+  }
+  if (typeof direction === "function") {
+    for (let i = 1; i < n; ++i) {
+      const candidate = arr[i];
+      if (candidate === target) {
+        return i;
+      }
+      if (candidate < target) {
+        if (direction(target, arr[i - 1], candidate) > 0) {
+          return i - 1;
+        }
+        return i;
+      }
+    }
+    return n - 1;
+  }
+  if (direction > 0) {
+    for (let i = 1; i < n; ++i) {
+      if (arr[i] < target) {
+        return i - 1;
+      }
+    }
+    return n - 1;
+  }
+  if (direction < 0) {
+    for (let i = 1; i < n; ++i) {
+      if (arr[i] <= target) {
+        return i;
+      }
+    }
+    return n - 1;
+  }
+  for (let i = 1; i < n; ++i) {
+    if (arr[i] == target) {
+      return i;
+    }
+    if (arr[i] < target) {
+      if (arr[i - 1] - target < target - arr[i]) {
+        return i - 1;
+      }
+      return i;
+    }
+  }
+  return n - 1;
+}
+function reverseSubArray(arr, begin, end) {
+  while (begin < end) {
+    const tmp = arr[begin];
+    arr[begin] = arr[end];
+    arr[end] = tmp;
+    ++begin;
+    --end;
+  }
+}
+function extend2(arr, data) {
+  const extension = Array.isArray(data) ? data : [data];
+  const length = extension.length;
+  for (let i = 0; i < length; i++) {
+    arr[arr.length] = extension[i];
+  }
+}
+function equals3(arr1, arr2) {
+  const len1 = arr1.length;
+  if (len1 !== arr2.length) {
+    return false;
+  }
+  for (let i = 0; i < len1; i++) {
+    if (arr1[i] !== arr2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function isSorted(arr, func, strict) {
+  const compare = func || ascending;
+  return arr.every(function(currentVal, index) {
+    if (index === 0) {
+      return true;
+    }
+    const res = compare(arr[index - 1], currentVal);
+    return !(res > 0 || strict && res === 0);
+  });
+}
+
+// node_modules/ol/functions.js
+init_dirname();
+init_buffer();
+init_process();
+function TRUE() {
+  return true;
+}
+function FALSE() {
+  return false;
+}
+function VOID() {
+}
+function memoizeOne(fn) {
+  let lastResult;
+  let lastArgs;
+  let lastThis;
+  return function() {
+    const nextArgs = Array.prototype.slice.call(arguments);
+    if (!lastArgs || this !== lastThis || !equals3(nextArgs, lastArgs)) {
+      lastThis = this;
+      lastArgs = nextArgs;
+      lastResult = fn.apply(this, arguments);
+    }
+    return lastResult;
+  };
+}
+function toPromise(getter) {
+  function promiseGetter() {
+    let value;
+    try {
+      value = getter();
+    } catch (err) {
+      return Promise.reject(err);
+    }
+    if (value instanceof Promise) {
+      return value;
+    }
+    return Promise.resolve(value);
+  }
+  return promiseGetter();
+}
+
+// node_modules/ol/events/Event.js
+init_dirname();
+init_buffer();
+init_process();
+var BaseEvent = class {
+  /**
+   * @param {string} type Type.
+   */
+  constructor(type) {
+    this.propagationStopped;
+    this.defaultPrevented;
+    this.type = type;
+    this.target = null;
+  }
+  /**
+   * Prevent default. This means that no emulated `click`, `singleclick` or `doubleclick` events
+   * will be fired.
+   * @api
+   */
+  preventDefault() {
+    this.defaultPrevented = true;
+  }
+  /**
+   * Stop event propagation.
+   * @api
+   */
+  stopPropagation() {
+    this.propagationStopped = true;
+  }
+};
+var Event_default = BaseEvent;
+
+// node_modules/ol/events.js
+init_dirname();
+init_buffer();
+init_process();
+function listen(target, type, listener, thisArg, once) {
+  if (once) {
+    const originalListener = listener;
+    listener = function(event) {
+      target.removeEventListener(type, listener);
+      return originalListener.call(thisArg != null ? thisArg : this, event);
+    };
+  } else if (thisArg && thisArg !== target) {
+    listener = listener.bind(thisArg);
+  }
+  const eventsKey = {
+    target,
+    type,
+    listener
+  };
+  target.addEventListener(type, listener);
+  return eventsKey;
+}
+function listenOnce(target, type, listener, thisArg) {
+  return listen(target, type, listener, thisArg, true);
+}
+function unlistenByKey(key) {
+  if (key && key.target) {
+    key.target.removeEventListener(key.type, key.listener);
+    clear(key);
+  }
+}
+
+// node_modules/ol/Observable.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/ol/events/Target.js
+init_dirname();
+init_buffer();
+init_process();
+var Target = class extends Disposable_default {
+  /**
+   * @param {*} [target] Default event target for dispatched events.
+   */
+  constructor(target) {
+    super();
+    this.eventTarget_ = target;
+    this.pendingRemovals_ = null;
+    this.dispatching_ = null;
+    this.listeners_ = null;
+  }
+  /**
+   * @param {string} type Type.
+   * @param {import("../events.js").Listener} listener Listener.
+   */
+  addEventListener(type, listener) {
+    if (!type || !listener) {
+      return;
+    }
+    const listeners = this.listeners_ || (this.listeners_ = {});
+    const listenersForType = listeners[type] || (listeners[type] = []);
+    if (!listenersForType.includes(listener)) {
+      listenersForType.push(listener);
+    }
+  }
+  /**
+   * Dispatches an event and calls all listeners listening for events
+   * of this type. The event parameter can either be a string or an
+   * Object with a `type` property.
+   *
+   * @param {import("./Event.js").default|string} event Event object.
+   * @return {boolean|undefined} `false` if anyone called preventDefault on the
+   *     event object or if any of the listeners returned false.
+   * @api
+   */
+  dispatchEvent(event) {
+    const isString = typeof event === "string";
+    const type = isString ? event : event.type;
+    const listeners = this.listeners_ && this.listeners_[type];
+    if (!listeners) {
+      return;
+    }
+    const evt = isString ? new Event_default(event) : (
+      /** @type {Event} */
+      event
+    );
+    if (!evt.target) {
+      evt.target = this.eventTarget_ || this;
+    }
+    const dispatching = this.dispatching_ || (this.dispatching_ = {});
+    const pendingRemovals = this.pendingRemovals_ || (this.pendingRemovals_ = {});
+    if (!(type in dispatching)) {
+      dispatching[type] = 0;
+      pendingRemovals[type] = 0;
+    }
+    ++dispatching[type];
+    let propagate;
+    for (let i = 0, ii = listeners.length; i < ii; ++i) {
+      if ("handleEvent" in listeners[i]) {
+        propagate = /** @type {import("../events.js").ListenerObject} */
+        listeners[i].handleEvent(evt);
+      } else {
+        propagate = /** @type {import("../events.js").ListenerFunction} */
+        listeners[i].call(this, evt);
+      }
+      if (propagate === false || evt.propagationStopped) {
+        propagate = false;
+        break;
+      }
+    }
+    if (--dispatching[type] === 0) {
+      let pr = pendingRemovals[type];
+      delete pendingRemovals[type];
+      while (pr--) {
+        this.removeEventListener(type, VOID);
+      }
+      delete dispatching[type];
+    }
+    return propagate;
+  }
+  /**
+   * Clean up.
+   * @override
+   */
+  disposeInternal() {
+    this.listeners_ && clear(this.listeners_);
+  }
+  /**
+   * Get the listeners for a specified event type. Listeners are returned in the
+   * order that they will be called in.
+   *
+   * @param {string} type Type.
+   * @return {Array<import("../events.js").Listener>|undefined} Listeners.
+   */
+  getListeners(type) {
+    return this.listeners_ && this.listeners_[type] || void 0;
+  }
+  /**
+   * @param {string} [type] Type. If not provided,
+   *     `true` will be returned if this event target has any listeners.
+   * @return {boolean} Has listeners.
+   */
+  hasListener(type) {
+    if (!this.listeners_) {
+      return false;
+    }
+    return type ? type in this.listeners_ : Object.keys(this.listeners_).length > 0;
+  }
+  /**
+   * @param {string} type Type.
+   * @param {import("../events.js").Listener} listener Listener.
+   */
+  removeEventListener(type, listener) {
+    if (!this.listeners_) {
+      return;
+    }
+    const listeners = this.listeners_[type];
+    if (!listeners) {
+      return;
+    }
+    const index = listeners.indexOf(listener);
+    if (index !== -1) {
+      if (this.pendingRemovals_ && type in this.pendingRemovals_) {
+        listeners[index] = VOID;
+        ++this.pendingRemovals_[type];
+      } else {
+        listeners.splice(index, 1);
+        if (listeners.length === 0) {
+          delete this.listeners_[type];
+        }
+      }
+    }
+  }
+};
+var Target_default = Target;
+
+// node_modules/ol/Observable.js
+var Observable = class extends Target_default {
+  constructor() {
+    super();
+    this.on = /** @type {ObservableOnSignature<import("./events").EventsKey>} */
+    this.onInternal;
+    this.once = /** @type {ObservableOnSignature<import("./events").EventsKey>} */
+    this.onceInternal;
+    this.un = /** @type {ObservableOnSignature<void>} */
+    this.unInternal;
+    this.revision_ = 0;
+  }
+  /**
+   * Increases the revision counter and dispatches a 'change' event.
+   * @api
+   */
+  changed() {
+    ++this.revision_;
+    this.dispatchEvent(EventType_default.CHANGE);
+  }
+  /**
+   * Get the version number for this object.  Each time the object is modified,
+   * its version number will be incremented.
+   * @return {number} Revision.
+   * @api
+   */
+  getRevision() {
+    return this.revision_;
+  }
+  /**
+   * @param {string|Array<string>} type Type.
+   * @param {function((Event|import("./events/Event").default)): ?} listener Listener.
+   * @return {import("./events.js").EventsKey|Array<import("./events.js").EventsKey>} Event key.
+   * @protected
+   */
+  onInternal(type, listener) {
+    if (Array.isArray(type)) {
+      const len = type.length;
+      const keys = new Array(len);
+      for (let i = 0; i < len; ++i) {
+        keys[i] = listen(this, type[i], listener);
+      }
+      return keys;
+    }
+    return listen(
+      this,
+      /** @type {string} */
+      type,
+      listener
+    );
+  }
+  /**
+   * @param {string|Array<string>} type Type.
+   * @param {function((Event|import("./events/Event").default)): ?} listener Listener.
+   * @return {import("./events.js").EventsKey|Array<import("./events.js").EventsKey>} Event key.
+   * @protected
+   */
+  onceInternal(type, listener) {
+    let key;
+    if (Array.isArray(type)) {
+      const len = type.length;
+      key = new Array(len);
+      for (let i = 0; i < len; ++i) {
+        key[i] = listenOnce(this, type[i], listener);
+      }
+    } else {
+      key = listenOnce(
+        this,
+        /** @type {string} */
+        type,
+        listener
+      );
+    }
+    listener.ol_key = key;
+    return key;
+  }
+  /**
+   * Unlisten for a certain type of event.
+   * @param {string|Array<string>} type Type.
+   * @param {function((Event|import("./events/Event").default)): ?} listener Listener.
+   * @protected
+   */
+  unInternal(type, listener) {
+    const key = (
+      /** @type {Object} */
+      listener.ol_key
+    );
+    if (key) {
+      unByKey(key);
+    } else if (Array.isArray(type)) {
+      for (let i = 0, ii = type.length; i < ii; ++i) {
+        this.removeEventListener(type[i], listener);
+      }
+    } else {
+      this.removeEventListener(type, listener);
+    }
+  }
+};
+Observable.prototype.on;
+Observable.prototype.once;
+Observable.prototype.un;
+function unByKey(key) {
+  if (Array.isArray(key)) {
+    for (let i = 0, ii = key.length; i < ii; ++i) {
+      unlistenByKey(key[i]);
+    }
+  } else {
+    unlistenByKey(
+      /** @type {import("./events.js").EventsKey} */
+      key
+    );
+  }
+}
+var Observable_default = Observable;
+
+// node_modules/ol/util.js
+init_dirname();
+init_buffer();
+init_process();
+function abstract() {
+  throw new Error("Unimplemented abstract method.");
+}
+var uidCounter_ = 0;
+function getUid(obj) {
+  return obj.ol_uid || (obj.ol_uid = String(++uidCounter_));
+}
+
+// node_modules/ol/Object.js
+init_dirname();
+init_buffer();
+init_process();
+var ObjectEvent = class extends Event_default {
+  /**
+   * @param {string} type The event type.
+   * @param {string} key The property name.
+   * @param {*} oldValue The old value for `key`.
+   */
+  constructor(type, key, oldValue) {
+    super(type);
+    this.key = key;
+    this.oldValue = oldValue;
+  }
+};
+var BaseObject = class extends Observable_default {
+  /**
+   * @param {NoInfer<Properties>} [values] An object with key-value pairs.
+   */
+  constructor(values) {
+    super();
+    this.on;
+    this.once;
+    this.un;
+    getUid(this);
+    this.values_ = null;
+    if (values !== void 0) {
+      this.setProperties(values);
+    }
+  }
+  /**
+   * Gets a value.
+   * @param {string} key Key name.
+   * @return {*} Value.
+   * @api
+   */
+  get(key) {
+    let value;
+    if (this.values_ && this.values_.hasOwnProperty(key)) {
+      value = this.values_[key];
+    }
+    return value;
+  }
+  /**
+   * Get a list of object property names.
+   * @return {Array<string>} List of property names.
+   * @api
+   */
+  getKeys() {
+    return this.values_ && Object.keys(this.values_) || [];
+  }
+  /**
+   * Get an object of all property names and values.
+   * @return {NoInfer<Properties>} Object.
+   * @api
+   */
+  getProperties() {
+    return (
+      /** @type {NoInfer<Properties>} */
+      this.values_ && Object.assign({}, this.values_) || {}
+    );
+  }
+  /**
+   * Get an object of all property names and values.
+   * @return {Partial<NoInfer<Properties>>?} Object.
+   */
+  getPropertiesInternal() {
+    return this.values_;
+  }
+  /**
+   * @return {boolean} The object has properties.
+   */
+  hasProperties() {
+    return !!this.values_;
+  }
+  /**
+   * @param {string} key Key name.
+   * @param {*} oldValue Old value.
+   */
+  notify(key, oldValue) {
+    let eventType;
+    eventType = `change:${key}`;
+    if (this.hasListener(eventType)) {
+      this.dispatchEvent(new ObjectEvent(eventType, key, oldValue));
+    }
+    eventType = ObjectEventType_default.PROPERTYCHANGE;
+    if (this.hasListener(eventType)) {
+      this.dispatchEvent(new ObjectEvent(eventType, key, oldValue));
+    }
+  }
+  /**
+   * @param {string} key Key name.
+   * @param {import("./events.js").Listener} listener Listener.
+   */
+  addChangeListener(key, listener) {
+    this.addEventListener(`change:${key}`, listener);
+  }
+  /**
+   * @param {string} key Key name.
+   * @param {import("./events.js").Listener} listener Listener.
+   */
+  removeChangeListener(key, listener) {
+    this.removeEventListener(`change:${key}`, listener);
+  }
+  /**
+   * Sets a value.
+   * @param {string} key Key name.
+   * @param {*} value Value.
+   * @param {boolean} [silent] Update without triggering an event.
+   * @api
+   */
+  set(key, value, silent) {
+    const values = this.values_ || (this.values_ = {});
+    if (silent) {
+      values[key] = value;
+    } else {
+      const oldValue = values[key];
+      values[key] = value;
+      if (oldValue !== value) {
+        this.notify(key, oldValue);
+      }
+    }
+  }
+  /**
+   * Sets a collection of key-value pairs.  Note that this changes any existing
+   * properties and adds new ones (it does not remove any existing properties).
+   * @param {Partial<NoInfer<Properties>>} values Values.
+   * @param {boolean} [silent] Update without triggering an event.
+   * @api
+   */
+  setProperties(values, silent) {
+    for (const key in values) {
+      this.set(key, values[key], silent);
+    }
+  }
+  /**
+   * Apply any properties from another object without triggering events.
+   * @param {BaseObject} source The source object.
+   * @protected
+   */
+  applyProperties(source) {
+    if (!source.values_) {
+      return;
+    }
+    Object.assign(this.values_ || (this.values_ = {}), source.values_);
+  }
+  /**
+   * Unsets a property.
+   * @param {string} key Key name.
+   * @param {boolean} [silent] Unset without triggering an event.
+   * @api
+   */
+  unset(key, silent) {
+    if (this.values_ && key in this.values_) {
+      const oldValue = this.values_[key];
+      delete this.values_[key];
+      if (isEmpty2(this.values_)) {
+        this.values_ = null;
+      }
+      if (!silent) {
+        this.notify(key, oldValue);
+      }
+    }
+  }
+};
+var Object_default = BaseObject;
+
+// node_modules/ol/geom/flat/contains.js
+init_dirname();
+init_buffer();
+init_process();
+function linearRingContainsExtent(flatCoordinates, offset, end, stride, extent) {
+  const outside = forEachCorner(
+    extent,
+    /**
+     * @param {import("../../coordinate.js").Coordinate} coordinate Coordinate.
+     * @return {boolean} Contains (x, y).
+     */
+    function(coordinate) {
+      return !linearRingContainsXY(
+        flatCoordinates,
+        offset,
+        end,
+        stride,
+        coordinate[0],
+        coordinate[1]
+      );
+    }
+  );
+  return !outside;
+}
+function linearRingContainsXY(flatCoordinates, offset, end, stride, x, y) {
+  let wn = 0;
+  let x1 = flatCoordinates[end - stride];
+  let y1 = flatCoordinates[end - stride + 1];
+  for (; offset < end; offset += stride) {
+    const x2 = flatCoordinates[offset];
+    const y2 = flatCoordinates[offset + 1];
+    if (y1 <= y) {
+      if (y2 > y && (x2 - x1) * (y - y1) - (x - x1) * (y2 - y1) > 0) {
+        wn++;
+      }
+    } else if (y2 <= y && (x2 - x1) * (y - y1) - (x - x1) * (y2 - y1) < 0) {
+      wn--;
+    }
+    x1 = x2;
+    y1 = y2;
+  }
+  return wn !== 0;
+}
+function linearRingsContainsXY(flatCoordinates, offset, ends, stride, x, y) {
+  if (ends.length === 0) {
+    return false;
+  }
+  if (!linearRingContainsXY(flatCoordinates, offset, ends[0], stride, x, y)) {
+    return false;
+  }
+  for (let i = 1, ii = ends.length; i < ii; ++i) {
+    if (linearRingContainsXY(flatCoordinates, ends[i - 1], ends[i], stride, x, y)) {
+      return false;
+    }
+  }
+  return true;
+}
+function linearRingssContainsXY(flatCoordinates, offset, endss, stride, x, y) {
+  if (endss.length === 0) {
+    return false;
+  }
+  for (let i = 0, ii = endss.length; i < ii; ++i) {
+    const ends = endss[i];
+    if (linearRingsContainsXY(flatCoordinates, offset, ends, stride, x, y)) {
+      return true;
+    }
+    offset = ends[ends.length - 1];
+  }
+  return false;
+}
+
+// node_modules/ol/geom/flat/intersectsextent.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/ol/geom/flat/segments.js
+init_dirname();
+init_buffer();
+init_process();
+function forEach(flatCoordinates, offset, end, stride, callback) {
+  let ret;
+  offset += stride;
+  for (; offset < end; offset += stride) {
+    ret = callback(
+      flatCoordinates.slice(offset - stride, offset),
+      flatCoordinates.slice(offset, offset + stride)
+    );
+    if (ret) {
+      return ret;
+    }
+  }
+  return false;
+}
+
+// node_modules/ol/geom/flat/intersectsextent.js
+function intersectsLineString(flatCoordinates, offset, end, stride, extent, coordinatesExtent) {
+  coordinatesExtent = coordinatesExtent != null ? coordinatesExtent : extendFlatCoordinates(createEmpty(), flatCoordinates, offset, end, stride);
+  if (!intersects(extent, coordinatesExtent)) {
+    return false;
+  }
+  if (coordinatesExtent[0] >= extent[0] && coordinatesExtent[2] <= extent[2] || coordinatesExtent[1] >= extent[1] && coordinatesExtent[3] <= extent[3]) {
+    return true;
+  }
+  return forEach(
+    flatCoordinates,
+    offset,
+    end,
+    stride,
+    /**
+     * @param {import("../../coordinate.js").Coordinate} point1 Start point.
+     * @param {import("../../coordinate.js").Coordinate} point2 End point.
+     * @return {boolean} `true` if the segment and the extent intersect,
+     *     `false` otherwise.
+     */
+    function(point1, point2) {
+      return intersectsSegment(extent, point1, point2);
+    }
+  );
+}
+function intersectsLineStringArray(flatCoordinates, offset, ends, stride, extent) {
+  for (let i = 0, ii = ends.length; i < ii; ++i) {
+    if (intersectsLineString(flatCoordinates, offset, ends[i], stride, extent)) {
+      return true;
+    }
+    offset = ends[i];
+  }
+  return false;
+}
+function intersectsLinearRing(flatCoordinates, offset, end, stride, extent) {
+  if (intersectsLineString(flatCoordinates, offset, end, stride, extent)) {
+    return true;
+  }
+  if (linearRingContainsXY(
+    flatCoordinates,
+    offset,
+    end,
+    stride,
+    extent[0],
+    extent[1]
+  )) {
+    return true;
+  }
+  if (linearRingContainsXY(
+    flatCoordinates,
+    offset,
+    end,
+    stride,
+    extent[0],
+    extent[3]
+  )) {
+    return true;
+  }
+  if (linearRingContainsXY(
+    flatCoordinates,
+    offset,
+    end,
+    stride,
+    extent[2],
+    extent[1]
+  )) {
+    return true;
+  }
+  if (linearRingContainsXY(
+    flatCoordinates,
+    offset,
+    end,
+    stride,
+    extent[2],
+    extent[3]
+  )) {
+    return true;
+  }
+  return false;
+}
+function intersectsLinearRingArray(flatCoordinates, offset, ends, stride, extent) {
+  if (!intersectsLinearRing(flatCoordinates, offset, ends[0], stride, extent)) {
+    return false;
+  }
+  if (ends.length === 1) {
+    return true;
+  }
+  for (let i = 1, ii = ends.length; i < ii; ++i) {
+    if (linearRingContainsExtent(
+      flatCoordinates,
+      ends[i - 1],
+      ends[i],
+      stride,
+      extent
+    )) {
+      if (!intersectsLineString(
+        flatCoordinates,
+        ends[i - 1],
+        ends[i],
+        stride,
+        extent
+      )) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function intersectsLinearRingMultiArray(flatCoordinates, offset, endss, stride, extent) {
+  for (let i = 0, ii = endss.length; i < ii; ++i) {
+    const ends = endss[i];
+    if (intersectsLinearRingArray(flatCoordinates, offset, ends, stride, extent)) {
+      return true;
+    }
+    offset = ends[ends.length - 1];
+  }
+  return false;
+}
+
+// node_modules/ol/has.js
+init_dirname();
+init_buffer();
+init_process();
+var ua = typeof navigator !== "undefined" && typeof navigator.userAgent !== "undefined" ? navigator.userAgent.toLowerCase() : "";
+var SAFARI = ua.includes("safari") && !ua.includes("chrom");
+var SAFARI_BUG_237906 = SAFARI && (ua.includes("version/15.4") || /cpu (os|iphone os) 15_4 like mac os x/.test(ua));
+var WEBKIT = ua.includes("webkit") && !ua.includes("edge");
+var MAC = ua.includes("macintosh");
+var DEVICE_PIXEL_RATIO = typeof devicePixelRatio !== "undefined" ? devicePixelRatio : 1;
+var WORKER_OFFSCREEN_CANVAS = typeof WorkerGlobalScope !== "undefined" && typeof OffscreenCanvas !== "undefined" && self instanceof WorkerGlobalScope;
+var IMAGE_DECODE = typeof Image !== "undefined" && Image.prototype.decode;
+var PASSIVE_EVENT_LISTENERS = function() {
+  let passive = false;
+  try {
+    const options = Object.defineProperty({}, "passive", {
+      get: function() {
+        passive = true;
+      }
+    });
+    window.addEventListener("_", null, options);
+    window.removeEventListener("_", null, options);
+  } catch (e) {
+  }
+  return passive;
+}();
+
+// node_modules/ol/dom.js
+init_dirname();
+init_buffer();
+init_process();
+function createCanvasContext2D(width, height, canvasPool, settings) {
+  let canvas;
+  if (canvasPool && canvasPool.length) {
+    canvas = /** @type {HTMLCanvasElement} */
+    canvasPool.shift();
+  } else if (WORKER_OFFSCREEN_CANVAS) {
+    canvas = new class extends OffscreenCanvas {
+      constructor() {
+        super(...arguments);
+        __publicField(this, "style", {});
+      }
+    }(width != null ? width : 300, height != null ? height : 150);
+  } else {
+    canvas = document.createElement("canvas");
+  }
+  if (width) {
+    canvas.width = width;
+  }
+  if (height) {
+    canvas.height = height;
+  }
+  return (
+    /** @type {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} */
+    canvas.getContext("2d", settings)
+  );
+}
+var sharedCanvasContext;
+function getSharedCanvasContext2D() {
+  if (!sharedCanvasContext) {
+    sharedCanvasContext = createCanvasContext2D(1, 1);
+  }
+  return sharedCanvasContext;
+}
+function releaseCanvas(context) {
+  const canvas = context.canvas;
+  canvas.width = 1;
+  canvas.height = 1;
+  context.clearRect(0, 0, 1, 1);
+}
+function replaceNode(newNode, oldNode) {
+  const parent = oldNode.parentNode;
+  if (parent) {
+    parent.replaceChild(newNode, oldNode);
+  }
+}
+function removeChildren(node) {
+  while (node.lastChild) {
+    node.lastChild.remove();
+  }
+}
+function replaceChildren(node, children) {
+  const oldChildren = node.childNodes;
+  for (let i = 0; true; ++i) {
+    const oldChild = oldChildren[i];
+    const newChild = children[i];
+    if (!oldChild && !newChild) {
+      break;
+    }
+    if (oldChild === newChild) {
+      continue;
+    }
+    if (!oldChild) {
+      node.appendChild(newChild);
+      continue;
+    }
+    if (!newChild) {
+      node.removeChild(oldChild);
+      --i;
+      continue;
+    }
+    node.insertBefore(newChild, oldChild);
+  }
+}
+function createMockDiv() {
+  const mockedDiv = new Proxy(
+    {
+      /**
+       * @type {Array<HTMLElement>}
+       */
+      childNodes: [],
+      /**
+       * @param {HTMLElement} node html node.
+       * @return {HTMLElement} html node.
+       */
+      appendChild: function(node) {
+        this.childNodes.push(node);
+        return node;
+      },
+      /**
+       * dummy function, as this structure is not supposed to have a parent.
+       */
+      remove: function() {
+      },
+      /**
+       * @param {HTMLElement} node html node.
+       * @return {HTMLElement} html node.
+       */
+      removeChild: function(node) {
+        const index = this.childNodes.indexOf(node);
+        if (index === -1) {
+          throw new Error("Node to remove was not found");
+        }
+        this.childNodes.splice(index, 1);
+        return node;
+      },
+      /**
+       * @param {HTMLElement} newNode new html node.
+       * @param {HTMLElement} referenceNode reference html node.
+       * @return {HTMLElement} new html node.
+       */
+      insertBefore: function(newNode, referenceNode) {
+        const index = this.childNodes.indexOf(referenceNode);
+        if (index === -1) {
+          throw new Error("Reference node not found");
+        }
+        this.childNodes.splice(index, 0, newNode);
+        return newNode;
+      },
+      style: {}
+    },
+    {
+      get(target, prop, receiver) {
+        if (prop === "firstElementChild") {
+          return target.childNodes.length > 0 ? target.childNodes[0] : null;
+        }
+        return Reflect.get(target, prop, receiver);
+      }
+    }
+  );
+  return (
+    /** @type {HTMLDivElement} */
+    /** @type {*} */
+    mockedDiv
+  );
+}
+function isCanvas(obj) {
+  return typeof HTMLCanvasElement !== "undefined" && obj instanceof HTMLCanvasElement || typeof OffscreenCanvas !== "undefined" && obj instanceof OffscreenCanvas;
+}
+
+// node_modules/ol/source/Source.js
+init_dirname();
+init_buffer();
+init_process();
+var Source = class extends Object_default {
+  /**
+   * @param {Options} options Source options.
+   */
+  constructor(options) {
+    var _a;
+    super();
+    this.projection = get3(options.projection);
+    this.attributions_ = adaptAttributions(options.attributions);
+    this.attributionsCollapsible_ = (_a = options.attributionsCollapsible) != null ? _a : true;
+    this.loading = false;
+    this.state_ = options.state !== void 0 ? options.state : "ready";
+    this.wrapX_ = options.wrapX !== void 0 ? options.wrapX : false;
+    this.interpolate_ = !!options.interpolate;
+    this.viewResolver = null;
+    this.viewRejector = null;
+    const self2 = this;
+    this.viewPromise_ = new Promise(function(resolve, reject) {
+      self2.viewResolver = resolve;
+      self2.viewRejector = reject;
+    });
+  }
+  /**
+   * Get the attribution function for the source.
+   * @return {?Attribution} Attribution function.
+   * @api
+   */
+  getAttributions() {
+    return this.attributions_;
+  }
+  /**
+   * @return {boolean} Attributions are collapsible.
+   * @api
+   */
+  getAttributionsCollapsible() {
+    return this.attributionsCollapsible_;
+  }
+  /**
+   * Get the projection of the source.
+   * @return {import("../proj/Projection.js").default|null} Projection.
+   * @api
+   */
+  getProjection() {
+    return this.projection;
+  }
+  /**
+   * @param {import("../proj/Projection").default} [projection] Projection.
+   * @return {Array<number>|null} Resolutions.
+   */
+  getResolutions(projection) {
+    return null;
+  }
+  /**
+   * @return {Promise<import("../View.js").ViewOptions>} A promise for view-related properties.
+   */
+  getView() {
+    return this.viewPromise_;
+  }
+  /**
+   * Get the state of the source, see {@link import("./Source.js").State} for possible states.
+   * @return {import("./Source.js").State} State.
+   * @api
+   */
+  getState() {
+    return this.state_;
+  }
+  /**
+   * @return {boolean|undefined} Wrap X.
+   */
+  getWrapX() {
+    return this.wrapX_;
+  }
+  /**
+   * @return {boolean} Use linear interpolation when resampling.
+   */
+  getInterpolate() {
+    return this.interpolate_;
+  }
+  /**
+   * Refreshes the source. The source will be cleared, and data from the server will be reloaded.
+   * @api
+   */
+  refresh() {
+    this.changed();
+  }
+  /**
+   * Set the attributions of the source.
+   * @param {AttributionLike|undefined} attributions Attributions.
+   *     Can be passed as `string`, `Array<string>`, {@link module:ol/source/Source~Attribution},
+   *     or `undefined`.
+   * @api
+   */
+  setAttributions(attributions) {
+    this.attributions_ = adaptAttributions(attributions);
+    this.changed();
+  }
+  /**
+   * Set the state of the source.
+   * @param {import("./Source.js").State} state State.
+   */
+  setState(state) {
+    this.state_ = state;
+    this.changed();
+  }
+};
+function adaptAttributions(attributionLike) {
+  if (!attributionLike) {
+    return null;
+  }
+  if (typeof attributionLike === "function") {
+    return attributionLike;
+  }
+  if (!Array.isArray(attributionLike)) {
+    attributionLike = [attributionLike];
+  }
+  return (frameState) => attributionLike;
+}
+var Source_default = Source;
+
+// node_modules/ol/size.js
+init_dirname();
+init_buffer();
+init_process();
+function hasArea(size) {
+  return size[0] > 0 && size[1] > 0;
+}
+function scale3(size, ratio, dest) {
+  if (dest === void 0) {
+    dest = [0, 0];
+  }
+  dest[0] = size[0] * ratio + 0.5 | 0;
+  dest[1] = size[1] * ratio + 0.5 | 0;
+  return dest;
+}
+function toSize(size, dest) {
+  if (Array.isArray(size)) {
+    return size;
+  }
+  if (dest === void 0) {
+    dest = [size, size];
+  } else {
+    dest[0] = size;
+    dest[1] = size;
+  }
+  return dest;
+}
+
+// node_modules/ol/easing.js
+init_dirname();
+init_buffer();
+init_process();
+function easeIn(t) {
+  return Math.pow(t, 3);
+}
+function easeOut(t) {
+  return 1 - easeIn(1 - t);
+}
+function inAndOut(t) {
+  return 3 * t * t - 2 * t * t * t;
+}
+function linear(t) {
+  return t;
+}
+
+// node_modules/ol/tilegrid/common.js
+init_dirname();
+init_buffer();
+init_process();
+var DEFAULT_MAX_ZOOM = 42;
+var DEFAULT_TILE_SIZE = 256;
+
+export {
+  ObjectEventType_default,
+  EventType_default,
+  Disposable_default,
+  binarySearch,
+  ascending,
+  descending,
+  linearFindNearest,
+  reverseSubArray,
+  extend2 as extend,
+  equals3 as equals,
+  isSorted,
+  TRUE,
+  FALSE,
+  VOID,
+  memoizeOne,
+  toPromise,
+  clear,
+  isEmpty2 as isEmpty,
+  Event_default,
+  Target_default,
+  listen,
+  listenOnce,
+  unlistenByKey,
+  Observable_default,
+  abstract,
+  getUid,
+  Object_default,
+  assert,
+  Relationship_default,
+  boundingExtent,
+  buffer,
+  clone,
+  closestSquaredDistanceXY,
+  containsCoordinate,
+  containsExtent,
+  containsXY,
+  coordinateRelationship,
+  createEmpty,
+  createOrUpdate,
+  createOrUpdateEmpty,
+  createOrUpdateFromCoordinate,
+  createOrUpdateFromFlatCoordinates,
+  equals as equals2,
+  approximatelyEquals,
+  extend as extend2,
+  extendCoordinate,
+  forEachCorner,
+  getArea,
+  getBottomLeft,
+  getBottomRight,
+  getCenter,
+  getCorner,
+  getForViewAndSize,
+  getRotatedViewport,
+  getHeight,
+  getIntersection,
+  getTopLeft,
+  getTopRight,
+  getWidth,
+  intersects,
+  isEmpty as isEmpty2,
+  returnOrUpdate,
+  applyTransform,
+  wrapX,
+  wrapAndSliceX,
+  clamp,
+  squaredSegmentDistance,
+  squaredDistance,
+  solveLinearSystem,
+  toRadians,
+  modulo,
+  lerp,
+  toFixed,
+  floor,
+  ceil,
+  getLength,
+  warn,
+  error,
+  add,
+  degreesToStringHDMS,
+  equals2 as equals3,
+  rotate,
+  scale,
+  squaredDistance2,
+  distance,
+  wrapX2,
+  angleBetween,
+  fromCode,
+  METERS_PER_UNIT,
+  Projection_default,
+  disableCoordinateWarning,
+  get3 as get,
+  getPointResolution,
+  createProjection,
+  createTransformFromCoordinateTransform,
+  toLonLat2 as toLonLat,
+  equivalent,
+  getTransformFromProjections,
+  getTransform,
+  transform,
+  transformExtent,
+  getUserProjection,
+  toUserCoordinate,
+  fromUserCoordinate,
+  toUserExtent,
+  fromUserExtent,
+  toUserResolution,
+  create,
+  reset,
+  multiply,
+  setFromArray,
+  apply,
+  rotate2,
+  scale2,
+  translate,
+  compose,
+  makeInverse,
+  toString,
+  fromString,
+  equivalent2,
+  linearRingsContainsXY,
+  linearRingssContainsXY,
+  forEach,
+  intersectsLineString,
+  intersectsLineStringArray,
+  intersectsLinearRing,
+  intersectsLinearRingArray,
+  intersectsLinearRingMultiArray,
+  SAFARI_BUG_237906,
+  WEBKIT,
+  MAC,
+  DEVICE_PIXEL_RATIO,
+  WORKER_OFFSCREEN_CANVAS,
+  IMAGE_DECODE,
+  PASSIVE_EVENT_LISTENERS,
+  createCanvasContext2D,
+  getSharedCanvasContext2D,
+  releaseCanvas,
+  replaceNode,
+  removeChildren,
+  replaceChildren,
+  createMockDiv,
+  isCanvas,
+  Source_default,
+  hasArea,
+  scale3,
+  toSize,
+  easeIn,
+  easeOut,
+  inAndOut,
+  linear,
+  DEFAULT_MAX_ZOOM,
+  DEFAULT_TILE_SIZE
+};