@nasa-terra/components 0.0.198 → 0.0.199

package/cdn/chunks/chunk.UUUD46S3.js

@@ -0,0 +1,1862 @@
+import {
+  DEFAULT_MAX_ZOOM,
+  DEFAULT_TILE_SIZE,
+  EventType_default,
+  Event_default,
+  METERS_PER_UNIT,
+  Source_default,
+  Target_default,
+  abstract,
+  apply,
+  assert,
+  boundingExtent,
+  ceil,
+  clamp,
+  containsCoordinate,
+  createCanvasContext2D,
+  createEmpty,
+  createOrUpdate,
+  createTransformFromCoordinateTransform,
+  easeIn,
+  extend2 as extend,
+  extendCoordinate,
+  floor,
+  forEachCorner,
+  get,
+  getArea,
+  getBottomLeft,
+  getBottomRight,
+  getCenter,
+  getCorner,
+  getHeight,
+  getPointResolution,
+  getTopLeft,
+  getTopRight,
+  getTransform,
+  getUid,
+  getWidth,
+  intersects,
+  intersectsLinearRing,
+  isSorted,
+  linearFindNearest,
+  modulo,
+  releaseCanvas,
+  scale3 as scale,
+  solveLinearSystem,
+  toSize,
+  transform
+} from "./chunk.RCPXD7AS.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// 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/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 getCacheKey(source, sourceKey, z, x, y) {
+  return `${getUid(source)},${sourceKey},${getKeyZXY(z, x, y)}`;
+}
+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/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 list of origins for the grid.
+   * @return {Array<import("../coordinate.js").Coordinate>|null} Origin.
+   */
+  getOrigins() {
+    return this.origins_;
+  }
+  /**
+   * 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 scale2 = resolution / this.getResolution(z);
+    const origin = this.getOrigin(z);
+    const tileSize = toSize(this.getTileSize(z), this.tmpSize_);
+    let tileCoordX = scale2 * (x - origin[0]) / resolution / tileSize[0];
+    let tileCoordY = scale2 * (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/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();
+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 self = this;
+    this.loader_().then(function(data) {
+      self.data_ = data;
+      self.state = TileState_default.LOADED;
+      self.changed();
+    }).catch(function(error) {
+      self.error_ = error;
+      self.state = TileState_default.ERROR;
+      self.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 wrapX(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 || get("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 = get(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.
+   * @param {import("../structs/LRUCache.js").default<import("../Tile.js").default>} [tileCache] Tile cache.
+   * @return {TileType|null} Tile.
+   */
+  getTile(z, x, y, pixelRatio, projection, tileCache) {
+    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 scale(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 = wrapX(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/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 {
+  TileState_default,
+  Tile_default,
+  TileRange_default,
+  asImageLike,
+  asArrayLike,
+  toArray,
+  DataTile_default,
+  canvasPool,
+  calculateSourceExtentResolution,
+  render,
+  Triangulation_default,
+  ERROR_THRESHOLD,
+  createOrUpdate3 as createOrUpdate,
+  getKey,
+  getCacheKey,
+  hash,
+  hashZXY,
+  TileGrid_default,
+  getForProjection,
+  createXYZ,
+  extentFromProjection,
+  TileSourceEvent,
+  Tile_default2,
+  TileEventType_default
+};