@nasa-terra/components 0.0.176 → 0.0.178

package/cdn/chunks/chunk.HCVVVZ5J.js

@@ -0,0 +1,4968 @@
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.CZA6CSBG.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, scale5) {
+  coordinate[0] *= scale5;
+  coordinate[1] *= scale5;
+  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;
+}
+
+// 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/tilegrid/TileGrid.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/ol/TileRange.js
+init_dirname();
+init_buffer();
+init_process();
+var TileRange = class {
+  /**
+   * @param {number} minX Minimum X.
+   * @param {number} maxX Maximum X.
+   * @param {number} minY Minimum Y.
+   * @param {number} maxY Maximum Y.
+   */
+  constructor(minX, maxX, minY, maxY) {
+    this.minX = minX;
+    this.maxX = maxX;
+    this.minY = minY;
+    this.maxY = maxY;
+  }
+  /**
+   * @param {import("./tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @return {boolean} Contains tile coordinate.
+   */
+  contains(tileCoord) {
+    return this.containsXY(tileCoord[1], tileCoord[2]);
+  }
+  /**
+   * @param {TileRange} tileRange Tile range.
+   * @return {boolean} Contains.
+   */
+  containsTileRange(tileRange) {
+    return this.minX <= tileRange.minX && tileRange.maxX <= this.maxX && this.minY <= tileRange.minY && tileRange.maxY <= this.maxY;
+  }
+  /**
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @return {boolean} Contains coordinate.
+   */
+  containsXY(x, y) {
+    return this.minX <= x && x <= this.maxX && this.minY <= y && y <= this.maxY;
+  }
+  /**
+   * @param {TileRange} tileRange Tile range.
+   * @return {boolean} Equals.
+   */
+  equals(tileRange) {
+    return this.minX == tileRange.minX && this.minY == tileRange.minY && this.maxX == tileRange.maxX && this.maxY == tileRange.maxY;
+  }
+  /**
+   * @param {TileRange} tileRange Tile range.
+   */
+  extend(tileRange) {
+    if (tileRange.minX < this.minX) {
+      this.minX = tileRange.minX;
+    }
+    if (tileRange.maxX > this.maxX) {
+      this.maxX = tileRange.maxX;
+    }
+    if (tileRange.minY < this.minY) {
+      this.minY = tileRange.minY;
+    }
+    if (tileRange.maxY > this.maxY) {
+      this.maxY = tileRange.maxY;
+    }
+  }
+  /**
+   * @return {number} Height.
+   */
+  getHeight() {
+    return this.maxY - this.minY + 1;
+  }
+  /**
+   * @return {import("./size.js").Size} Size.
+   */
+  getSize() {
+    return [this.getWidth(), this.getHeight()];
+  }
+  /**
+   * @return {number} Width.
+   */
+  getWidth() {
+    return this.maxX - this.minX + 1;
+  }
+  /**
+   * @param {TileRange} tileRange Tile range.
+   * @return {boolean} Intersects.
+   */
+  intersects(tileRange) {
+    return this.minX <= tileRange.maxX && this.maxX >= tileRange.minX && this.minY <= tileRange.maxY && this.maxY >= tileRange.minY;
+  }
+};
+function createOrUpdate2(minX, maxX, minY, maxY, tileRange) {
+  if (tileRange !== void 0) {
+    tileRange.minX = minX;
+    tileRange.maxX = maxX;
+    tileRange.minY = minY;
+    tileRange.maxY = maxY;
+    return tileRange;
+  }
+  return new TileRange(minX, maxX, minY, maxY);
+}
+var TileRange_default = TileRange;
+
+// 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/geom/flat/intersectsextent.js
+init_dirname();
+init_buffer();
+init_process();
+
+// 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/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/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/tilecoord.js
+init_dirname();
+init_buffer();
+init_process();
+function createOrUpdate3(z, x, y, tileCoord) {
+  if (tileCoord !== void 0) {
+    tileCoord[0] = z;
+    tileCoord[1] = x;
+    tileCoord[2] = y;
+    return tileCoord;
+  }
+  return [z, x, y];
+}
+function getKeyZXY(z, x, y) {
+  return z + "/" + x + "/" + y;
+}
+function getKey(tileCoord) {
+  return getKeyZXY(tileCoord[0], tileCoord[1], tileCoord[2]);
+}
+function hash(tileCoord) {
+  return hashZXY(tileCoord[0], tileCoord[1], tileCoord[2]);
+}
+function hashZXY(z, x, y) {
+  return (x << z) + y;
+}
+function withinExtentAndZ(tileCoord, tileGrid) {
+  const z = tileCoord[0];
+  const x = tileCoord[1];
+  const y = tileCoord[2];
+  if (tileGrid.getMinZoom() > z || z > tileGrid.getMaxZoom()) {
+    return false;
+  }
+  const tileRange = tileGrid.getFullTileRange(z);
+  if (!tileRange) {
+    return true;
+  }
+  return tileRange.containsXY(x, y);
+}
+
+// node_modules/ol/tilegrid/common.js
+init_dirname();
+init_buffer();
+init_process();
+var DEFAULT_MAX_ZOOM = 42;
+var DEFAULT_TILE_SIZE = 256;
+
+// node_modules/ol/tilegrid/TileGrid.js
+var tmpTileCoord = [0, 0, 0];
+var DECIMALS = 5;
+var TileGrid = class {
+  /**
+   * @param {Options} options Tile grid options.
+   */
+  constructor(options) {
+    this.minZoom = options.minZoom !== void 0 ? options.minZoom : 0;
+    this.resolutions_ = options.resolutions;
+    assert(
+      isSorted(
+        this.resolutions_,
+        /**
+         * @param {number} a First resolution
+         * @param {number} b Second resolution
+         * @return {number} Comparison result
+         */
+        (a, b) => b - a,
+        true
+      ),
+      "`resolutions` must be sorted in descending order"
+    );
+    let zoomFactor;
+    if (!options.origins) {
+      for (let i = 0, ii = this.resolutions_.length - 1; i < ii; ++i) {
+        if (!zoomFactor) {
+          zoomFactor = this.resolutions_[i] / this.resolutions_[i + 1];
+        } else {
+          if (this.resolutions_[i] / this.resolutions_[i + 1] !== zoomFactor) {
+            zoomFactor = void 0;
+            break;
+          }
+        }
+      }
+    }
+    this.zoomFactor_ = zoomFactor;
+    this.maxZoom = this.resolutions_.length - 1;
+    this.origin_ = options.origin !== void 0 ? options.origin : null;
+    this.origins_ = null;
+    if (options.origins !== void 0) {
+      this.origins_ = options.origins;
+      assert(
+        this.origins_.length == this.resolutions_.length,
+        "Number of `origins` and `resolutions` must be equal"
+      );
+    }
+    const extent = options.extent;
+    if (extent !== void 0 && !this.origin_ && !this.origins_) {
+      this.origin_ = getTopLeft(extent);
+    }
+    assert(
+      !this.origin_ && this.origins_ || this.origin_ && !this.origins_,
+      "Either `origin` or `origins` must be configured, never both"
+    );
+    this.tileSizes_ = null;
+    if (options.tileSizes !== void 0) {
+      this.tileSizes_ = options.tileSizes;
+      assert(
+        this.tileSizes_.length == this.resolutions_.length,
+        "Number of `tileSizes` and `resolutions` must be equal"
+      );
+    }
+    this.tileSize_ = options.tileSize !== void 0 ? options.tileSize : !this.tileSizes_ ? DEFAULT_TILE_SIZE : null;
+    assert(
+      !this.tileSize_ && this.tileSizes_ || this.tileSize_ && !this.tileSizes_,
+      "Either `tileSize` or `tileSizes` must be configured, never both"
+    );
+    this.extent_ = extent !== void 0 ? extent : null;
+    this.fullTileRanges_ = null;
+    this.tmpSize_ = [0, 0];
+    this.tmpExtent_ = [0, 0, 0, 0];
+    if (options.sizes !== void 0) {
+      this.fullTileRanges_ = options.sizes.map((size, z) => {
+        const tileRange = new TileRange_default(
+          Math.min(0, size[0]),
+          Math.max(size[0] - 1, -1),
+          Math.min(0, size[1]),
+          Math.max(size[1] - 1, -1)
+        );
+        if (extent) {
+          const restrictedTileRange = this.getTileRangeForExtentAndZ(extent, z);
+          tileRange.minX = Math.max(restrictedTileRange.minX, tileRange.minX);
+          tileRange.maxX = Math.min(restrictedTileRange.maxX, tileRange.maxX);
+          tileRange.minY = Math.max(restrictedTileRange.minY, tileRange.minY);
+          tileRange.maxY = Math.min(restrictedTileRange.maxY, tileRange.maxY);
+        }
+        return tileRange;
+      });
+    } else if (extent) {
+      this.calculateTileRanges_(extent);
+    }
+  }
+  /**
+   * Call a function with each tile coordinate for a given extent and zoom level.
+   *
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @param {number} zoom Integer zoom level.
+   * @param {function(import("../tilecoord.js").TileCoord): void} callback Function called with each tile coordinate.
+   * @api
+   */
+  forEachTileCoord(extent, zoom, callback) {
+    const tileRange = this.getTileRangeForExtentAndZ(extent, zoom);
+    for (let i = tileRange.minX, ii = tileRange.maxX; i <= ii; ++i) {
+      for (let j = tileRange.minY, jj = tileRange.maxY; j <= jj; ++j) {
+        callback([zoom, i, j]);
+      }
+    }
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {function(number, import("../TileRange.js").default): boolean} callback Callback.
+   * @param {import("../TileRange.js").default} [tempTileRange] Temporary import("../TileRange.js").default object.
+   * @param {import("../extent.js").Extent} [tempExtent] Temporary import("../extent.js").Extent object.
+   * @return {boolean} Callback succeeded.
+   */
+  forEachTileCoordParentTileRange(tileCoord, callback, tempTileRange, tempExtent) {
+    let tileRange, x, y;
+    let tileCoordExtent = null;
+    let z = tileCoord[0] - 1;
+    if (this.zoomFactor_ === 2) {
+      x = tileCoord[1];
+      y = tileCoord[2];
+    } else {
+      tileCoordExtent = this.getTileCoordExtent(tileCoord, tempExtent);
+    }
+    while (z >= this.minZoom) {
+      if (x !== void 0 && y !== void 0) {
+        x = Math.floor(x / 2);
+        y = Math.floor(y / 2);
+        tileRange = createOrUpdate2(x, x, y, y, tempTileRange);
+      } else {
+        tileRange = this.getTileRangeForExtentAndZ(
+          tileCoordExtent,
+          z,
+          tempTileRange
+        );
+      }
+      if (callback(z, tileRange)) {
+        return true;
+      }
+      --z;
+    }
+    return false;
+  }
+  /**
+   * Get the extent for this tile grid, if it was configured.
+   * @return {import("../extent.js").Extent} Extent.
+   * @api
+   */
+  getExtent() {
+    return this.extent_;
+  }
+  /**
+   * Get the maximum zoom level for the grid.
+   * @return {number} Max zoom.
+   * @api
+   */
+  getMaxZoom() {
+    return this.maxZoom;
+  }
+  /**
+   * Get the minimum zoom level for the grid.
+   * @return {number} Min zoom.
+   * @api
+   */
+  getMinZoom() {
+    return this.minZoom;
+  }
+  /**
+   * Get the origin for the grid at the given zoom level.
+   * @param {number} z Integer zoom level.
+   * @return {import("../coordinate.js").Coordinate} Origin.
+   * @api
+   */
+  getOrigin(z) {
+    if (this.origin_) {
+      return this.origin_;
+    }
+    return this.origins_[z];
+  }
+  /**
+   * Get the resolution for the given zoom level.
+   * @param {number} z Integer zoom level.
+   * @return {number} Resolution.
+   * @api
+   */
+  getResolution(z) {
+    return this.resolutions_[z];
+  }
+  /**
+   * Get the list of resolutions for the tile grid.
+   * @return {Array<number>} Resolutions.
+   * @api
+   */
+  getResolutions() {
+    return this.resolutions_;
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {import("../TileRange.js").default} [tempTileRange] Temporary import("../TileRange.js").default object.
+   * @param {import("../extent.js").Extent} [tempExtent] Temporary import("../extent.js").Extent object.
+   * @return {import("../TileRange.js").default|null} Tile range.
+   */
+  getTileCoordChildTileRange(tileCoord, tempTileRange, tempExtent) {
+    if (tileCoord[0] < this.maxZoom) {
+      if (this.zoomFactor_ === 2) {
+        const minX = tileCoord[1] * 2;
+        const minY = tileCoord[2] * 2;
+        return createOrUpdate2(
+          minX,
+          minX + 1,
+          minY,
+          minY + 1,
+          tempTileRange
+        );
+      }
+      const tileCoordExtent = this.getTileCoordExtent(
+        tileCoord,
+        tempExtent || this.tmpExtent_
+      );
+      return this.getTileRangeForExtentAndZ(
+        tileCoordExtent,
+        tileCoord[0] + 1,
+        tempTileRange
+      );
+    }
+    return null;
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {number} z Integer zoom level.
+   * @param {import("../TileRange.js").default} [tempTileRange] Temporary import("../TileRange.js").default object.
+   * @return {import("../TileRange.js").default|null} Tile range.
+   */
+  getTileRangeForTileCoordAndZ(tileCoord, z, tempTileRange) {
+    if (z > this.maxZoom || z < this.minZoom) {
+      return null;
+    }
+    const tileCoordZ = tileCoord[0];
+    const tileCoordX = tileCoord[1];
+    const tileCoordY = tileCoord[2];
+    if (z === tileCoordZ) {
+      return createOrUpdate2(
+        tileCoordX,
+        tileCoordY,
+        tileCoordX,
+        tileCoordY,
+        tempTileRange
+      );
+    }
+    if (this.zoomFactor_) {
+      const factor = Math.pow(this.zoomFactor_, z - tileCoordZ);
+      const minX = Math.floor(tileCoordX * factor);
+      const minY = Math.floor(tileCoordY * factor);
+      if (z < tileCoordZ) {
+        return createOrUpdate2(minX, minX, minY, minY, tempTileRange);
+      }
+      const maxX = Math.floor(factor * (tileCoordX + 1)) - 1;
+      const maxY = Math.floor(factor * (tileCoordY + 1)) - 1;
+      return createOrUpdate2(minX, maxX, minY, maxY, tempTileRange);
+    }
+    const tileCoordExtent = this.getTileCoordExtent(tileCoord, this.tmpExtent_);
+    return this.getTileRangeForExtentAndZ(tileCoordExtent, z, tempTileRange);
+  }
+  /**
+   * Get a tile range for the given extent and integer zoom level.
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @param {number} z Integer zoom level.
+   * @param {import("../TileRange.js").default} [tempTileRange] Temporary tile range object.
+   * @return {import("../TileRange.js").default} Tile range.
+   */
+  getTileRangeForExtentAndZ(extent, z, tempTileRange) {
+    this.getTileCoordForXYAndZ_(extent[0], extent[3], z, false, tmpTileCoord);
+    const minX = tmpTileCoord[1];
+    const minY = tmpTileCoord[2];
+    this.getTileCoordForXYAndZ_(extent[2], extent[1], z, true, tmpTileCoord);
+    const maxX = tmpTileCoord[1];
+    const maxY = tmpTileCoord[2];
+    return createOrUpdate2(minX, maxX, minY, maxY, tempTileRange);
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @return {import("../coordinate.js").Coordinate} Tile center.
+   */
+  getTileCoordCenter(tileCoord) {
+    const origin = this.getOrigin(tileCoord[0]);
+    const resolution = this.getResolution(tileCoord[0]);
+    const tileSize = toSize(this.getTileSize(tileCoord[0]), this.tmpSize_);
+    return [
+      origin[0] + (tileCoord[1] + 0.5) * tileSize[0] * resolution,
+      origin[1] - (tileCoord[2] + 0.5) * tileSize[1] * resolution
+    ];
+  }
+  /**
+   * Get the extent of a tile coordinate.
+   *
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {import("../extent.js").Extent} [tempExtent] Temporary extent object.
+   * @return {import("../extent.js").Extent} Extent.
+   * @api
+   */
+  getTileCoordExtent(tileCoord, tempExtent) {
+    const origin = this.getOrigin(tileCoord[0]);
+    const resolution = this.getResolution(tileCoord[0]);
+    const tileSize = toSize(this.getTileSize(tileCoord[0]), this.tmpSize_);
+    const minX = origin[0] + tileCoord[1] * tileSize[0] * resolution;
+    const minY = origin[1] - (tileCoord[2] + 1) * tileSize[1] * resolution;
+    const maxX = minX + tileSize[0] * resolution;
+    const maxY = minY + tileSize[1] * resolution;
+    return createOrUpdate(minX, minY, maxX, maxY, tempExtent);
+  }
+  /**
+   * Get the tile coordinate for the given map coordinate and resolution.  This
+   * method considers that coordinates that intersect tile boundaries should be
+   * assigned the higher tile coordinate.
+   *
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {number} resolution Resolution.
+   * @param {import("../tilecoord.js").TileCoord} [opt_tileCoord] Destination import("../tilecoord.js").TileCoord object.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate.
+   * @api
+   */
+  getTileCoordForCoordAndResolution(coordinate, resolution, opt_tileCoord) {
+    return this.getTileCoordForXYAndResolution_(
+      coordinate[0],
+      coordinate[1],
+      resolution,
+      false,
+      opt_tileCoord
+    );
+  }
+  /**
+   * Note that this method should not be called for resolutions that correspond
+   * to an integer zoom level.  Instead call the `getTileCoordForXYAndZ_` method.
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @param {number} resolution Resolution (for a non-integer zoom level).
+   * @param {boolean} reverseIntersectionPolicy Instead of letting edge
+   *     intersections go to the higher tile coordinate, let edge intersections
+   *     go to the lower tile coordinate.
+   * @param {import("../tilecoord.js").TileCoord} [opt_tileCoord] Temporary import("../tilecoord.js").TileCoord object.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate.
+   * @private
+   */
+  getTileCoordForXYAndResolution_(x, y, resolution, reverseIntersectionPolicy, opt_tileCoord) {
+    const z = this.getZForResolution(resolution);
+    const scale5 = resolution / this.getResolution(z);
+    const origin = this.getOrigin(z);
+    const tileSize = toSize(this.getTileSize(z), this.tmpSize_);
+    let tileCoordX = scale5 * (x - origin[0]) / resolution / tileSize[0];
+    let tileCoordY = scale5 * (origin[1] - y) / resolution / tileSize[1];
+    if (reverseIntersectionPolicy) {
+      tileCoordX = ceil(tileCoordX, DECIMALS) - 1;
+      tileCoordY = ceil(tileCoordY, DECIMALS) - 1;
+    } else {
+      tileCoordX = floor(tileCoordX, DECIMALS);
+      tileCoordY = floor(tileCoordY, DECIMALS);
+    }
+    return createOrUpdate3(z, tileCoordX, tileCoordY, opt_tileCoord);
+  }
+  /**
+   * Although there is repetition between this method and `getTileCoordForXYAndResolution_`,
+   * they should have separate implementations.  This method is for integer zoom
+   * levels.  The other method should only be called for resolutions corresponding
+   * to non-integer zoom levels.
+   * @param {number} x Map x coordinate.
+   * @param {number} y Map y coordinate.
+   * @param {number} z Integer zoom level.
+   * @param {boolean} reverseIntersectionPolicy Instead of letting edge
+   *     intersections go to the higher tile coordinate, let edge intersections
+   *     go to the lower tile coordinate.
+   * @param {import("../tilecoord.js").TileCoord} [opt_tileCoord] Temporary import("../tilecoord.js").TileCoord object.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate.
+   * @private
+   */
+  getTileCoordForXYAndZ_(x, y, z, reverseIntersectionPolicy, opt_tileCoord) {
+    const origin = this.getOrigin(z);
+    const resolution = this.getResolution(z);
+    const tileSize = toSize(this.getTileSize(z), this.tmpSize_);
+    let tileCoordX = (x - origin[0]) / resolution / tileSize[0];
+    let tileCoordY = (origin[1] - y) / resolution / tileSize[1];
+    if (reverseIntersectionPolicy) {
+      tileCoordX = ceil(tileCoordX, DECIMALS) - 1;
+      tileCoordY = ceil(tileCoordY, DECIMALS) - 1;
+    } else {
+      tileCoordX = floor(tileCoordX, DECIMALS);
+      tileCoordY = floor(tileCoordY, DECIMALS);
+    }
+    return createOrUpdate3(z, tileCoordX, tileCoordY, opt_tileCoord);
+  }
+  /**
+   * Get a tile coordinate given a map coordinate and zoom level.
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {number} z Integer zoom level, e.g. the result of a `getZForResolution()` method call
+   * @param {import("../tilecoord.js").TileCoord} [opt_tileCoord] Destination import("../tilecoord.js").TileCoord object.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate.
+   * @api
+   */
+  getTileCoordForCoordAndZ(coordinate, z, opt_tileCoord) {
+    return this.getTileCoordForXYAndZ_(
+      coordinate[0],
+      coordinate[1],
+      z,
+      false,
+      opt_tileCoord
+    );
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @return {number} Tile resolution.
+   */
+  getTileCoordResolution(tileCoord) {
+    return this.resolutions_[tileCoord[0]];
+  }
+  /**
+   * Get the tile size for a zoom level. The type of the return value matches the
+   * `tileSize` or `tileSizes` that the tile grid was configured with. To always
+   * get an {@link import("../size.js").Size}, run the result through {@link module:ol/size.toSize}.
+   * @param {number} z Z.
+   * @return {number|import("../size.js").Size} Tile size.
+   * @api
+   */
+  getTileSize(z) {
+    if (this.tileSize_) {
+      return this.tileSize_;
+    }
+    return this.tileSizes_[z];
+  }
+  /**
+   * @param {number} z Zoom level.
+   * @return {import("../TileRange.js").default|null} Extent tile range for the specified zoom level.
+   */
+  getFullTileRange(z) {
+    if (!this.fullTileRanges_) {
+      return this.extent_ ? this.getTileRangeForExtentAndZ(this.extent_, z) : null;
+    }
+    return this.fullTileRanges_[z];
+  }
+  /**
+   * @param {number} resolution Resolution.
+   * @param {number|import("../array.js").NearestDirectionFunction} [opt_direction]
+   *     If 0, the nearest resolution will be used.
+   *     If 1, the nearest higher resolution (lower Z) will be used. If -1, the
+   *     nearest lower resolution (higher Z) will be used. Default is 0.
+   *     Use a {@link module:ol/array~NearestDirectionFunction} for more precise control.
+   *
+   * For example to change tile Z at the midpoint of zoom levels
+   * ```js
+   * function(value, high, low) {
+   *   return value - low * Math.sqrt(high / low);
+   * }
+   * ```
+   * @return {number} Z.
+   * @api
+   */
+  getZForResolution(resolution, opt_direction) {
+    const z = linearFindNearest(
+      this.resolutions_,
+      resolution,
+      opt_direction || 0
+    );
+    return clamp(z, this.minZoom, this.maxZoom);
+  }
+  /**
+   * The tile with the provided tile coordinate intersects the given viewport.
+   * @param {import('../tilecoord.js').TileCoord} tileCoord Tile coordinate.
+   * @param {Array<number>} viewport Viewport as returned from {@link module:ol/extent.getRotatedViewport}.
+   * @return {boolean} The tile with the provided tile coordinate intersects the given viewport.
+   */
+  tileCoordIntersectsViewport(tileCoord, viewport) {
+    return intersectsLinearRing(
+      viewport,
+      0,
+      viewport.length,
+      2,
+      this.getTileCoordExtent(tileCoord)
+    );
+  }
+  /**
+   * @param {!import("../extent.js").Extent} extent Extent for this tile grid.
+   * @private
+   */
+  calculateTileRanges_(extent) {
+    const length = this.resolutions_.length;
+    const fullTileRanges = new Array(length);
+    for (let z = this.minZoom; z < length; ++z) {
+      fullTileRanges[z] = this.getTileRangeForExtentAndZ(extent, z);
+    }
+    this.fullTileRanges_ = fullTileRanges;
+  }
+};
+var TileGrid_default = TileGrid;
+
+// 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/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 {Object<string, *>} [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 {Object<string, *>} Object.
+   * @api
+   */
+  getProperties() {
+    return this.values_ && Object.assign({}, this.values_) || {};
+  }
+  /**
+   * Get an object of all property names and values.
+   * @return {Object<string, *>?} 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 {Object<string, *>} 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/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/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/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/TileState.js
+init_dirname();
+init_buffer();
+init_process();
+var TileState_default = {
+  IDLE: 0,
+  LOADING: 1,
+  LOADED: 2,
+  /**
+   * Indicates that tile loading failed
+   * @type {number}
+   */
+  ERROR: 3,
+  EMPTY: 4
+};
+
+// node_modules/ol/Tile.js
+init_dirname();
+init_buffer();
+init_process();
+var Tile = class extends Target_default {
+  /**
+   * @param {import("./tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {import("./TileState.js").default} state State.
+   * @param {Options} [options] Tile options.
+   */
+  constructor(tileCoord, state, options) {
+    super();
+    options = options ? options : {};
+    this.tileCoord = tileCoord;
+    this.state = state;
+    this.key = "";
+    this.transition_ = options.transition === void 0 ? 250 : options.transition;
+    this.transitionStarts_ = {};
+    this.interpolate = !!options.interpolate;
+  }
+  /**
+   * @protected
+   */
+  changed() {
+    this.dispatchEvent(EventType_default.CHANGE);
+  }
+  /**
+   * Called by the tile cache when the tile is removed from the cache due to expiry
+   */
+  release() {
+    this.setState(TileState_default.EMPTY);
+  }
+  /**
+   * @return {string} Key.
+   */
+  getKey() {
+    return this.key + "/" + this.tileCoord;
+  }
+  /**
+   * Get the tile coordinate for this tile.
+   * @return {import("./tilecoord.js").TileCoord} The tile coordinate.
+   * @api
+   */
+  getTileCoord() {
+    return this.tileCoord;
+  }
+  /**
+   * @return {import("./TileState.js").default} State.
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Sets the state of this tile. If you write your own {@link module:ol/Tile~LoadFunction tileLoadFunction} ,
+   * it is important to set the state correctly to {@link module:ol/TileState~ERROR}
+   * when the tile cannot be loaded. Otherwise the tile cannot be removed from
+   * the tile queue and will block other requests.
+   * @param {import("./TileState.js").default} state State.
+   * @api
+   */
+  setState(state) {
+    if (this.state === TileState_default.EMPTY) {
+      return;
+    }
+    if (this.state !== TileState_default.ERROR && this.state > state) {
+      throw new Error("Tile load sequence violation");
+    }
+    this.state = state;
+    this.changed();
+  }
+  /**
+   * Load the image or retry if loading previously failed.
+   * Loading is taken care of by the tile queue, and calling this method is
+   * only needed for preloading or for reloading in case of an error.
+   * @abstract
+   * @api
+   */
+  load() {
+    abstract();
+  }
+  /**
+   * Get the alpha value for rendering.
+   * @param {string} id An id for the renderer.
+   * @param {number} time The render frame time.
+   * @return {number} A number between 0 and 1.
+   */
+  getAlpha(id, time) {
+    if (!this.transition_) {
+      return 1;
+    }
+    let start = this.transitionStarts_[id];
+    if (!start) {
+      start = time;
+      this.transitionStarts_[id] = start;
+    } else if (start === -1) {
+      return 1;
+    }
+    const delta = time - start + 1e3 / 60;
+    if (delta >= this.transition_) {
+      return 1;
+    }
+    return easeIn(delta / this.transition_);
+  }
+  /**
+   * Determine if a tile is in an alpha transition.  A tile is considered in
+   * transition if tile.getAlpha() has not yet been called or has been called
+   * and returned 1.
+   * @param {string} id An id for the renderer.
+   * @return {boolean} The tile is in transition.
+   */
+  inTransition(id) {
+    if (!this.transition_) {
+      return false;
+    }
+    return this.transitionStarts_[id] !== -1;
+  }
+  /**
+   * Mark a transition as complete.
+   * @param {string} id An id for the renderer.
+   */
+  endTransition(id) {
+    if (this.transition_) {
+      this.transitionStarts_[id] = -1;
+    }
+  }
+  /**
+   * @override
+   */
+  disposeInternal() {
+    this.release();
+    super.disposeInternal();
+  }
+};
+var Tile_default = Tile;
+
+// node_modules/ol/DataTile.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/ol/dom.js
+init_dirname();
+init_buffer();
+init_process();
+function createCanvasContext2D(width, height, canvasPool2, settings) {
+  let canvas;
+  if (canvasPool2 && canvasPool2.length) {
+    canvas = /** @type {HTMLCanvasElement} */
+    canvasPool2.shift();
+  } else if (WORKER_OFFSCREEN_CANVAS) {
+    canvas = new OffscreenCanvas(width || 300, height || 300);
+  } else {
+    canvas = document.createElement("canvas");
+  }
+  if (width) {
+    canvas.width = width;
+  }
+  if (height) {
+    canvas.height = height;
+  }
+  return (
+    /** @type {CanvasRenderingContext2D} */
+    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);
+  }
+}
+
+// node_modules/ol/DataTile.js
+function asImageLike(data) {
+  return data instanceof Image || data instanceof HTMLCanvasElement || data instanceof HTMLVideoElement || data instanceof ImageBitmap ? data : null;
+}
+function asArrayLike(data) {
+  return data instanceof Uint8Array || data instanceof Uint8ClampedArray || data instanceof Float32Array || data instanceof DataView ? data : null;
+}
+var disposedError = new Error("disposed");
+var sharedContext = null;
+function toArray(image) {
+  if (!sharedContext) {
+    sharedContext = createCanvasContext2D(
+      image.width,
+      image.height,
+      void 0,
+      { willReadFrequently: true }
+    );
+  }
+  const canvas = sharedContext.canvas;
+  const width = image.width;
+  if (canvas.width !== width) {
+    canvas.width = width;
+  }
+  const height = image.height;
+  if (canvas.height !== height) {
+    canvas.height = height;
+  }
+  sharedContext.clearRect(0, 0, width, height);
+  sharedContext.drawImage(image, 0, 0);
+  return sharedContext.getImageData(0, 0, width, height).data;
+}
+var defaultSize = [256, 256];
+var DataTile = class extends Tile_default {
+  /**
+   * @param {Options} options Tile options.
+   */
+  constructor(options) {
+    const state = TileState_default.IDLE;
+    super(options.tileCoord, state, {
+      transition: options.transition,
+      interpolate: options.interpolate
+    });
+    this.loader_ = options.loader;
+    this.data_ = null;
+    this.error_ = null;
+    this.size_ = options.size || null;
+    this.controller_ = options.controller || null;
+  }
+  /**
+   * Get the tile size.
+   * @return {import('./size.js').Size} Tile size.
+   */
+  getSize() {
+    if (this.size_) {
+      return this.size_;
+    }
+    const imageData = asImageLike(this.data_);
+    if (imageData) {
+      return [imageData.width, imageData.height];
+    }
+    return defaultSize;
+  }
+  /**
+   * Get the data for the tile.
+   * @return {Data} Tile data.
+   * @api
+   */
+  getData() {
+    return this.data_;
+  }
+  /**
+   * Get any loading error.
+   * @return {Error} Loading error.
+   * @api
+   */
+  getError() {
+    return this.error_;
+  }
+  /**
+   * Load the tile data.
+   * @api
+   * @override
+   */
+  load() {
+    if (this.state !== TileState_default.IDLE && this.state !== TileState_default.ERROR) {
+      return;
+    }
+    this.state = TileState_default.LOADING;
+    this.changed();
+    const self2 = this;
+    this.loader_().then(function(data) {
+      self2.data_ = data;
+      self2.state = TileState_default.LOADED;
+      self2.changed();
+    }).catch(function(error2) {
+      self2.error_ = error2;
+      self2.state = TileState_default.ERROR;
+      self2.changed();
+    });
+  }
+  /**
+   * Clean up.
+   * @override
+   */
+  disposeInternal() {
+    if (this.controller_) {
+      this.controller_.abort(disposedError);
+      this.controller_ = null;
+    }
+    super.disposeInternal();
+  }
+};
+var DataTile_default = DataTile;
+
+// node_modules/ol/tilegrid.js
+init_dirname();
+init_buffer();
+init_process();
+function getForProjection(projection) {
+  let tileGrid = projection.getDefaultTileGrid();
+  if (!tileGrid) {
+    tileGrid = createForProjection(projection);
+    projection.setDefaultTileGrid(tileGrid);
+  }
+  return tileGrid;
+}
+function wrapX3(tileGrid, tileCoord, projection) {
+  const z = tileCoord[0];
+  const center = tileGrid.getTileCoordCenter(tileCoord);
+  const projectionExtent = extentFromProjection(projection);
+  if (!containsCoordinate(projectionExtent, center)) {
+    const worldWidth = getWidth(projectionExtent);
+    const worldsAway = Math.ceil(
+      (projectionExtent[0] - center[0]) / worldWidth
+    );
+    center[0] += worldWidth * worldsAway;
+    return tileGrid.getTileCoordForCoordAndZ(center, z);
+  }
+  return tileCoord;
+}
+function createForExtent(extent, maxZoom, tileSize, corner) {
+  corner = corner !== void 0 ? corner : "top-left";
+  const resolutions = resolutionsFromExtent(extent, maxZoom, tileSize);
+  return new TileGrid_default({
+    extent,
+    origin: getCorner(extent, corner),
+    resolutions,
+    tileSize
+  });
+}
+function createXYZ(options) {
+  const xyzOptions = options || {};
+  const extent = xyzOptions.extent || get3("EPSG:3857").getExtent();
+  const gridOptions = {
+    extent,
+    minZoom: xyzOptions.minZoom,
+    tileSize: xyzOptions.tileSize,
+    resolutions: resolutionsFromExtent(
+      extent,
+      xyzOptions.maxZoom,
+      xyzOptions.tileSize,
+      xyzOptions.maxResolution
+    )
+  };
+  return new TileGrid_default(gridOptions);
+}
+function resolutionsFromExtent(extent, maxZoom, tileSize, maxResolution) {
+  maxZoom = maxZoom !== void 0 ? maxZoom : DEFAULT_MAX_ZOOM;
+  tileSize = toSize(tileSize !== void 0 ? tileSize : DEFAULT_TILE_SIZE);
+  const height = getHeight(extent);
+  const width = getWidth(extent);
+  maxResolution = maxResolution > 0 ? maxResolution : Math.max(width / tileSize[0], height / tileSize[1]);
+  const length = maxZoom + 1;
+  const resolutions = new Array(length);
+  for (let z = 0; z < length; ++z) {
+    resolutions[z] = maxResolution / Math.pow(2, z);
+  }
+  return resolutions;
+}
+function createForProjection(projection, maxZoom, tileSize, corner) {
+  const extent = extentFromProjection(projection);
+  return createForExtent(extent, maxZoom, tileSize, corner);
+}
+function extentFromProjection(projection) {
+  projection = get3(projection);
+  let extent = projection.getExtent();
+  if (!extent) {
+    const half = 180 * METERS_PER_UNIT.degrees / projection.getMetersPerUnit();
+    extent = createOrUpdate(-half, -half, half, half);
+  }
+  return extent;
+}
+
+// node_modules/ol/source/Tile.js
+init_dirname();
+init_buffer();
+init_process();
+var TileSource = class extends Source_default {
+  /**
+   * @param {Options} options SourceTile source options.
+   */
+  constructor(options) {
+    super({
+      attributions: options.attributions,
+      attributionsCollapsible: options.attributionsCollapsible,
+      projection: options.projection,
+      state: options.state,
+      wrapX: options.wrapX,
+      interpolate: options.interpolate
+    });
+    this.on;
+    this.once;
+    this.un;
+    this.tilePixelRatio_ = options.tilePixelRatio !== void 0 ? options.tilePixelRatio : 1;
+    this.tileGrid = options.tileGrid !== void 0 ? options.tileGrid : null;
+    const tileSize = [256, 256];
+    if (this.tileGrid) {
+      toSize(this.tileGrid.getTileSize(this.tileGrid.getMinZoom()), tileSize);
+    }
+    this.tmpSize = [0, 0];
+    this.key_ = options.key || getUid(this);
+    this.tileOptions = {
+      transition: options.transition,
+      interpolate: options.interpolate
+    };
+    this.zDirection = options.zDirection ? options.zDirection : 0;
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {number} Gutter.
+   */
+  getGutterForProjection(projection) {
+    return 0;
+  }
+  /**
+   * Return the key to be used for all tiles in the source.
+   * @return {string} The key for all tiles.
+   */
+  getKey() {
+    return this.key_;
+  }
+  /**
+   * Set the value to be used as the key for all tiles in the source.
+   * @param {string} key The key for tiles.
+   * @protected
+   */
+  setKey(key) {
+    if (this.key_ !== key) {
+      this.key_ = key;
+      this.changed();
+    }
+  }
+  /**
+   * @param {import("../proj/Projection").default} [projection] Projection.
+   * @return {Array<number>|null} Resolutions.
+   * @override
+   */
+  getResolutions(projection) {
+    const tileGrid = projection ? this.getTileGridForProjection(projection) : this.tileGrid;
+    if (!tileGrid) {
+      return null;
+    }
+    return tileGrid.getResolutions();
+  }
+  /**
+   * @abstract
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {TileType|null} Tile.
+   */
+  getTile(z, x, y, pixelRatio, projection) {
+    return abstract();
+  }
+  /**
+   * Return the tile grid of the tile source.
+   * @return {import("../tilegrid/TileGrid.js").default|null} Tile grid.
+   * @api
+   */
+  getTileGrid() {
+    return this.tileGrid;
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {!import("../tilegrid/TileGrid.js").default} Tile grid.
+   */
+  getTileGridForProjection(projection) {
+    if (!this.tileGrid) {
+      return getForProjection(projection);
+    }
+    return this.tileGrid;
+  }
+  /**
+   * Get the tile pixel ratio for this source. Subclasses may override this
+   * method, which is meant to return a supported pixel ratio that matches the
+   * provided `pixelRatio` as close as possible.
+   * @param {number} pixelRatio Pixel ratio.
+   * @return {number} Tile pixel ratio.
+   */
+  getTilePixelRatio(pixelRatio) {
+    return this.tilePixelRatio_;
+  }
+  /**
+   * @param {number} z Z.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {import("../size.js").Size} Tile size.
+   */
+  getTilePixelSize(z, pixelRatio, projection) {
+    const tileGrid = this.getTileGridForProjection(projection);
+    const tilePixelRatio = this.getTilePixelRatio(pixelRatio);
+    const tileSize = toSize(tileGrid.getTileSize(z), this.tmpSize);
+    if (tilePixelRatio == 1) {
+      return tileSize;
+    }
+    return scale3(tileSize, tilePixelRatio, this.tmpSize);
+  }
+  /**
+   * Returns a tile coordinate wrapped around the x-axis. When the tile coordinate
+   * is outside the resolution and extent range of the tile grid, `null` will be
+   * returned.
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {import("../proj/Projection.js").default} [projection] Projection.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate to be passed to the tileUrlFunction or
+   *     null if no tile URL should be created for the passed `tileCoord`.
+   */
+  getTileCoordForTileUrlFunction(tileCoord, projection) {
+    const gridProjection = projection !== void 0 ? projection : this.getProjection();
+    const tileGrid = projection !== void 0 ? this.getTileGridForProjection(gridProjection) : this.tileGrid || this.getTileGridForProjection(gridProjection);
+    if (this.getWrapX() && gridProjection.isGlobal()) {
+      tileCoord = wrapX3(tileGrid, tileCoord, gridProjection);
+    }
+    return withinExtentAndZ(tileCoord, tileGrid) ? tileCoord : null;
+  }
+  /**
+   * Remove all cached reprojected tiles from the source. The next render cycle will create new tiles.
+   * @api
+   */
+  clear() {
+  }
+  /**
+   * @override
+   */
+  refresh() {
+    this.clear();
+    super.refresh();
+  }
+};
+var TileSourceEvent = class extends Event_default {
+  /**
+   * @param {string} type Type.
+   * @param {import("../Tile.js").default} tile The tile.
+   */
+  constructor(type, tile) {
+    super(type);
+    this.tile = tile;
+  }
+};
+var Tile_default2 = TileSource;
+
+// node_modules/ol/source/TileEventType.js
+init_dirname();
+init_buffer();
+init_process();
+var TileEventType_default = {
+  /**
+   * Triggered when a tile starts loading.
+   * @event module:ol/source/Tile.TileSourceEvent#tileloadstart
+   * @api
+   */
+  TILELOADSTART: "tileloadstart",
+  /**
+   * Triggered when a tile finishes loading, either when its data is loaded,
+   * or when loading was aborted because the tile is no longer needed.
+   * @event module:ol/source/Tile.TileSourceEvent#tileloadend
+   * @api
+   */
+  TILELOADEND: "tileloadend",
+  /**
+   * Triggered if tile loading results in an error. Note that this is not the
+   * right place to re-fetch tiles. See {@link module:ol/ImageTile~ImageTile#load}
+   * for details.
+   * @event module:ol/source/Tile.TileSourceEvent#tileloaderror
+   * @api
+   */
+  TILELOADERROR: "tileloaderror"
+};
+
+// node_modules/ol/vec/mat4.js
+init_dirname();
+init_buffer();
+init_process();
+function create2() {
+  return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+}
+function fromTransform(mat4, transform2) {
+  mat4[0] = transform2[0];
+  mat4[1] = transform2[1];
+  mat4[4] = transform2[2];
+  mat4[5] = transform2[3];
+  mat4[12] = transform2[4];
+  mat4[13] = transform2[5];
+  return mat4;
+}
+function orthographic(left, right, bottom, top, near, far, out) {
+  out = out != null ? out : create2();
+  const lr = 1 / (left - right), bt = 1 / (bottom - top), nf = 1 / (near - far);
+  out[0] = -2 * lr;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = -2 * bt;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = 2 * nf;
+  out[11] = 0;
+  out[12] = (left + right) * lr;
+  out[13] = (top + bottom) * bt;
+  out[14] = (far + near) * nf;
+  out[15] = 1;
+  return out;
+}
+function scale4(m, x, y, z, out) {
+  out = out != null ? out : create2();
+  out[0] = m[0] * x;
+  out[1] = m[1] * x;
+  out[2] = m[2] * x;
+  out[3] = m[3] * x;
+  out[4] = m[4] * y;
+  out[5] = m[5] * y;
+  out[6] = m[6] * y;
+  out[7] = m[7] * y;
+  out[8] = m[8] * z;
+  out[9] = m[9] * z;
+  out[10] = m[10] * z;
+  out[11] = m[11] * z;
+  out[12] = m[12];
+  out[13] = m[13];
+  out[14] = m[14];
+  out[15] = m[15];
+  return out;
+}
+function translate2(m, x, y, z, out) {
+  out = out != null ? out : create2();
+  let a00, a01, a02, a03, a10, a11, a12, a13, a20, a21, a22, a23;
+  if (m === out) {
+    out[12] = m[0] * x + m[4] * y + m[8] * z + m[12];
+    out[13] = m[1] * x + m[5] * y + m[9] * z + m[13];
+    out[14] = m[2] * x + m[6] * y + m[10] * z + m[14];
+    out[15] = m[3] * x + m[7] * y + m[11] * z + m[15];
+  } else {
+    a00 = m[0];
+    a01 = m[1];
+    a02 = m[2];
+    a03 = m[3];
+    a10 = m[4];
+    a11 = m[5];
+    a12 = m[6];
+    a13 = m[7];
+    a20 = m[8];
+    a21 = m[9];
+    a22 = m[10];
+    a23 = m[11];
+    out[0] = a00;
+    out[1] = a01;
+    out[2] = a02;
+    out[3] = a03;
+    out[4] = a10;
+    out[5] = a11;
+    out[6] = a12;
+    out[7] = a13;
+    out[8] = a20;
+    out[9] = a21;
+    out[10] = a22;
+    out[11] = a23;
+    out[12] = a00 * x + a10 * y + a20 * z + m[12];
+    out[13] = a01 * x + a11 * y + a21 * z + m[13];
+    out[14] = a02 * x + a12 * y + a22 * z + m[14];
+    out[15] = a03 * x + a13 * y + a23 * z + m[15];
+  }
+  return out;
+}
+function translation(x, y, z, out) {
+  out = out != null ? out : create2();
+  out[0] = 1;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = 1;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = 1;
+  out[11] = 0;
+  out[12] = x;
+  out[13] = y;
+  out[14] = z;
+  out[15] = 1;
+  return out;
+}
+
+// node_modules/ol/reproj.js
+init_dirname();
+init_buffer();
+init_process();
+var brokenDiagonalRendering_;
+var canvasPool = [];
+function drawTestTriangle(ctx, u1, v1, u2, v2) {
+  ctx.beginPath();
+  ctx.moveTo(0, 0);
+  ctx.lineTo(u1, v1);
+  ctx.lineTo(u2, v2);
+  ctx.closePath();
+  ctx.save();
+  ctx.clip();
+  ctx.fillRect(0, 0, Math.max(u1, u2) + 1, Math.max(v1, v2));
+  ctx.restore();
+}
+function verifyBrokenDiagonalRendering(data, offset) {
+  return Math.abs(data[offset * 4] - 210) > 2 || Math.abs(data[offset * 4 + 3] - 0.75 * 255) > 2;
+}
+function isBrokenDiagonalRendering() {
+  if (brokenDiagonalRendering_ === void 0) {
+    const ctx = createCanvasContext2D(6, 6, canvasPool);
+    ctx.globalCompositeOperation = "lighter";
+    ctx.fillStyle = "rgba(210, 0, 0, 0.75)";
+    drawTestTriangle(ctx, 4, 5, 4, 0);
+    drawTestTriangle(ctx, 4, 5, 0, 5);
+    const data = ctx.getImageData(0, 0, 3, 3).data;
+    brokenDiagonalRendering_ = verifyBrokenDiagonalRendering(data, 0) || verifyBrokenDiagonalRendering(data, 4) || verifyBrokenDiagonalRendering(data, 8);
+    releaseCanvas(ctx);
+    canvasPool.push(ctx.canvas);
+  }
+  return brokenDiagonalRendering_;
+}
+function calculateSourceResolution(sourceProj, targetProj, targetCenter, targetResolution) {
+  const sourceCenter = transform(targetCenter, targetProj, sourceProj);
+  let sourceResolution = getPointResolution(
+    targetProj,
+    targetResolution,
+    targetCenter
+  );
+  const targetMetersPerUnit = targetProj.getMetersPerUnit();
+  if (targetMetersPerUnit !== void 0) {
+    sourceResolution *= targetMetersPerUnit;
+  }
+  const sourceMetersPerUnit = sourceProj.getMetersPerUnit();
+  if (sourceMetersPerUnit !== void 0) {
+    sourceResolution /= sourceMetersPerUnit;
+  }
+  const sourceExtent = sourceProj.getExtent();
+  if (!sourceExtent || containsCoordinate(sourceExtent, sourceCenter)) {
+    const compensationFactor = getPointResolution(sourceProj, sourceResolution, sourceCenter) / sourceResolution;
+    if (isFinite(compensationFactor) && compensationFactor > 0) {
+      sourceResolution /= compensationFactor;
+    }
+  }
+  return sourceResolution;
+}
+function calculateSourceExtentResolution(sourceProj, targetProj, targetExtent, targetResolution) {
+  const targetCenter = getCenter(targetExtent);
+  let sourceResolution = calculateSourceResolution(
+    sourceProj,
+    targetProj,
+    targetCenter,
+    targetResolution
+  );
+  if (!isFinite(sourceResolution) || sourceResolution <= 0) {
+    forEachCorner(targetExtent, function(corner) {
+      sourceResolution = calculateSourceResolution(
+        sourceProj,
+        targetProj,
+        corner,
+        targetResolution
+      );
+      return isFinite(sourceResolution) && sourceResolution > 0;
+    });
+  }
+  return sourceResolution;
+}
+function render(width, height, pixelRatio, sourceResolution, sourceExtent, targetResolution, targetExtent, triangulation, sources, gutter, renderEdges, interpolate, drawSingle, clipExtent) {
+  const context = createCanvasContext2D(
+    Math.round(pixelRatio * width),
+    Math.round(pixelRatio * height),
+    canvasPool
+  );
+  if (!interpolate) {
+    context.imageSmoothingEnabled = false;
+  }
+  if (sources.length === 0) {
+    return context.canvas;
+  }
+  context.scale(pixelRatio, pixelRatio);
+  function pixelRound(value) {
+    return Math.round(value * pixelRatio) / pixelRatio;
+  }
+  context.globalCompositeOperation = "lighter";
+  const sourceDataExtent = createEmpty();
+  sources.forEach(function(src, i, arr) {
+    extend(sourceDataExtent, src.extent);
+  });
+  let stitchContext;
+  const stitchScale = pixelRatio / sourceResolution;
+  const inverseScale = (interpolate ? 1 : 1 + Math.pow(2, -24)) / stitchScale;
+  if (!drawSingle || sources.length !== 1 || gutter !== 0) {
+    stitchContext = createCanvasContext2D(
+      Math.round(getWidth(sourceDataExtent) * stitchScale),
+      Math.round(getHeight(sourceDataExtent) * stitchScale),
+      canvasPool
+    );
+    if (!interpolate) {
+      stitchContext.imageSmoothingEnabled = false;
+    }
+    if (sourceExtent && clipExtent) {
+      const xPos = (sourceExtent[0] - sourceDataExtent[0]) * stitchScale;
+      const yPos = -(sourceExtent[3] - sourceDataExtent[3]) * stitchScale;
+      const width2 = getWidth(sourceExtent) * stitchScale;
+      const height2 = getHeight(sourceExtent) * stitchScale;
+      stitchContext.rect(xPos, yPos, width2, height2);
+      stitchContext.clip();
+    }
+    sources.forEach(function(src, i, arr) {
+      if (src.image.width > 0 && src.image.height > 0) {
+        if (src.clipExtent) {
+          stitchContext.save();
+          const xPos2 = (src.clipExtent[0] - sourceDataExtent[0]) * stitchScale;
+          const yPos2 = -(src.clipExtent[3] - sourceDataExtent[3]) * stitchScale;
+          const width2 = getWidth(src.clipExtent) * stitchScale;
+          const height2 = getHeight(src.clipExtent) * stitchScale;
+          stitchContext.rect(
+            interpolate ? xPos2 : Math.round(xPos2),
+            interpolate ? yPos2 : Math.round(yPos2),
+            interpolate ? width2 : Math.round(xPos2 + width2) - Math.round(xPos2),
+            interpolate ? height2 : Math.round(yPos2 + height2) - Math.round(yPos2)
+          );
+          stitchContext.clip();
+        }
+        const xPos = (src.extent[0] - sourceDataExtent[0]) * stitchScale;
+        const yPos = -(src.extent[3] - sourceDataExtent[3]) * stitchScale;
+        const srcWidth = getWidth(src.extent) * stitchScale;
+        const srcHeight = getHeight(src.extent) * stitchScale;
+        stitchContext.drawImage(
+          src.image,
+          gutter,
+          gutter,
+          src.image.width - 2 * gutter,
+          src.image.height - 2 * gutter,
+          interpolate ? xPos : Math.round(xPos),
+          interpolate ? yPos : Math.round(yPos),
+          interpolate ? srcWidth : Math.round(xPos + srcWidth) - Math.round(xPos),
+          interpolate ? srcHeight : Math.round(yPos + srcHeight) - Math.round(yPos)
+        );
+        if (src.clipExtent) {
+          stitchContext.restore();
+        }
+      }
+    });
+  }
+  const targetTopLeft = getTopLeft(targetExtent);
+  triangulation.getTriangles().forEach(function(triangle, i, arr) {
+    const source = triangle.source;
+    const target = triangle.target;
+    let x0 = source[0][0], y0 = source[0][1];
+    let x1 = source[1][0], y1 = source[1][1];
+    let x2 = source[2][0], y2 = source[2][1];
+    const u0 = pixelRound((target[0][0] - targetTopLeft[0]) / targetResolution);
+    const v0 = pixelRound(
+      -(target[0][1] - targetTopLeft[1]) / targetResolution
+    );
+    const u1 = pixelRound((target[1][0] - targetTopLeft[0]) / targetResolution);
+    const v1 = pixelRound(
+      -(target[1][1] - targetTopLeft[1]) / targetResolution
+    );
+    const u2 = pixelRound((target[2][0] - targetTopLeft[0]) / targetResolution);
+    const v2 = pixelRound(
+      -(target[2][1] - targetTopLeft[1]) / targetResolution
+    );
+    const sourceNumericalShiftX = x0;
+    const sourceNumericalShiftY = y0;
+    x0 = 0;
+    y0 = 0;
+    x1 -= sourceNumericalShiftX;
+    y1 -= sourceNumericalShiftY;
+    x2 -= sourceNumericalShiftX;
+    y2 -= sourceNumericalShiftY;
+    const augmentedMatrix = [
+      [x1, y1, 0, 0, u1 - u0],
+      [x2, y2, 0, 0, u2 - u0],
+      [0, 0, x1, y1, v1 - v0],
+      [0, 0, x2, y2, v2 - v0]
+    ];
+    const affineCoefs = solveLinearSystem(augmentedMatrix);
+    if (!affineCoefs) {
+      return;
+    }
+    context.save();
+    context.beginPath();
+    if (isBrokenDiagonalRendering() || !interpolate) {
+      context.moveTo(u1, v1);
+      const steps = 4;
+      const ud = u0 - u1;
+      const vd = v0 - v1;
+      for (let step = 0; step < steps; step++) {
+        context.lineTo(
+          u1 + pixelRound((step + 1) * ud / steps),
+          v1 + pixelRound(step * vd / (steps - 1))
+        );
+        if (step != steps - 1) {
+          context.lineTo(
+            u1 + pixelRound((step + 1) * ud / steps),
+            v1 + pixelRound((step + 1) * vd / (steps - 1))
+          );
+        }
+      }
+      context.lineTo(u2, v2);
+    } else {
+      context.moveTo(u1, v1);
+      context.lineTo(u0, v0);
+      context.lineTo(u2, v2);
+    }
+    context.clip();
+    context.transform(
+      affineCoefs[0],
+      affineCoefs[2],
+      affineCoefs[1],
+      affineCoefs[3],
+      u0,
+      v0
+    );
+    context.translate(
+      sourceDataExtent[0] - sourceNumericalShiftX,
+      sourceDataExtent[3] - sourceNumericalShiftY
+    );
+    let image;
+    if (stitchContext) {
+      image = stitchContext.canvas;
+      context.scale(inverseScale, -inverseScale);
+    } else {
+      const source2 = sources[0];
+      const extent = source2.extent;
+      image = source2.image;
+      context.scale(
+        getWidth(extent) / image.width,
+        -getHeight(extent) / image.height
+      );
+    }
+    context.drawImage(image, 0, 0);
+    context.restore();
+  });
+  if (stitchContext) {
+    releaseCanvas(stitchContext);
+    canvasPool.push(stitchContext.canvas);
+  }
+  if (renderEdges) {
+    context.save();
+    context.globalCompositeOperation = "source-over";
+    context.strokeStyle = "black";
+    context.lineWidth = 1;
+    triangulation.getTriangles().forEach(function(triangle, i, arr) {
+      const target = triangle.target;
+      const u0 = (target[0][0] - targetTopLeft[0]) / targetResolution;
+      const v0 = -(target[0][1] - targetTopLeft[1]) / targetResolution;
+      const u1 = (target[1][0] - targetTopLeft[0]) / targetResolution;
+      const v1 = -(target[1][1] - targetTopLeft[1]) / targetResolution;
+      const u2 = (target[2][0] - targetTopLeft[0]) / targetResolution;
+      const v2 = -(target[2][1] - targetTopLeft[1]) / targetResolution;
+      context.beginPath();
+      context.moveTo(u1, v1);
+      context.lineTo(u0, v0);
+      context.lineTo(u2, v2);
+      context.closePath();
+      context.stroke();
+    });
+    context.restore();
+  }
+  return context.canvas;
+}
+
+// node_modules/ol/reproj/Triangulation.js
+init_dirname();
+init_buffer();
+init_process();
+var MAX_SUBDIVISION = 10;
+var MAX_TRIANGLE_WIDTH = 0.25;
+var Triangulation = class {
+  /**
+   * @param {import("../proj/Projection.js").default} sourceProj Source projection.
+   * @param {import("../proj/Projection.js").default} targetProj Target projection.
+   * @param {import("../extent.js").Extent} targetExtent Target extent to triangulate.
+   * @param {import("../extent.js").Extent} maxSourceExtent Maximal source extent that can be used.
+   * @param {number} errorThreshold Acceptable error (in source units).
+   * @param {?number} destinationResolution The (optional) resolution of the destination.
+   * @param {import("../transform.js").Transform} [sourceMatrix] Source transform matrix.
+   */
+  constructor(sourceProj, targetProj, targetExtent, maxSourceExtent, errorThreshold, destinationResolution, sourceMatrix) {
+    this.sourceProj_ = sourceProj;
+    this.targetProj_ = targetProj;
+    let transformInvCache = {};
+    const transformInv = sourceMatrix ? createTransformFromCoordinateTransform(
+      (input) => apply(
+        sourceMatrix,
+        transform(input, this.targetProj_, this.sourceProj_)
+      )
+    ) : getTransform(this.targetProj_, this.sourceProj_);
+    this.transformInv_ = function(c) {
+      const key = c[0] + "/" + c[1];
+      if (!transformInvCache[key]) {
+        transformInvCache[key] = transformInv(c);
+      }
+      return transformInvCache[key];
+    };
+    this.maxSourceExtent_ = maxSourceExtent;
+    this.errorThresholdSquared_ = errorThreshold * errorThreshold;
+    this.triangles_ = [];
+    this.wrapsXInSource_ = false;
+    this.canWrapXInSource_ = this.sourceProj_.canWrapX() && !!maxSourceExtent && !!this.sourceProj_.getExtent() && getWidth(maxSourceExtent) >= getWidth(this.sourceProj_.getExtent());
+    this.sourceWorldWidth_ = this.sourceProj_.getExtent() ? getWidth(this.sourceProj_.getExtent()) : null;
+    this.targetWorldWidth_ = this.targetProj_.getExtent() ? getWidth(this.targetProj_.getExtent()) : null;
+    const destinationTopLeft = getTopLeft(targetExtent);
+    const destinationTopRight = getTopRight(targetExtent);
+    const destinationBottomRight = getBottomRight(targetExtent);
+    const destinationBottomLeft = getBottomLeft(targetExtent);
+    const sourceTopLeft = this.transformInv_(destinationTopLeft);
+    const sourceTopRight = this.transformInv_(destinationTopRight);
+    const sourceBottomRight = this.transformInv_(destinationBottomRight);
+    const sourceBottomLeft = this.transformInv_(destinationBottomLeft);
+    const maxSubdivision = MAX_SUBDIVISION + (destinationResolution ? Math.max(
+      0,
+      Math.ceil(
+        Math.log2(
+          getArea(targetExtent) / (destinationResolution * destinationResolution * 256 * 256)
+        )
+      )
+    ) : 0);
+    this.addQuad_(
+      destinationTopLeft,
+      destinationTopRight,
+      destinationBottomRight,
+      destinationBottomLeft,
+      sourceTopLeft,
+      sourceTopRight,
+      sourceBottomRight,
+      sourceBottomLeft,
+      maxSubdivision
+    );
+    if (this.wrapsXInSource_) {
+      let leftBound = Infinity;
+      this.triangles_.forEach(function(triangle, i, arr) {
+        leftBound = Math.min(
+          leftBound,
+          triangle.source[0][0],
+          triangle.source[1][0],
+          triangle.source[2][0]
+        );
+      });
+      this.triangles_.forEach((triangle) => {
+        if (Math.max(
+          triangle.source[0][0],
+          triangle.source[1][0],
+          triangle.source[2][0]
+        ) - leftBound > this.sourceWorldWidth_ / 2) {
+          const newTriangle = [
+            [triangle.source[0][0], triangle.source[0][1]],
+            [triangle.source[1][0], triangle.source[1][1]],
+            [triangle.source[2][0], triangle.source[2][1]]
+          ];
+          if (newTriangle[0][0] - leftBound > this.sourceWorldWidth_ / 2) {
+            newTriangle[0][0] -= this.sourceWorldWidth_;
+          }
+          if (newTriangle[1][0] - leftBound > this.sourceWorldWidth_ / 2) {
+            newTriangle[1][0] -= this.sourceWorldWidth_;
+          }
+          if (newTriangle[2][0] - leftBound > this.sourceWorldWidth_ / 2) {
+            newTriangle[2][0] -= this.sourceWorldWidth_;
+          }
+          const minX = Math.min(
+            newTriangle[0][0],
+            newTriangle[1][0],
+            newTriangle[2][0]
+          );
+          const maxX = Math.max(
+            newTriangle[0][0],
+            newTriangle[1][0],
+            newTriangle[2][0]
+          );
+          if (maxX - minX < this.sourceWorldWidth_ / 2) {
+            triangle.source = newTriangle;
+          }
+        }
+      });
+    }
+    transformInvCache = {};
+  }
+  /**
+   * Adds triangle to the triangulation.
+   * @param {import("../coordinate.js").Coordinate} a The target a coordinate.
+   * @param {import("../coordinate.js").Coordinate} b The target b coordinate.
+   * @param {import("../coordinate.js").Coordinate} c The target c coordinate.
+   * @param {import("../coordinate.js").Coordinate} aSrc The source a coordinate.
+   * @param {import("../coordinate.js").Coordinate} bSrc The source b coordinate.
+   * @param {import("../coordinate.js").Coordinate} cSrc The source c coordinate.
+   * @private
+   */
+  addTriangle_(a, b, c, aSrc, bSrc, cSrc) {
+    this.triangles_.push({
+      source: [aSrc, bSrc, cSrc],
+      target: [a, b, c]
+    });
+  }
+  /**
+   * Adds quad (points in clock-wise order) to the triangulation
+   * (and reprojects the vertices) if valid.
+   * Performs quad subdivision if needed to increase precision.
+   *
+   * @param {import("../coordinate.js").Coordinate} a The target a coordinate.
+   * @param {import("../coordinate.js").Coordinate} b The target b coordinate.
+   * @param {import("../coordinate.js").Coordinate} c The target c coordinate.
+   * @param {import("../coordinate.js").Coordinate} d The target d coordinate.
+   * @param {import("../coordinate.js").Coordinate} aSrc The source a coordinate.
+   * @param {import("../coordinate.js").Coordinate} bSrc The source b coordinate.
+   * @param {import("../coordinate.js").Coordinate} cSrc The source c coordinate.
+   * @param {import("../coordinate.js").Coordinate} dSrc The source d coordinate.
+   * @param {number} maxSubdivision Maximal allowed subdivision of the quad.
+   * @private
+   */
+  addQuad_(a, b, c, d, aSrc, bSrc, cSrc, dSrc, maxSubdivision) {
+    const sourceQuadExtent = boundingExtent([aSrc, bSrc, cSrc, dSrc]);
+    const sourceCoverageX = this.sourceWorldWidth_ ? getWidth(sourceQuadExtent) / this.sourceWorldWidth_ : null;
+    const sourceWorldWidth = (
+      /** @type {number} */
+      this.sourceWorldWidth_
+    );
+    const wrapsX = this.sourceProj_.canWrapX() && sourceCoverageX > 0.5 && sourceCoverageX < 1;
+    let needsSubdivision = false;
+    if (maxSubdivision > 0) {
+      if (this.targetProj_.isGlobal() && this.targetWorldWidth_) {
+        const targetQuadExtent = boundingExtent([a, b, c, d]);
+        const targetCoverageX = getWidth(targetQuadExtent) / this.targetWorldWidth_;
+        needsSubdivision = targetCoverageX > MAX_TRIANGLE_WIDTH || needsSubdivision;
+      }
+      if (!wrapsX && this.sourceProj_.isGlobal() && sourceCoverageX) {
+        needsSubdivision = sourceCoverageX > MAX_TRIANGLE_WIDTH || needsSubdivision;
+      }
+    }
+    if (!needsSubdivision && this.maxSourceExtent_) {
+      if (isFinite(sourceQuadExtent[0]) && isFinite(sourceQuadExtent[1]) && isFinite(sourceQuadExtent[2]) && isFinite(sourceQuadExtent[3])) {
+        if (!intersects(sourceQuadExtent, this.maxSourceExtent_)) {
+          return;
+        }
+      }
+    }
+    let isNotFinite = 0;
+    if (!needsSubdivision) {
+      if (!isFinite(aSrc[0]) || !isFinite(aSrc[1]) || !isFinite(bSrc[0]) || !isFinite(bSrc[1]) || !isFinite(cSrc[0]) || !isFinite(cSrc[1]) || !isFinite(dSrc[0]) || !isFinite(dSrc[1])) {
+        if (maxSubdivision > 0) {
+          needsSubdivision = true;
+        } else {
+          isNotFinite = (!isFinite(aSrc[0]) || !isFinite(aSrc[1]) ? 8 : 0) + (!isFinite(bSrc[0]) || !isFinite(bSrc[1]) ? 4 : 0) + (!isFinite(cSrc[0]) || !isFinite(cSrc[1]) ? 2 : 0) + (!isFinite(dSrc[0]) || !isFinite(dSrc[1]) ? 1 : 0);
+          if (isNotFinite != 1 && isNotFinite != 2 && isNotFinite != 4 && isNotFinite != 8) {
+            return;
+          }
+        }
+      }
+    }
+    if (maxSubdivision > 0) {
+      if (!needsSubdivision) {
+        const center = [(a[0] + c[0]) / 2, (a[1] + c[1]) / 2];
+        const centerSrc = this.transformInv_(center);
+        let dx;
+        if (wrapsX) {
+          const centerSrcEstimX = (modulo(aSrc[0], sourceWorldWidth) + modulo(cSrc[0], sourceWorldWidth)) / 2;
+          dx = centerSrcEstimX - modulo(centerSrc[0], sourceWorldWidth);
+        } else {
+          dx = (aSrc[0] + cSrc[0]) / 2 - centerSrc[0];
+        }
+        const dy = (aSrc[1] + cSrc[1]) / 2 - centerSrc[1];
+        const centerSrcErrorSquared = dx * dx + dy * dy;
+        needsSubdivision = centerSrcErrorSquared > this.errorThresholdSquared_;
+      }
+      if (needsSubdivision) {
+        if (Math.abs(a[0] - c[0]) <= Math.abs(a[1] - c[1])) {
+          const bc = [(b[0] + c[0]) / 2, (b[1] + c[1]) / 2];
+          const bcSrc = this.transformInv_(bc);
+          const da = [(d[0] + a[0]) / 2, (d[1] + a[1]) / 2];
+          const daSrc = this.transformInv_(da);
+          this.addQuad_(
+            a,
+            b,
+            bc,
+            da,
+            aSrc,
+            bSrc,
+            bcSrc,
+            daSrc,
+            maxSubdivision - 1
+          );
+          this.addQuad_(
+            da,
+            bc,
+            c,
+            d,
+            daSrc,
+            bcSrc,
+            cSrc,
+            dSrc,
+            maxSubdivision - 1
+          );
+        } else {
+          const ab = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+          const abSrc = this.transformInv_(ab);
+          const cd = [(c[0] + d[0]) / 2, (c[1] + d[1]) / 2];
+          const cdSrc = this.transformInv_(cd);
+          this.addQuad_(
+            a,
+            ab,
+            cd,
+            d,
+            aSrc,
+            abSrc,
+            cdSrc,
+            dSrc,
+            maxSubdivision - 1
+          );
+          this.addQuad_(
+            ab,
+            b,
+            c,
+            cd,
+            abSrc,
+            bSrc,
+            cSrc,
+            cdSrc,
+            maxSubdivision - 1
+          );
+        }
+        return;
+      }
+    }
+    if (wrapsX) {
+      if (!this.canWrapXInSource_) {
+        return;
+      }
+      this.wrapsXInSource_ = true;
+    }
+    if ((isNotFinite & 11) == 0) {
+      this.addTriangle_(a, c, d, aSrc, cSrc, dSrc);
+    }
+    if ((isNotFinite & 14) == 0) {
+      this.addTriangle_(a, c, b, aSrc, cSrc, bSrc);
+    }
+    if (isNotFinite) {
+      if ((isNotFinite & 13) == 0) {
+        this.addTriangle_(b, d, a, bSrc, dSrc, aSrc);
+      }
+      if ((isNotFinite & 7) == 0) {
+        this.addTriangle_(b, d, c, bSrc, dSrc, cSrc);
+      }
+    }
+  }
+  /**
+   * Calculates extent of the `source` coordinates from all the triangles.
+   *
+   * @return {import("../extent.js").Extent} Calculated extent.
+   */
+  calculateSourceExtent() {
+    const extent = createEmpty();
+    this.triangles_.forEach(function(triangle, i, arr) {
+      const src = triangle.source;
+      extendCoordinate(extent, src[0]);
+      extendCoordinate(extent, src[1]);
+      extendCoordinate(extent, src[2]);
+    });
+    return extent;
+  }
+  /**
+   * @return {Array<Triangle>} Array of the calculated triangles.
+   */
+  getTriangles() {
+    return this.triangles_;
+  }
+};
+var Triangulation_default = Triangulation;
+
+// node_modules/ol/reproj/common.js
+init_dirname();
+init_buffer();
+init_process();
+var ERROR_THRESHOLD = 0.5;
+
+export {
+  ObjectEventType_default,
+  EventType_default,
+  Disposable_default,
+  binarySearch,
+  ascending,
+  descending,
+  linearFindNearest,
+  reverseSubArray,
+  extend2 as extend,
+  equals3 as equals,
+  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,
+  getForViewAndSize,
+  getRotatedViewport,
+  getHeight,
+  getIntersection,
+  getTopLeft,
+  getTopRight,
+  getWidth,
+  intersects,
+  isEmpty as isEmpty2,
+  returnOrUpdate,
+  applyTransform,
+  wrapX,
+  wrapAndSliceX,
+  clamp,
+  squaredSegmentDistance,
+  squaredDistance,
+  toRadians,
+  modulo,
+  lerp,
+  toFixed,
+  getLength,
+  warn,
+  error,
+  add,
+  degreesToStringHDMS,
+  equals2 as equals3,
+  rotate,
+  scale,
+  squaredDistance2,
+  distance,
+  wrapX2,
+  fromCode,
+  METERS_PER_UNIT,
+  Projection_default,
+  disableCoordinateWarning,
+  get3 as get,
+  createProjection,
+  createTransformFromCoordinateTransform,
+  toLonLat2 as toLonLat,
+  equivalent,
+  getTransformFromProjections,
+  getTransform,
+  transformExtent,
+  getUserProjection,
+  toUserCoordinate,
+  fromUserCoordinate,
+  toUserExtent,
+  fromUserExtent,
+  toUserResolution,
+  create,
+  reset,
+  multiply,
+  setFromArray,
+  apply,
+  rotate2,
+  scale2,
+  translate,
+  compose,
+  makeInverse,
+  toString,
+  equivalent2,
+  linearRingsContainsXY,
+  linearRingssContainsXY,
+  forEach,
+  intersectsLineString,
+  intersectsLineStringArray,
+  intersectsLinearRingArray,
+  intersectsLinearRingMultiArray,
+  SAFARI_BUG_237906,
+  WEBKIT,
+  MAC,
+  DEVICE_PIXEL_RATIO,
+  WORKER_OFFSCREEN_CANVAS,
+  IMAGE_DECODE,
+  PASSIVE_EVENT_LISTENERS,
+  createCanvasContext2D,
+  getSharedCanvasContext2D,
+  releaseCanvas,
+  replaceNode,
+  removeChildren,
+  replaceChildren,
+  Source_default,
+  hasArea,
+  toSize,
+  easeOut,
+  inAndOut,
+  linear,
+  DEFAULT_TILE_SIZE,
+  TileState_default,
+  Tile_default,
+  TileRange_default,
+  create2,
+  fromTransform,
+  orthographic,
+  scale4 as scale3,
+  translate2,
+  translation,
+  asImageLike,
+  asArrayLike,
+  toArray,
+  DataTile_default,
+  canvasPool,
+  calculateSourceExtentResolution,
+  render,
+  Triangulation_default,
+  ERROR_THRESHOLD,
+  createOrUpdate3 as createOrUpdate2,
+  getKey,
+  hash,
+  TileGrid_default,
+  getForProjection,
+  createXYZ,
+  extentFromProjection,
+  TileSourceEvent,
+  Tile_default2,
+  TileEventType_default
+};