@nasa-terra/components 0.0.175 → 0.0.177

package/cdn/chunks/chunk.P4PYSONI.js

@@ -1,1985 +0,0 @@
-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 scale3 = resolution / this.getResolution(z);
-    const origin = this.getOrigin(z);
-    const tileSize = toSize(this.getTileSize(z), this.tmpSize_);
-    let tileCoordX = scale3 * (x - origin[0]) / resolution / tileSize[0];
-    let tileCoordY = scale3 * (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/vec/mat4.js
-init_dirname();
-init_buffer();
-init_process();
-function create() {
-  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 : create();
-  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 scale2(m, x, y, z, out) {
-  out = out != null ? out : create();
-  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 translate(m, x, y, z, out) {
-  out = out != null ? out : create();
-  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 : create();
-  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 {
-  TileState_default,
-  Tile_default,
-  TileRange_default,
-  create,
-  fromTransform,
-  orthographic,
-  scale2 as scale,
-  translate,
-  translation,
-  asImageLike,
-  asArrayLike,
-  toArray,
-  DataTile_default,
-  canvasPool,
-  calculateSourceExtentResolution,
-  render,
-  Triangulation_default,
-  ERROR_THRESHOLD,
-  createOrUpdate3 as createOrUpdate,
-  getKey,
-  getCacheKey,
-  hash,
-  TileGrid_default,
-  getForProjection,
-  createXYZ,
-  extentFromProjection,
-  TileSourceEvent,
-  Tile_default2,
-  TileEventType_default
-};