map-2d-base 1.0.0

package/dist/chunks/index-snoDp5kN.js

@@ -0,0 +1,1216 @@
+var __pow = Math.pow;
+import { t as toRadians, w as wrap, g as toDegrees, m as modulo } from "./math-CtjJ8U9C.js";
+const Relationship = {
+  UNKNOWN: 0,
+  INTERSECTING: 1,
+  ABOVE: 2,
+  RIGHT: 4,
+  BELOW: 8,
+  LEFT: 16
+};
+function boundingExtent(coordinates) {
+  const extent = createEmpty();
+  for (let i = 0, ii = coordinates.length; i < ii; ++i) {
+    extendCoordinate(extent, coordinates[i]);
+  }
+  return extent;
+}
+function buffer(extent, value, dest) {
+  if (dest) {
+    dest[0] = extent[0] - value;
+    dest[1] = extent[1] - value;
+    dest[2] = extent[2] + value;
+    dest[3] = extent[3] + value;
+    return dest;
+  }
+  return [
+    extent[0] - value,
+    extent[1] - value,
+    extent[2] + value,
+    extent[3] + value
+  ];
+}
+function clone(extent, dest) {
+  if (dest) {
+    dest[0] = extent[0];
+    dest[1] = extent[1];
+    dest[2] = extent[2];
+    dest[3] = extent[3];
+    return dest;
+  }
+  return extent.slice();
+}
+function closestSquaredDistanceXY(extent, x, y) {
+  let dx, dy;
+  if (x < extent[0]) {
+    dx = extent[0] - x;
+  } else if (extent[2] < x) {
+    dx = x - extent[2];
+  } else {
+    dx = 0;
+  }
+  if (y < extent[1]) {
+    dy = extent[1] - y;
+  } else if (extent[3] < y) {
+    dy = y - extent[3];
+  } else {
+    dy = 0;
+  }
+  return dx * dx + dy * dy;
+}
+function containsCoordinate(extent, coordinate) {
+  return containsXY(extent, coordinate[0], coordinate[1]);
+}
+function containsExtent(extent1, extent2) {
+  return extent1[0] <= extent2[0] && extent2[2] <= extent1[2] && extent1[1] <= extent2[1] && extent2[3] <= extent1[3];
+}
+function containsXY(extent, x, y) {
+  return extent[0] <= x && x <= extent[2] && extent[1] <= y && y <= extent[3];
+}
+function coordinateRelationship(extent, coordinate) {
+  const minX = extent[0];
+  const minY = extent[1];
+  const maxX = extent[2];
+  const maxY = extent[3];
+  const x = coordinate[0];
+  const y = coordinate[1];
+  let relationship = Relationship.UNKNOWN;
+  if (x < minX) {
+    relationship = relationship | Relationship.LEFT;
+  } else if (x > maxX) {
+    relationship = relationship | Relationship.RIGHT;
+  }
+  if (y < minY) {
+    relationship = relationship | Relationship.BELOW;
+  } else if (y > maxY) {
+    relationship = relationship | Relationship.ABOVE;
+  }
+  if (relationship === Relationship.UNKNOWN) {
+    relationship = Relationship.INTERSECTING;
+  }
+  return relationship;
+}
+function createEmpty() {
+  return [Infinity, Infinity, -Infinity, -Infinity];
+}
+function createOrUpdate(minX, minY, maxX, maxY, dest) {
+  if (dest) {
+    dest[0] = minX;
+    dest[1] = minY;
+    dest[2] = maxX;
+    dest[3] = maxY;
+    return dest;
+  }
+  return [minX, minY, maxX, maxY];
+}
+function createOrUpdateEmpty(dest) {
+  return createOrUpdate(Infinity, Infinity, -Infinity, -Infinity, dest);
+}
+function createOrUpdateFromCoordinate(coordinate, dest) {
+  const x = coordinate[0];
+  const y = coordinate[1];
+  return createOrUpdate(x, y, x, y, dest);
+}
+function createOrUpdateFromFlatCoordinates(flatCoordinates, offset, end, stride, dest) {
+  const extent = createOrUpdateEmpty(dest);
+  return extendFlatCoordinates(extent, flatCoordinates, offset, end, stride);
+}
+function equals$1(extent1, extent2) {
+  return extent1[0] == extent2[0] && extent1[2] == extent2[2] && extent1[1] == extent2[1] && extent1[3] == extent2[3];
+}
+function extend(extent1, extent2) {
+  if (extent2[0] < extent1[0]) {
+    extent1[0] = extent2[0];
+  }
+  if (extent2[2] > extent1[2]) {
+    extent1[2] = extent2[2];
+  }
+  if (extent2[1] < extent1[1]) {
+    extent1[1] = extent2[1];
+  }
+  if (extent2[3] > extent1[3]) {
+    extent1[3] = extent2[3];
+  }
+  return extent1;
+}
+function extendCoordinate(extent, coordinate) {
+  if (coordinate[0] < extent[0]) {
+    extent[0] = coordinate[0];
+  }
+  if (coordinate[0] > extent[2]) {
+    extent[2] = coordinate[0];
+  }
+  if (coordinate[1] < extent[1]) {
+    extent[1] = coordinate[1];
+  }
+  if (coordinate[1] > extent[3]) {
+    extent[3] = coordinate[1];
+  }
+}
+function extendFlatCoordinates(extent, flatCoordinates, offset, end, stride) {
+  for (; offset < end; offset += stride) {
+    extendXY(extent, flatCoordinates[offset], flatCoordinates[offset + 1]);
+  }
+  return extent;
+}
+function extendXY(extent, x, y) {
+  extent[0] = Math.min(extent[0], x);
+  extent[1] = Math.min(extent[1], y);
+  extent[2] = Math.max(extent[2], x);
+  extent[3] = Math.max(extent[3], y);
+}
+function forEachCorner(extent, callback) {
+  let val;
+  val = callback(getBottomLeft(extent));
+  if (val) {
+    return val;
+  }
+  val = callback(getBottomRight(extent));
+  if (val) {
+    return val;
+  }
+  val = callback(getTopRight(extent));
+  if (val) {
+    return val;
+  }
+  val = callback(getTopLeft(extent));
+  if (val) {
+    return val;
+  }
+  return false;
+}
+function getArea(extent) {
+  let area = 0;
+  if (!isEmpty(extent)) {
+    area = getWidth(extent) * getHeight(extent);
+  }
+  return area;
+}
+function getBottomLeft(extent) {
+  return [extent[0], extent[1]];
+}
+function getBottomRight(extent) {
+  return [extent[2], extent[1]];
+}
+function getCenter(extent) {
+  return [(extent[0] + extent[2]) / 2, (extent[1] + extent[3]) / 2];
+}
+function getCorner(extent, corner) {
+  let coordinate;
+  if (corner === "bottom-left") {
+    coordinate = getBottomLeft(extent);
+  } else if (corner === "bottom-right") {
+    coordinate = getBottomRight(extent);
+  } else if (corner === "top-left") {
+    coordinate = getTopLeft(extent);
+  } else if (corner === "top-right") {
+    coordinate = getTopRight(extent);
+  } else {
+    throw new Error("Invalid corner");
+  }
+  return coordinate;
+}
+function getForViewAndSize(center, resolution, rotation, size, dest) {
+  const [x0, y0, x1, y1, x2, y2, x3, y3] = getRotatedViewport(
+    center,
+    resolution,
+    rotation,
+    size
+  );
+  return createOrUpdate(
+    Math.min(x0, x1, x2, x3),
+    Math.min(y0, y1, y2, y3),
+    Math.max(x0, x1, x2, x3),
+    Math.max(y0, y1, y2, y3),
+    dest
+  );
+}
+function getRotatedViewport(center, resolution, rotation, size) {
+  const dx = resolution * size[0] / 2;
+  const dy = resolution * size[1] / 2;
+  const cosRotation = Math.cos(rotation);
+  const sinRotation = Math.sin(rotation);
+  const xCos = dx * cosRotation;
+  const xSin = dx * sinRotation;
+  const yCos = dy * cosRotation;
+  const ySin = dy * sinRotation;
+  const x = center[0];
+  const y = center[1];
+  return [
+    x - xCos + ySin,
+    y - xSin - yCos,
+    x - xCos - ySin,
+    y - xSin + yCos,
+    x + xCos - ySin,
+    y + xSin + yCos,
+    x + xCos + ySin,
+    y + xSin - yCos,
+    x - xCos + ySin,
+    y - xSin - yCos
+  ];
+}
+function getHeight(extent) {
+  return extent[3] - extent[1];
+}
+function getIntersection(extent1, extent2, dest) {
+  const intersection = dest ? dest : createEmpty();
+  if (intersects(extent1, extent2)) {
+    if (extent1[0] > extent2[0]) {
+      intersection[0] = extent1[0];
+    } else {
+      intersection[0] = extent2[0];
+    }
+    if (extent1[1] > extent2[1]) {
+      intersection[1] = extent1[1];
+    } else {
+      intersection[1] = extent2[1];
+    }
+    if (extent1[2] < extent2[2]) {
+      intersection[2] = extent1[2];
+    } else {
+      intersection[2] = extent2[2];
+    }
+    if (extent1[3] < extent2[3]) {
+      intersection[3] = extent1[3];
+    } else {
+      intersection[3] = extent2[3];
+    }
+  } else {
+    createOrUpdateEmpty(intersection);
+  }
+  return intersection;
+}
+function getTopLeft(extent) {
+  return [extent[0], extent[3]];
+}
+function getTopRight(extent) {
+  return [extent[2], extent[3]];
+}
+function getWidth(extent) {
+  return extent[2] - extent[0];
+}
+function intersects(extent1, extent2) {
+  return extent1[0] <= extent2[2] && extent1[2] >= extent2[0] && extent1[1] <= extent2[3] && extent1[3] >= extent2[1];
+}
+function isEmpty(extent) {
+  return extent[2] < extent[0] || extent[3] < extent[1];
+}
+function returnOrUpdate(extent, dest) {
+  if (dest) {
+    dest[0] = extent[0];
+    dest[1] = extent[1];
+    dest[2] = extent[2];
+    dest[3] = extent[3];
+    return dest;
+  }
+  return extent;
+}
+function intersectsSegment(extent, start, end) {
+  let intersects2 = false;
+  const startRel = coordinateRelationship(extent, start);
+  const endRel = coordinateRelationship(extent, end);
+  if (startRel === Relationship.INTERSECTING || endRel === Relationship.INTERSECTING) {
+    intersects2 = true;
+  } else {
+    const minX = extent[0];
+    const minY = extent[1];
+    const maxX = extent[2];
+    const maxY = extent[3];
+    const startX = start[0];
+    const startY = start[1];
+    const endX = end[0];
+    const endY = end[1];
+    const slope = (endY - startY) / (endX - startX);
+    let x, y;
+    if (!!(endRel & Relationship.ABOVE) && !(startRel & Relationship.ABOVE)) {
+      x = endX - (endY - maxY) / slope;
+      intersects2 = x >= minX && x <= maxX;
+    }
+    if (!intersects2 && !!(endRel & Relationship.RIGHT) && !(startRel & Relationship.RIGHT)) {
+      y = endY - (endX - maxX) * slope;
+      intersects2 = y >= minY && y <= maxY;
+    }
+    if (!intersects2 && !!(endRel & Relationship.BELOW) && !(startRel & Relationship.BELOW)) {
+      x = endX - (endY - minY) / slope;
+      intersects2 = x >= minX && x <= maxX;
+    }
+    if (!intersects2 && !!(endRel & Relationship.LEFT) && !(startRel & Relationship.LEFT)) {
+      y = endY - (endX - minX) * slope;
+      intersects2 = y >= minY && y <= maxY;
+    }
+  }
+  return intersects2;
+}
+function wrapX$1(extent, projection) {
+  const projectionExtent = projection.getExtent();
+  const center = getCenter(extent);
+  if (projection.canWrapX() && (center[0] < projectionExtent[0] || center[0] >= projectionExtent[2])) {
+    const worldWidth = getWidth(projectionExtent);
+    const worldsAway = Math.floor(
+      (center[0] - projectionExtent[0]) / worldWidth
+    );
+    const offset = worldsAway * worldWidth;
+    extent[0] -= offset;
+    extent[2] -= offset;
+  }
+  return extent;
+}
+function wrapAndSliceX(extent, projection, multiWorld) {
+  if (projection.canWrapX()) {
+    const projectionExtent = projection.getExtent();
+    if (!isFinite(extent[0]) || !isFinite(extent[2])) {
+      return [[projectionExtent[0], extent[1], projectionExtent[2], extent[3]]];
+    }
+    wrapX$1(extent, projection);
+    const worldWidth = getWidth(projectionExtent);
+    if (getWidth(extent) > worldWidth && !multiWorld) {
+      return [[projectionExtent[0], extent[1], projectionExtent[2], extent[3]]];
+    }
+    if (extent[0] < projectionExtent[0]) {
+      return [
+        [extent[0] + worldWidth, extent[1], projectionExtent[2], extent[3]],
+        [projectionExtent[0], extent[1], extent[2], extent[3]]
+      ];
+    }
+    if (extent[2] > projectionExtent[2]) {
+      return [
+        [extent[0], extent[1], projectionExtent[2], extent[3]],
+        [projectionExtent[0], extent[1], extent[2] - worldWidth, extent[3]]
+      ];
+    }
+  }
+  return [extent];
+}
+function add$2(coordinate, delta) {
+  coordinate[0] += +delta[0];
+  coordinate[1] += +delta[1];
+  return coordinate;
+}
+function equals(coordinate1, coordinate2) {
+  let equals2 = true;
+  for (let i = coordinate1.length - 1; i >= 0; --i) {
+    if (coordinate1[i] != coordinate2[i]) {
+      equals2 = false;
+      break;
+    }
+  }
+  return equals2;
+}
+function rotate(coordinate, angle) {
+  const cosAngle = Math.cos(angle);
+  const sinAngle = Math.sin(angle);
+  const x = coordinate[0] * cosAngle - coordinate[1] * sinAngle;
+  const y = coordinate[1] * cosAngle + coordinate[0] * sinAngle;
+  coordinate[0] = x;
+  coordinate[1] = y;
+  return coordinate;
+}
+function scale(coordinate, scale2) {
+  coordinate[0] *= scale2;
+  coordinate[1] *= scale2;
+  return coordinate;
+}
+function wrapX(coordinate, projection) {
+  if (projection.canWrapX()) {
+    const worldWidth = getWidth(projection.getExtent());
+    const worldsAway = getWorldsAway(coordinate, projection, worldWidth);
+    if (worldsAway) {
+      coordinate[0] -= worldsAway * worldWidth;
+    }
+  }
+  return coordinate;
+}
+function getWorldsAway(coordinate, projection, sourceExtentWidth) {
+  const projectionExtent = projection.getExtent();
+  let worldsAway = 0;
+  if (projection.canWrapX() && (coordinate[0] < projectionExtent[0] || coordinate[0] > projectionExtent[2])) {
+    sourceExtentWidth = sourceExtentWidth || getWidth(projectionExtent);
+    worldsAway = Math.floor(
+      (coordinate[0] - projectionExtent[0]) / sourceExtentWidth
+    );
+  }
+  return worldsAway;
+}
+const DEFAULT_RADIUS = 63710088e-1;
+function getDistance(c1, c2, radius) {
+  radius = radius || DEFAULT_RADIUS;
+  const lat1 = toRadians(c1[1]);
+  const lat2 = toRadians(c2[1]);
+  const deltaLatBy2 = (lat2 - lat1) / 2;
+  const deltaLonBy2 = toRadians(c2[0] - c1[0]) / 2;
+  const a = Math.sin(deltaLatBy2) * Math.sin(deltaLatBy2) + Math.sin(deltaLonBy2) * Math.sin(deltaLonBy2) * Math.cos(lat1) * Math.cos(lat2);
+  return 2 * radius * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+}
+function warn(...args) {
+  console.warn(...args);
+}
+const METERS_PER_UNIT$1 = {
+  // use the radius of the Normal sphere
+  "radians": 6370997 / (2 * Math.PI),
+  "degrees": 2 * Math.PI * 6370997 / 360,
+  "ft": 0.3048,
+  "m": 1,
+  "us-ft": 1200 / 3937
+};
+class Projection {
+  /**
+   * @param {Options} options Projection options.
+   */
+  constructor(options) {
+    this.code_ = options.code;
+    this.units_ = /** @type {import("./Units.js").Units} */
+    options.units;
+    this.extent_ = options.extent !== void 0 ? options.extent : null;
+    this.worldExtent_ = options.worldExtent !== void 0 ? options.worldExtent : null;
+    this.axisOrientation_ = options.axisOrientation !== void 0 ? options.axisOrientation : "enu";
+    this.global_ = options.global !== void 0 ? options.global : false;
+    this.canWrapX_ = !!(this.global_ && this.extent_);
+    this.getPointResolutionFunc_ = options.getPointResolution;
+    this.defaultTileGrid_ = null;
+    this.metersPerUnit_ = options.metersPerUnit;
+  }
+  /**
+   * @return {boolean} The projection is suitable for wrapping the x-axis
+   */
+  canWrapX() {
+    return this.canWrapX_;
+  }
+  /**
+   * Get the code for this projection, e.g. 'EPSG:4326'.
+   * @return {string} Code.
+   * @api
+   */
+  getCode() {
+    return this.code_;
+  }
+  /**
+   * Get the validity extent for this projection.
+   * @return {import("../extent.js").Extent} Extent.
+   * @api
+   */
+  getExtent() {
+    return this.extent_;
+  }
+  /**
+   * Get the units of this projection.
+   * @return {import("./Units.js").Units} Units.
+   * @api
+   */
+  getUnits() {
+    return this.units_;
+  }
+  /**
+   * Get the amount of meters per unit of this projection.  If the projection is
+   * not configured with `metersPerUnit` or a units identifier, the return is
+   * `undefined`.
+   * @return {number|undefined} Meters.
+   * @api
+   */
+  getMetersPerUnit() {
+    return this.metersPerUnit_ || METERS_PER_UNIT$1[this.units_];
+  }
+  /**
+   * Get the world extent for this projection.
+   * @return {import("../extent.js").Extent} Extent.
+   * @api
+   */
+  getWorldExtent() {
+    return this.worldExtent_;
+  }
+  /**
+   * Get the axis orientation of this projection.
+   * Example values are:
+   * enu - the default easting, northing, elevation.
+   * neu - northing, easting, up - useful for "lat/long" geographic coordinates,
+   *     or south orientated transverse mercator.
+   * wnu - westing, northing, up - some planetary coordinate systems have
+   *     "west positive" coordinate systems
+   * @return {string} Axis orientation.
+   * @api
+   */
+  getAxisOrientation() {
+    return this.axisOrientation_;
+  }
+  /**
+   * Is this projection a global projection which spans the whole world?
+   * @return {boolean} Whether the projection is global.
+   * @api
+   */
+  isGlobal() {
+    return this.global_;
+  }
+  /**
+   * Set if the projection is a global projection which spans the whole world
+   * @param {boolean} global Whether the projection is global.
+   * @api
+   */
+  setGlobal(global) {
+    this.global_ = global;
+    this.canWrapX_ = !!(global && this.extent_);
+  }
+  /**
+   * @return {import("../tilegrid/TileGrid.js").default} The default tile grid.
+   */
+  getDefaultTileGrid() {
+    return this.defaultTileGrid_;
+  }
+  /**
+   * @param {import("../tilegrid/TileGrid.js").default} tileGrid The default tile grid.
+   */
+  setDefaultTileGrid(tileGrid) {
+    this.defaultTileGrid_ = tileGrid;
+  }
+  /**
+   * Set the validity extent for this projection.
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @api
+   */
+  setExtent(extent) {
+    this.extent_ = extent;
+    this.canWrapX_ = !!(this.global_ && extent);
+  }
+  /**
+   * Set the world extent for this projection.
+   * @param {import("../extent.js").Extent} worldExtent World extent
+   *     [minlon, minlat, maxlon, maxlat].
+   * @api
+   */
+  setWorldExtent(worldExtent) {
+    this.worldExtent_ = worldExtent;
+  }
+  /**
+   * Set the getPointResolution function (see {@link module:ol/proj.getPointResolution}
+   * for this projection.
+   * @param {function(number, import("../coordinate.js").Coordinate):number} func Function
+   * @api
+   */
+  setGetPointResolution(func) {
+    this.getPointResolutionFunc_ = func;
+  }
+  /**
+   * Get the custom point resolution function for this projection (if set).
+   * @return {GetPointResolution|undefined} The custom point
+   * resolution function (if set).
+   */
+  getPointResolutionFunc() {
+    return this.getPointResolutionFunc_;
+  }
+}
+const RADIUS$1 = 6378137;
+const HALF_SIZE = Math.PI * RADIUS$1;
+const EXTENT$1 = [-HALF_SIZE, -HALF_SIZE, HALF_SIZE, HALF_SIZE];
+const WORLD_EXTENT = [-180, -85, 180, 85];
+const MAX_SAFE_Y = RADIUS$1 * Math.log(Math.tan(Math.PI / 2));
+class EPSG3857Projection extends Projection {
+  /**
+   * @param {string} code Code.
+   */
+  constructor(code) {
+    super({
+      code,
+      units: "m",
+      extent: EXTENT$1,
+      global: true,
+      worldExtent: WORLD_EXTENT,
+      getPointResolution: function(resolution, point) {
+        return resolution / Math.cosh(point[1] / RADIUS$1);
+      }
+    });
+  }
+}
+const PROJECTIONS$1 = [
+  new EPSG3857Projection("EPSG:3857"),
+  new EPSG3857Projection("EPSG:102100"),
+  new EPSG3857Projection("EPSG:102113"),
+  new EPSG3857Projection("EPSG:900913"),
+  new EPSG3857Projection("http://www.opengis.net/def/crs/EPSG/0/3857"),
+  new EPSG3857Projection("http://www.opengis.net/gml/srs/epsg.xml#3857")
+];
+function fromEPSG4326(input, output, dimension, stride) {
+  const length = input.length;
+  dimension = dimension > 1 ? dimension : 2;
+  stride = stride != null ? stride : dimension;
+  if (output === void 0) {
+    if (dimension > 2) {
+      output = input.slice();
+    } else {
+      output = new Array(length);
+    }
+  }
+  for (let i = 0; i < length; i += stride) {
+    output[i] = HALF_SIZE * input[i] / 180;
+    let y = RADIUS$1 * Math.log(Math.tan(Math.PI * (+input[i + 1] + 90) / 360));
+    if (y > MAX_SAFE_Y) {
+      y = MAX_SAFE_Y;
+    } else if (y < -MAX_SAFE_Y) {
+      y = -MAX_SAFE_Y;
+    }
+    output[i + 1] = y;
+  }
+  return output;
+}
+function toEPSG4326(input, output, dimension, stride) {
+  const length = input.length;
+  dimension = dimension > 1 ? dimension : 2;
+  stride = stride != null ? stride : dimension;
+  if (output === void 0) {
+    if (dimension > 2) {
+      output = input.slice();
+    } else {
+      output = new Array(length);
+    }
+  }
+  for (let i = 0; i < length; i += stride) {
+    output[i] = 180 * input[i] / HALF_SIZE;
+    output[i + 1] = 360 * Math.atan(Math.exp(input[i + 1] / RADIUS$1)) / Math.PI - 90;
+  }
+  return output;
+}
+const RADIUS = 6378137;
+const EXTENT = [-180, -90, 180, 90];
+const METERS_PER_UNIT = Math.PI * RADIUS / 180;
+class EPSG4326Projection extends Projection {
+  /**
+   * @param {string} code Code.
+   * @param {string} [axisOrientation] Axis orientation.
+   */
+  constructor(code, axisOrientation) {
+    super({
+      code,
+      units: "degrees",
+      extent: EXTENT,
+      axisOrientation,
+      global: true,
+      metersPerUnit: METERS_PER_UNIT,
+      worldExtent: EXTENT
+    });
+  }
+}
+const PROJECTIONS = [
+  new EPSG4326Projection("CRS:84"),
+  new EPSG4326Projection("EPSG:4326", "neu"),
+  new EPSG4326Projection("urn:ogc:def:crs:OGC:1.3:CRS84"),
+  new EPSG4326Projection("urn:ogc:def:crs:OGC:2:84"),
+  new EPSG4326Projection("http://www.opengis.net/def/crs/OGC/1.3/CRS84"),
+  new EPSG4326Projection("http://www.opengis.net/gml/srs/epsg.xml#4326", "neu"),
+  new EPSG4326Projection("http://www.opengis.net/def/crs/EPSG/0/4326", "neu")
+];
+let cache = {};
+function get$2(code) {
+  return cache[code] || cache[code.replace(/urn:(x-)?ogc:def:crs:EPSG:(.*:)?(\w+)$/, "EPSG:$3")] || null;
+}
+function add$1(code, projection) {
+  cache[code] = projection;
+}
+let transforms = {};
+function add(source, destination, transformFn) {
+  const sourceCode = source.getCode();
+  const destinationCode = destination.getCode();
+  if (!(sourceCode in transforms)) {
+    transforms[sourceCode] = {};
+  }
+  transforms[sourceCode][destinationCode] = transformFn;
+}
+function get$1(sourceCode, destinationCode) {
+  if (sourceCode in transforms && destinationCode in transforms[sourceCode]) {
+    return transforms[sourceCode][destinationCode];
+  }
+  return null;
+}
+const K0 = 0.9996;
+const E = 669438e-8;
+const E2 = E * E;
+const E3 = E2 * E;
+const E_P2 = E / (1 - E);
+const SQRT_E = Math.sqrt(1 - E);
+const _E = (1 - SQRT_E) / (1 + SQRT_E);
+const _E2 = _E * _E;
+const _E3 = _E2 * _E;
+const _E4 = _E3 * _E;
+const _E5 = _E4 * _E;
+const M1 = 1 - E / 4 - 3 * E2 / 64 - 5 * E3 / 256;
+const M2 = 3 * E / 8 + 3 * E2 / 32 + 45 * E3 / 1024;
+const M3 = 15 * E2 / 256 + 45 * E3 / 1024;
+const M4 = 35 * E3 / 3072;
+const P2 = 3 / 2 * _E - 27 / 32 * _E3 + 269 / 512 * _E5;
+const P3 = 21 / 16 * _E2 - 55 / 32 * _E4;
+const P4 = 151 / 96 * _E3 - 417 / 128 * _E5;
+const P5 = 1097 / 512 * _E4;
+const R = 6378137;
+function toLonLat$1(easting, northing, zone) {
+  const x = easting - 5e5;
+  const y = zone.north ? northing : northing - 1e7;
+  const m = y / K0;
+  const mu = m / (R * M1);
+  const pRad = mu + P2 * Math.sin(2 * mu) + P3 * Math.sin(4 * mu) + P4 * Math.sin(6 * mu) + P5 * Math.sin(8 * mu);
+  const pSin = Math.sin(pRad);
+  const pSin2 = pSin * pSin;
+  const pCos = Math.cos(pRad);
+  const pTan = pSin / pCos;
+  const pTan2 = pTan * pTan;
+  const pTan4 = pTan2 * pTan2;
+  const epSin = 1 - E * pSin2;
+  const epSinSqrt = Math.sqrt(1 - E * pSin2);
+  const n = R / epSinSqrt;
+  const r = (1 - E) / epSin;
+  const c = E_P2 * __pow(pCos, 2);
+  const c2 = c * c;
+  const d = x / (n * K0);
+  const d2 = d * d;
+  const d3 = d2 * d;
+  const d4 = d3 * d;
+  const d5 = d4 * d;
+  const d6 = d5 * d;
+  const latitude = pRad - pTan / r * (d2 / 2 - d4 / 24 * (5 + 3 * pTan2 + 10 * c - 4 * c2 - 9 * E_P2)) + d6 / 720 * (61 + 90 * pTan2 + 298 * c + 45 * pTan4 - 252 * E_P2 - 3 * c2);
+  let longitude = (d - d3 / 6 * (1 + 2 * pTan2 + c) + d5 / 120 * (5 - 2 * c + 28 * pTan2 - 3 * c2 + 8 * E_P2 + 24 * pTan4)) / pCos;
+  longitude = wrap(
+    longitude + toRadians(zoneToCentralLongitude(zone.number)),
+    -Math.PI,
+    Math.PI
+  );
+  return [toDegrees(longitude), toDegrees(latitude)];
+}
+const MIN_LATITUDE = -80;
+const MAX_LATITUDE = 84;
+const MIN_LONGITUDE = -180;
+const MAX_LONGITUDE = 180;
+function fromLonLat$1(longitude, latitude, zone) {
+  longitude = wrap(longitude, MIN_LONGITUDE, MAX_LONGITUDE);
+  if (latitude < MIN_LATITUDE) {
+    latitude = MIN_LATITUDE;
+  } else if (latitude > MAX_LATITUDE) {
+    latitude = MAX_LATITUDE;
+  }
+  const latRad = toRadians(latitude);
+  const latSin = Math.sin(latRad);
+  const latCos = Math.cos(latRad);
+  const latTan = latSin / latCos;
+  const latTan2 = latTan * latTan;
+  const latTan4 = latTan2 * latTan2;
+  const lonRad = toRadians(longitude);
+  const centralLon = zoneToCentralLongitude(zone.number);
+  const centralLonRad = toRadians(centralLon);
+  const n = R / Math.sqrt(1 - E * __pow(latSin, 2));
+  const c = E_P2 * __pow(latCos, 2);
+  const a = latCos * wrap(lonRad - centralLonRad, -Math.PI, Math.PI);
+  const a2 = a * a;
+  const a3 = a2 * a;
+  const a4 = a3 * a;
+  const a5 = a4 * a;
+  const a6 = a5 * a;
+  const m = R * (M1 * latRad - M2 * Math.sin(2 * latRad) + M3 * Math.sin(4 * latRad) - M4 * Math.sin(6 * latRad));
+  const easting = K0 * n * (a + a3 / 6 * (1 - latTan2 + c) + a5 / 120 * (5 - 18 * latTan2 + latTan4 + 72 * c - 58 * E_P2)) + 5e5;
+  let northing = K0 * (m + n * latTan * (a2 / 2 + a4 / 24 * (5 - latTan2 + 9 * c + 4 * __pow(c, 2)) + a6 / 720 * (61 - 58 * latTan2 + latTan4 + 600 * c - 330 * E_P2)));
+  if (!zone.north) {
+    northing += 1e7;
+  }
+  return [easting, northing];
+}
+function zoneToCentralLongitude(zone) {
+  return (zone - 1) * 6 - 180 + 3;
+}
+const epsgRegExes = [
+  /^EPSG:(\d+)$/,
+  /^urn:ogc:def:crs:EPSG::(\d+)$/,
+  /^http:\/\/www\.opengis\.net\/def\/crs\/EPSG\/0\/(\d+)$/
+];
+function zoneFromCode(code) {
+  let epsgId = 0;
+  for (const re of epsgRegExes) {
+    const match = code.match(re);
+    if (match) {
+      epsgId = parseInt(match[1]);
+      break;
+    }
+  }
+  if (!epsgId) {
+    return null;
+  }
+  let number = 0;
+  let north = false;
+  if (epsgId > 32700 && epsgId < 32761) {
+    number = epsgId - 32700;
+  } else if (epsgId > 32600 && epsgId < 32661) {
+    north = true;
+    number = epsgId - 32600;
+  }
+  if (!number) {
+    return null;
+  }
+  return { number, north };
+}
+function makeTransformFunction(transformer, zone) {
+  return function(input, output, dimension, stride) {
+    const length = input.length;
+    dimension = dimension > 1 ? dimension : 2;
+    stride = stride != null ? stride : dimension;
+    if (!output) {
+      if (dimension > 2) {
+        output = input.slice();
+      } else {
+        output = new Array(length);
+      }
+    }
+    for (let i = 0; i < length; i += stride) {
+      const x = input[i];
+      const y = input[i + 1];
+      const coord = transformer(x, y, zone);
+      output[i] = coord[0];
+      output[i + 1] = coord[1];
+    }
+    return output;
+  };
+}
+function makeProjection(code) {
+  const zone = zoneFromCode(code);
+  if (!zone) {
+    return null;
+  }
+  return new Projection({ code, units: "m" });
+}
+function makeTransforms(projection) {
+  const zone = zoneFromCode(projection.getCode());
+  if (!zone) {
+    return null;
+  }
+  return {
+    forward: makeTransformFunction(fromLonLat$1, zone),
+    inverse: makeTransformFunction(toLonLat$1, zone)
+  };
+}
+const transformFactories = [makeTransforms];
+const projectionFactories = [makeProjection];
+let showCoordinateWarning = true;
+function disableCoordinateWarning(disable) {
+  showCoordinateWarning = false;
+}
+function cloneTransform(input, output) {
+  if (output !== void 0) {
+    for (let i = 0, ii = input.length; i < ii; ++i) {
+      output[i] = input[i];
+    }
+    output = output;
+  } else {
+    output = input.slice();
+  }
+  return output;
+}
+function addProjection(projection) {
+  add$1(projection.getCode(), projection);
+  add(projection, projection, cloneTransform);
+}
+function addProjections(projections) {
+  projections.forEach(addProjection);
+}
+function get(projectionLike) {
+  if (!(typeof projectionLike === "string")) {
+    return projectionLike;
+  }
+  const projection = get$2(projectionLike);
+  if (projection) {
+    return projection;
+  }
+  for (const makeProjection2 of projectionFactories) {
+    const projection2 = makeProjection2(projectionLike);
+    if (projection2) {
+      return projection2;
+    }
+  }
+  return null;
+}
+function getPointResolution(projection, resolution, point, units) {
+  projection = get(projection);
+  let pointResolution;
+  const getter = projection.getPointResolutionFunc();
+  if (getter) {
+    pointResolution = getter(resolution, point);
+  } else {
+    const projUnits = projection.getUnits();
+    if (projUnits == "degrees" && !units || units == "degrees") {
+      pointResolution = resolution;
+    } else {
+      const toEPSG43262 = getTransformFromProjections(
+        projection,
+        get("EPSG:4326")
+      );
+      if (!toEPSG43262 && projUnits !== "degrees") {
+        pointResolution = resolution * projection.getMetersPerUnit();
+      } else {
+        let vertices = [
+          point[0] - resolution / 2,
+          point[1],
+          point[0] + resolution / 2,
+          point[1],
+          point[0],
+          point[1] - resolution / 2,
+          point[0],
+          point[1] + resolution / 2
+        ];
+        vertices = toEPSG43262(vertices, vertices, 2);
+        const width = getDistance(vertices.slice(0, 2), vertices.slice(2, 4));
+        const height = getDistance(vertices.slice(4, 6), vertices.slice(6, 8));
+        pointResolution = (width + height) / 2;
+      }
+      const metersPerUnit = projection.getMetersPerUnit();
+      if (metersPerUnit !== void 0) {
+        pointResolution /= metersPerUnit;
+      }
+    }
+  }
+  return pointResolution;
+}
+function addEquivalentProjections(projections) {
+  addProjections(projections);
+  projections.forEach(function(source) {
+    projections.forEach(function(destination) {
+      if (source !== destination) {
+        add(source, destination, cloneTransform);
+      }
+    });
+  });
+}
+function addEquivalentTransforms(projections1, projections2, forwardTransform, inverseTransform) {
+  projections1.forEach(function(projection1) {
+    projections2.forEach(function(projection2) {
+      add(projection1, projection2, forwardTransform);
+      add(projection2, projection1, inverseTransform);
+    });
+  });
+}
+function createProjection(projection, defaultCode) {
+  if (!projection) {
+    return get(defaultCode);
+  }
+  if (typeof projection === "string") {
+    return get(projection);
+  }
+  return (
+    /** @type {Projection} */
+    projection
+  );
+}
+function createTransformFromCoordinateTransform(coordTransform) {
+  return (
+    /**
+     * @param {Array<number>} input Input.
+     * @param {Array<number>} [output] Output.
+     * @param {number} [dimension] Dimensions that should be transformed.
+     * @param {number} [stride] Stride.
+     * @return {Array<number>} Output.
+     */
+    (function(input, output, dimension, stride) {
+      const length = input.length;
+      dimension = dimension !== void 0 ? dimension : 2;
+      stride = stride != null ? stride : dimension;
+      output = output !== void 0 ? output : new Array(length);
+      for (let i = 0; i < length; i += stride) {
+        const point = coordTransform(input.slice(i, i + dimension));
+        const pointLength = point.length;
+        for (let j = 0, jj = stride; j < jj; ++j) {
+          output[i + j] = j >= pointLength ? input[i + j] : point[j];
+        }
+      }
+      return output;
+    })
+  );
+}
+function fromLonLat(coordinate, projection) {
+  disableCoordinateWarning();
+  return transform(
+    coordinate,
+    "EPSG:4326",
+    projection !== void 0 ? projection : "EPSG:3857"
+  );
+}
+function toLonLat(coordinate, projection) {
+  const lonLat = transform(
+    coordinate,
+    projection !== void 0 ? projection : "EPSG:3857",
+    "EPSG:4326"
+  );
+  const lon = lonLat[0];
+  if (lon < -180 || lon > 180) {
+    lonLat[0] = modulo(lon + 180, 360) - 180;
+  }
+  return lonLat;
+}
+function equivalent(projection1, projection2) {
+  if (projection1 === projection2) {
+    return true;
+  }
+  const equalUnits = projection1.getUnits() === projection2.getUnits();
+  if (projection1.getCode() === projection2.getCode()) {
+    return equalUnits;
+  }
+  const transformFunc = getTransformFromProjections(projection1, projection2);
+  return transformFunc === cloneTransform && equalUnits;
+}
+function getTransformFromProjections(source, destination) {
+  const sourceCode = source.getCode();
+  const destinationCode = destination.getCode();
+  let transformFunc = get$1(sourceCode, destinationCode);
+  if (transformFunc) {
+    return transformFunc;
+  }
+  let sourceTransforms = null;
+  let destinationTransforms = null;
+  for (const makeTransforms2 of transformFactories) {
+    if (!sourceTransforms) {
+      sourceTransforms = makeTransforms2(source);
+    }
+    if (!destinationTransforms) {
+      destinationTransforms = makeTransforms2(destination);
+    }
+  }
+  if (!sourceTransforms && !destinationTransforms) {
+    return null;
+  }
+  const intermediateCode = "EPSG:4326";
+  if (!destinationTransforms) {
+    const toDestination = get$1(intermediateCode, destinationCode);
+    if (toDestination) {
+      transformFunc = composeTransformFuncs(
+        sourceTransforms.inverse,
+        toDestination
+      );
+    }
+  } else if (!sourceTransforms) {
+    const fromSource = get$1(sourceCode, intermediateCode);
+    if (fromSource) {
+      transformFunc = composeTransformFuncs(
+        fromSource,
+        destinationTransforms.forward
+      );
+    }
+  } else {
+    transformFunc = composeTransformFuncs(
+      sourceTransforms.inverse,
+      destinationTransforms.forward
+    );
+  }
+  if (transformFunc) {
+    addProjection(source);
+    addProjection(destination);
+    add(source, destination, transformFunc);
+  }
+  return transformFunc;
+}
+function composeTransformFuncs(t1, t2) {
+  return function(input, output, dimensions, stride) {
+    output = t1(input, output, dimensions, stride);
+    return t2(output, output, dimensions, stride);
+  };
+}
+function getTransform(source, destination) {
+  const sourceProjection = get(source);
+  const destinationProjection = get(destination);
+  return getTransformFromProjections(sourceProjection, destinationProjection);
+}
+function transform(coordinate, source, destination) {
+  const transformFunc = getTransform(source, destination);
+  if (!transformFunc) {
+    const sourceCode = get(source).getCode();
+    const destinationCode = get(destination).getCode();
+    throw new Error(
+      `No transform available between ${sourceCode} and ${destinationCode}`
+    );
+  }
+  return transformFunc(coordinate, void 0, coordinate.length);
+}
+function toUserCoordinate(coordinate, sourceProjection) {
+  {
+    return coordinate;
+  }
+}
+function fromUserCoordinate(coordinate, destProjection) {
+  {
+    if (showCoordinateWarning && !equals(coordinate, [0, 0]) && coordinate[0] >= -180 && coordinate[0] <= 180 && coordinate[1] >= -90 && coordinate[1] <= 90) {
+      showCoordinateWarning = false;
+      warn(
+        "Call useGeographic() from ol/proj once to work with [longitude, latitude] coordinates."
+      );
+    }
+    return coordinate;
+  }
+}
+function toUserExtent(extent, sourceProjection) {
+  {
+    return extent;
+  }
+}
+function fromUserExtent(extent, destProjection) {
+  {
+    return extent;
+  }
+}
+function addCommon() {
+  addEquivalentProjections(PROJECTIONS$1);
+  addEquivalentProjections(PROJECTIONS);
+  addEquivalentTransforms(
+    PROJECTIONS,
+    PROJECTIONS$1,
+    fromEPSG4326,
+    toEPSG4326
+  );
+}
+addCommon();
+export {
+  getCorner as $,
+  warn as A,
+  containsCoordinate as B,
+  coordinateRelationship as C,
+  buffer as D,
+  createOrUpdate as E,
+  extendCoordinate as F,
+  getTopLeft as G,
+  getTopRight as H,
+  getBottomRight as I,
+  getBottomLeft as J,
+  containsExtent as K,
+  wrapX$1 as L,
+  METERS_PER_UNIT$1 as M,
+  extend as N,
+  transform as O,
+  getPointResolution as P,
+  createTransformFromCoordinateTransform as Q,
+  Relationship as R,
+  getTransform as S,
+  getArea as T,
+  boundingExtent as U,
+  wrapAndSliceX as V,
+  equivalent as W,
+  getRotatedViewport as X,
+  createOrUpdateFromFlatCoordinates as Y,
+  createOrUpdateFromCoordinate as Z,
+  get as _,
+  createEmpty as a,
+  returnOrUpdate as a0,
+  containsXY as a1,
+  fromLonLat as a2,
+  toLonLat as a3,
+  intersectsSegment as b,
+  closestSquaredDistanceXY as c,
+  isEmpty as d,
+  extendFlatCoordinates as e,
+  forEachCorner as f,
+  getCenter as g,
+  getWidth as h,
+  intersects as i,
+  getHeight as j,
+  createProjection as k,
+  fromUserCoordinate as l,
+  fromUserExtent as m,
+  add$2 as n,
+  toUserExtent as o,
+  getForViewAndSize as p,
+  equals as q,
+  rotate as r,
+  disableCoordinateWarning as s,
+  toUserCoordinate as t,
+  scale as u,
+  getIntersection as v,
+  wrapX as w,
+  equals$1 as x,
+  createOrUpdateEmpty as y,
+  clone as z
+};