@hybridcore/ui 1.0.2 → 1.1.2

package/dist/Source-CnCcu5UP.js

@@ -0,0 +1,4374 @@
+import { k as W, m as K, d as p, W as ce, f as H, b as S, i as E, n as Lt, o as ge, s as j, p as fe, q as de, r as Re, e as _e, V as me, u as nt, l as it, E as Ct } from "./has-9_asnBxn.js";
+const vt = {
+  // 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 Yt {
+  /**
+   * @param {Options} options Projection options.
+   */
+  constructor(t) {
+    this.code_ = t.code, this.units_ = /** @type {import("./Units.js").Units} */
+    t.units, this.extent_ = t.extent !== void 0 ? t.extent : null, this.worldExtent_ = t.worldExtent !== void 0 ? t.worldExtent : null, this.axisOrientation_ = t.axisOrientation !== void 0 ? t.axisOrientation : "enu", this.global_ = t.global !== void 0 ? t.global : !1, this.canWrapX_ = !!(this.global_ && this.extent_), this.getPointResolutionFunc_ = t.getPointResolution, this.defaultTileGrid_ = null, this.metersPerUnit_ = t.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_ || vt[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(t) {
+    this.global_ = t, this.canWrapX_ = !!(t && 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(t) {
+    this.defaultTileGrid_ = t;
+  }
+  /**
+   * Set the validity extent for this projection.
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @api
+   */
+  setExtent(t) {
+    this.extent_ = t, this.canWrapX_ = !!(this.global_ && t);
+  }
+  /**
+   * Set the world extent for this projection.
+   * @param {import("../extent.js").Extent} worldExtent World extent
+   *     [minlon, minlat, maxlon, maxlat].
+   * @api
+   */
+  setWorldExtent(t) {
+    this.worldExtent_ = t;
+  }
+  /**
+   * 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(t) {
+    this.getPointResolutionFunc_ = t;
+  }
+  /**
+   * Get the custom point resolution function for this projection (if set).
+   * @return {function(number, import("../coordinate.js").Coordinate):number|undefined} The custom point
+   * resolution function (if set).
+   */
+  getPointResolutionFunc() {
+    return this.getPointResolutionFunc_;
+  }
+}
+const z = 6378137, Z = Math.PI * z, ye = [-Z, -Z, Z, Z], Me = [-180, -85, 180, 85], U = z * Math.log(Math.tan(Math.PI / 2));
+class x extends Yt {
+  /**
+   * @param {string} code Code.
+   */
+  constructor(t) {
+    super({
+      code: t,
+      units: "m",
+      extent: ye,
+      global: !0,
+      worldExtent: Me,
+      getPointResolution: function(e, i) {
+        return e / Math.cosh(i[1] / z);
+      }
+    });
+  }
+}
+const Et = [
+  new x("EPSG:3857"),
+  new x("EPSG:102100"),
+  new x("EPSG:102113"),
+  new x("EPSG:900913"),
+  new x("http://www.opengis.net/def/crs/EPSG/0/3857"),
+  new x("http://www.opengis.net/gml/srs/epsg.xml#3857")
+];
+function Ce(n, t, e) {
+  const i = n.length;
+  e = e > 1 ? e : 2, t === void 0 && (e > 2 ? t = n.slice() : t = new Array(i));
+  for (let r = 0; r < i; r += e) {
+    t[r] = Z * n[r] / 180;
+    let s = z * Math.log(Math.tan(Math.PI * (+n[r + 1] + 90) / 360));
+    s > U ? s = U : s < -U && (s = -U), t[r + 1] = s;
+  }
+  return t;
+}
+function Ee(n, t, e) {
+  const i = n.length;
+  e = e > 1 ? e : 2, t === void 0 && (e > 2 ? t = n.slice() : t = new Array(i));
+  for (let r = 0; r < i; r += e)
+    t[r] = 180 * n[r] / Z, t[r + 1] = 360 * Math.atan(Math.exp(n[r + 1] / z)) / Math.PI - 90;
+  return t;
+}
+const Ie = 6378137, It = [-180, -90, 180, 90], Se = Math.PI * Ie / 180;
+class N extends Yt {
+  /**
+   * @param {string} code Code.
+   * @param {string} [axisOrientation] Axis orientation.
+   */
+  constructor(t, e) {
+    super({
+      code: t,
+      units: "degrees",
+      extent: It,
+      axisOrientation: e,
+      global: !0,
+      metersPerUnit: Se,
+      worldExtent: It
+    });
+  }
+}
+const St = [
+  new N("CRS:84"),
+  new N("EPSG:4326", "neu"),
+  new N("urn:ogc:def:crs:OGC:1.3:CRS84"),
+  new N("urn:ogc:def:crs:OGC:2:84"),
+  new N("http://www.opengis.net/def/crs/OGC/1.3/CRS84"),
+  new N("http://www.opengis.net/gml/srs/epsg.xml#4326", "neu"),
+  new N("http://www.opengis.net/def/crs/EPSG/0/4326", "neu")
+];
+let ot = {};
+function pe(n) {
+  return ot[n] || ot[n.replace(/urn:(x-)?ogc:def:crs:EPSG:(.*:)?(\w+)$/, "EPSG:$3")] || null;
+}
+function Ae(n, t) {
+  ot[n] = t;
+}
+let b = {};
+function k(n, t, e) {
+  const i = n.getCode(), r = t.getCode();
+  i in b || (b[i] = {}), b[i][r] = e;
+}
+function we(n, t) {
+  let e;
+  return n in b && t in b[n] && (e = b[n][t]), e;
+}
+const C = {
+  UNKNOWN: 0,
+  INTERSECTING: 1,
+  ABOVE: 2,
+  RIGHT: 4,
+  BELOW: 8,
+  LEFT: 16
+};
+function Gn(n) {
+  const t = $();
+  for (let e = 0, i = n.length; e < i; ++e)
+    xe(t, n[e]);
+  return t;
+}
+function Pe(n, t, e) {
+  const i = Math.min.apply(null, n), r = Math.min.apply(null, t), s = Math.max.apply(null, n), o = Math.max.apply(null, t);
+  return J(i, r, s, o, e);
+}
+function jn(n, t, e) {
+  return e ? (e[0] = n[0] - t, e[1] = n[1] - t, e[2] = n[2] + t, e[3] = n[3] + t, e) : [
+    n[0] - t,
+    n[1] - t,
+    n[2] + t,
+    n[3] + t
+  ];
+}
+function Ln(n, t) {
+  return t ? (t[0] = n[0], t[1] = n[1], t[2] = n[2], t[3] = n[3], t) : n.slice();
+}
+function zt(n, t, e) {
+  let i, r;
+  return t < n[0] ? i = n[0] - t : n[2] < t ? i = t - n[2] : i = 0, e < n[1] ? r = n[1] - e : n[3] < e ? r = e - n[3] : r = 0, i * i + r * r;
+}
+function vn(n, t) {
+  return Ut(n, t[0], t[1]);
+}
+function Te(n, t) {
+  return n[0] <= t[0] && t[2] <= n[2] && n[1] <= t[1] && t[3] <= n[3];
+}
+function Ut(n, t, e) {
+  return n[0] <= t && t <= n[2] && n[1] <= e && e <= n[3];
+}
+function pt(n, t) {
+  const e = n[0], i = n[1], r = n[2], s = n[3], o = t[0], u = t[1];
+  let a = C.UNKNOWN;
+  return o < e ? a = a | C.LEFT : o > r && (a = a | C.RIGHT), u < i ? a = a | C.BELOW : u > s && (a = a | C.ABOVE), a === C.UNKNOWN && (a = C.INTERSECTING), a;
+}
+function $() {
+  return [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+}
+function J(n, t, e, i, r) {
+  return r ? (r[0] = n, r[1] = t, r[2] = e, r[3] = i, r) : [n, t, e, i];
+}
+function Q(n) {
+  return J(1 / 0, 1 / 0, -1 / 0, -1 / 0, n);
+}
+function Ne(n, t) {
+  const e = n[0], i = n[1];
+  return J(e, i, e, i, t);
+}
+function Oe(n, t, e, i, r) {
+  const s = Q(r);
+  return Vt(s, n, t, e, i);
+}
+function Yn(n, t) {
+  return n[0] == t[0] && n[2] == t[2] && n[1] == t[1] && n[3] == t[3];
+}
+function zn(n, t) {
+  return t[0] < n[0] && (n[0] = t[0]), t[2] > n[2] && (n[2] = t[2]), t[1] < n[1] && (n[1] = t[1]), t[3] > n[3] && (n[3] = t[3]), n;
+}
+function xe(n, t) {
+  t[0] < n[0] && (n[0] = t[0]), t[0] > n[2] && (n[2] = t[0]), t[1] < n[1] && (n[1] = t[1]), t[1] > n[3] && (n[3] = t[1]);
+}
+function Vt(n, t, e, i, r) {
+  for (; e < i; e += r)
+    Fe(n, t[e], t[e + 1]);
+  return n;
+}
+function Fe(n, t, e) {
+  n[0] = Math.min(n[0], t), n[1] = Math.min(n[1], e), n[2] = Math.max(n[2], t), n[3] = Math.max(n[3], e);
+}
+function Ze(n, t) {
+  let e;
+  return e = t(be(n)), e || (e = t(Xe(n)), e) || (e = t(ve(n)), e) || (e = t(Le(n)), e) ? e : !1;
+}
+function Un(n) {
+  let t = 0;
+  return tt(n) || (t = A(n) * X(n)), t;
+}
+function be(n) {
+  return [n[0], n[1]];
+}
+function Xe(n) {
+  return [n[2], n[1]];
+}
+function L(n) {
+  return [(n[0] + n[2]) / 2, (n[1] + n[3]) / 2];
+}
+function Ge(n, t, e, i, r) {
+  const [s, o, u, a, h, l, c, g] = je(
+    n,
+    t,
+    e,
+    i
+  );
+  return J(
+    Math.min(s, u, h, c),
+    Math.min(o, a, l, g),
+    Math.max(s, u, h, c),
+    Math.max(o, a, l, g),
+    r
+  );
+}
+function je(n, t, e, i) {
+  const r = t * i[0] / 2, s = t * i[1] / 2, o = Math.cos(e), u = Math.sin(e), a = r * o, h = r * u, l = s * o, c = s * u, g = n[0], f = n[1];
+  return [
+    g - a + c,
+    f - h - l,
+    g - a - c,
+    f - h + l,
+    g + a - c,
+    f + h + l,
+    g + a + c,
+    f + h - l,
+    g - a + c,
+    f - h - l
+  ];
+}
+function X(n) {
+  return n[3] - n[1];
+}
+function Vn(n, t, e) {
+  const i = e || $();
+  return lt(n, t) ? (n[0] > t[0] ? i[0] = n[0] : i[0] = t[0], n[1] > t[1] ? i[1] = n[1] : i[1] = t[1], n[2] < t[2] ? i[2] = n[2] : i[2] = t[2], n[3] < t[3] ? i[3] = n[3] : i[3] = t[3]) : Q(i), i;
+}
+function Le(n) {
+  return [n[0], n[3]];
+}
+function ve(n) {
+  return [n[2], n[3]];
+}
+function A(n) {
+  return n[2] - n[0];
+}
+function lt(n, t) {
+  return n[0] <= t[2] && n[2] >= t[0] && n[1] <= t[3] && n[3] >= t[1];
+}
+function tt(n) {
+  return n[2] < n[0] || n[3] < n[1];
+}
+function Ye(n, t) {
+  return t ? (t[0] = n[0], t[1] = n[1], t[2] = n[2], t[3] = n[3], t) : n;
+}
+function ze(n, t, e) {
+  let i = !1;
+  const r = pt(n, t), s = pt(n, e);
+  if (r === C.INTERSECTING || s === C.INTERSECTING)
+    i = !0;
+  else {
+    const o = n[0], u = n[1], a = n[2], h = n[3], l = t[0], c = t[1], g = e[0], f = e[1], d = (f - c) / (g - l);
+    let R, _;
+    s & C.ABOVE && !(r & C.ABOVE) && (R = g - (f - h) / d, i = R >= o && R <= a), !i && s & C.RIGHT && !(r & C.RIGHT) && (_ = f - (g - a) * d, i = _ >= u && _ <= h), !i && s & C.BELOW && !(r & C.BELOW) && (R = g - (f - u) / d, i = R >= o && R <= a), !i && s & C.LEFT && !(r & C.LEFT) && (_ = f - (g - o) * d, i = _ >= u && _ <= h);
+  }
+  return i;
+}
+function Ue(n, t, e, i) {
+  if (tt(n))
+    return Q(e);
+  let r = [];
+  r = [
+    n[0],
+    n[1],
+    n[2],
+    n[1],
+    n[2],
+    n[3],
+    n[0],
+    n[3]
+  ], t(r, r, 2);
+  const s = [], o = [];
+  for (let u = 0, a = r.length; u < a; u += 2)
+    s.push(r[u]), o.push(r[u + 1]);
+  return Pe(s, o, e);
+}
+function Ve(n, t) {
+  const e = t.getExtent(), i = L(n);
+  if (t.canWrapX() && (i[0] < e[0] || i[0] >= e[2])) {
+    const r = A(e), o = Math.floor(
+      (i[0] - e[0]) / r
+    ) * r;
+    n[0] -= o, n[2] -= o;
+  }
+  return n;
+}
+function Dn(n, t) {
+  if (t.canWrapX()) {
+    const e = t.getExtent();
+    if (!isFinite(n[0]) || !isFinite(n[2]))
+      return [[e[0], n[1], e[2], n[3]]];
+    Ve(n, t);
+    const i = A(e);
+    if (A(n) > i)
+      return [[e[0], n[1], e[2], n[3]]];
+    if (n[0] < e[0])
+      return [
+        [n[0] + i, n[1], e[2], n[3]],
+        [e[0], n[1], n[2], n[3]]
+      ];
+    if (n[2] > e[2])
+      return [
+        [n[0], n[1], e[2], n[3]],
+        [e[0], n[1], n[2] - i, n[3]]
+      ];
+  }
+  return [n];
+}
+function De(n, t) {
+  return n[0] += +t[0], n[1] += +t[1], n;
+}
+function Wn(n, t) {
+  const e = t.getRadius(), i = t.getCenter(), r = i[0], s = i[1], o = n[0], u = n[1];
+  let a = o - r;
+  const h = u - s;
+  a === 0 && h === 0 && (a = 1);
+  const l = Math.sqrt(a * a + h * h), c = r + e * a / l, g = s + e * h / l;
+  return [c, g];
+}
+function We(n, t) {
+  const e = n[0], i = n[1], r = t[0], s = t[1], o = r[0], u = r[1], a = s[0], h = s[1], l = a - o, c = h - u, g = l === 0 && c === 0 ? 0 : (l * (e - o) + c * (i - u)) / (l * l + c * c || 0);
+  let f, d;
+  return g <= 0 ? (f = o, d = u) : g >= 1 ? (f = a, d = h) : (f = o + g * l, d = u + g * c), [f, d];
+}
+function B(n, t) {
+  let e = !0;
+  for (let i = n.length - 1; i >= 0; --i)
+    if (n[i] != t[i]) {
+      e = !1;
+      break;
+    }
+  return e;
+}
+function Ke(n, t) {
+  const e = Math.cos(t), i = Math.sin(t), r = n[0] * e - n[1] * i, s = n[1] * e + n[0] * i;
+  return n[0] = r, n[1] = s, n;
+}
+function Kn(n, t) {
+  return n[0] *= t, n[1] *= t, n;
+}
+function Dt(n, t) {
+  const e = n[0] - t[0], i = n[1] - t[1];
+  return e * e + i * i;
+}
+function kn(n, t) {
+  return Math.sqrt(Dt(n, t));
+}
+function Bn(n, t) {
+  return Dt(n, We(n, t));
+}
+function qn(n, t) {
+  if (t.canWrapX()) {
+    const e = A(t.getExtent()), i = ke(n, t, e);
+    i && (n[0] -= i * e);
+  }
+  return n;
+}
+function ke(n, t, e) {
+  const i = t.getExtent();
+  let r = 0;
+  return t.canWrapX() && (n[0] < i[0] || n[0] > i[2]) && (e = e || A(i), r = Math.floor(
+    (n[0] - i[0]) / e
+  )), r;
+}
+const Be = 63710088e-1;
+function At(n, t, e) {
+  e = e || Be;
+  const i = W(n[1]), r = W(t[1]), s = (r - i) / 2, o = W(t[0] - n[0]) / 2, u = Math.sin(s) * Math.sin(s) + Math.sin(o) * Math.sin(o) * Math.cos(i) * Math.cos(r);
+  return 2 * e * Math.atan2(Math.sqrt(u), Math.sqrt(1 - u));
+}
+function qe(...n) {
+  console.warn(...n);
+}
+let at = !0;
+function Wt(n) {
+  at = !1;
+}
+function ht(n, t) {
+  if (t !== void 0) {
+    for (let e = 0, i = n.length; e < i; ++e)
+      t[e] = n[e];
+    t = t;
+  } else
+    t = n.slice();
+  return t;
+}
+function Kt(n, t) {
+  if (t !== void 0 && n !== t) {
+    for (let e = 0, i = n.length; e < i; ++e)
+      t[e] = n[e];
+    n = t;
+  }
+  return n;
+}
+function He(n) {
+  Ae(n.getCode(), n), k(n, n, ht);
+}
+function $e(n) {
+  n.forEach(He);
+}
+function T(n) {
+  return typeof n == "string" ? pe(
+    /** @type {string} */
+    n
+  ) : (
+    /** @type {Projection} */
+    n || null
+  );
+}
+function Hn(n, t, e, i) {
+  n = T(n);
+  let r;
+  const s = n.getPointResolutionFunc();
+  if (s)
+    r = s(t, e);
+  else {
+    const o = n.getUnits();
+    if (o == "degrees" && !i || i == "degrees")
+      r = t;
+    else {
+      const u = gt(
+        n,
+        T("EPSG:4326")
+      );
+      if (u === Kt && o !== "degrees")
+        r = t * n.getMetersPerUnit();
+      else {
+        let h = [
+          e[0] - t / 2,
+          e[1],
+          e[0] + t / 2,
+          e[1],
+          e[0],
+          e[1] - t / 2,
+          e[0],
+          e[1] + t / 2
+        ];
+        h = u(h, h, 2);
+        const l = At(h.slice(0, 2), h.slice(2, 4)), c = At(h.slice(4, 6), h.slice(6, 8));
+        r = (l + c) / 2;
+      }
+      const a = n.getMetersPerUnit();
+      a !== void 0 && (r /= a);
+    }
+  }
+  return r;
+}
+function wt(n) {
+  $e(n), n.forEach(function(t) {
+    n.forEach(function(e) {
+      t !== e && k(t, e, ht);
+    });
+  });
+}
+function Je(n, t, e, i) {
+  n.forEach(function(r) {
+    t.forEach(function(s) {
+      k(r, s, e), k(s, r, i);
+    });
+  });
+}
+function ct(n, t) {
+  return n ? typeof n == "string" ? T(n) : (
+    /** @type {Projection} */
+    n
+  ) : T(t);
+}
+function $n(n, t) {
+  return Wt(), kt(
+    n,
+    "EPSG:4326",
+    "EPSG:3857"
+  );
+}
+function Jn(n, t) {
+  const e = kt(
+    n,
+    "EPSG:3857",
+    "EPSG:4326"
+  ), i = e[0];
+  return (i < -180 || i > 180) && (e[0] = K(i + 180, 360) - 180), e;
+}
+function Qn(n, t) {
+  if (n === t)
+    return !0;
+  const e = n.getUnits() === t.getUnits();
+  return (n.getCode() === t.getCode() || gt(n, t) === ht) && e;
+}
+function gt(n, t) {
+  const e = n.getCode(), i = t.getCode();
+  let r = we(e, i);
+  return r || (r = Kt), r;
+}
+function q(n, t) {
+  const e = T(n), i = T(t);
+  return gt(e, i);
+}
+function kt(n, t, e) {
+  return q(t, e)(n, void 0, n.length);
+}
+function ti(n, t, e, i) {
+  const r = q(t, e);
+  return Ue(n, r, void 0);
+}
+function Pt(n, t) {
+  return n;
+}
+function w(n, t) {
+  return at && !B(n, [0, 0]) && n[0] >= -180 && n[0] <= 180 && n[1] >= -90 && n[1] <= 90 && (at = !1, qe(
+    "Call useGeographic() from ol/proj once to work with [longitude, latitude] coordinates."
+  )), n;
+}
+function Qe(n, t) {
+  return n;
+}
+function V(n, t) {
+  return n;
+}
+function tn() {
+  wt(Et), wt(St), Je(
+    St,
+    Et,
+    Ce,
+    Ee
+  );
+}
+tn();
+new Array(6);
+function en() {
+  return [1, 0, 0, 1, 0, 0];
+}
+function nn(n, t, e, i, r, s, o) {
+  return n[0] = t, n[1] = e, n[2] = i, n[3] = r, n[4] = s, n[5] = o, n;
+}
+function ei(n, t) {
+  return n[0] = t[0], n[1] = t[1], n[2] = t[2], n[3] = t[3], n[4] = t[4], n[5] = t[5], n;
+}
+function ni(n, t) {
+  const e = t[0], i = t[1];
+  return t[0] = n[0] * e + n[2] * i + n[4], t[1] = n[1] * e + n[3] * i + n[5], t;
+}
+function ii(n, t, e) {
+  return nn(n, t, 0, 0, e, 0, 0);
+}
+function rn(n, t, e, i, r, s, o, u) {
+  const a = Math.sin(s), h = Math.cos(s);
+  return n[0] = i * h, n[1] = r * a, n[2] = -i * a, n[3] = r * h, n[4] = o * i * h - u * i * a + t, n[5] = o * r * a + u * r * h + e, n;
+}
+function ri(n, t) {
+  const e = sn(t);
+  p(e !== 0, 32);
+  const i = t[0], r = t[1], s = t[2], o = t[3], u = t[4], a = t[5];
+  return n[0] = o / e, n[1] = -r / e, n[2] = -s / e, n[3] = i / e, n[4] = (s * a - o * u) / e, n[5] = -(i * a - r * u) / e, n;
+}
+function sn(n) {
+  return n[0] * n[3] - n[1] * n[2];
+}
+let Tt;
+function si(n) {
+  const t = "matrix(" + n.join(", ") + ")";
+  if (ce)
+    return t;
+  const e = Tt || (Tt = document.createElement("div"));
+  return e.style.transform = t, e.style.transform;
+}
+const m = {
+  OPACITY: "opacity",
+  VISIBLE: "visible",
+  EXTENT: "extent",
+  Z_INDEX: "zIndex",
+  MAX_RESOLUTION: "maxResolution",
+  MIN_RESOLUTION: "minResolution",
+  MAX_ZOOM: "maxZoom",
+  MIN_ZOOM: "minZoom",
+  SOURCE: "source",
+  MAP: "map"
+};
+class on extends H {
+  /**
+   * @param {Options} options Layer options.
+   */
+  constructor(t) {
+    super(), this.on, this.once, this.un, this.background_ = t.background;
+    const e = Object.assign({}, t);
+    typeof t.properties == "object" && (delete e.properties, Object.assign(e, t.properties)), e[m.OPACITY] = t.opacity !== void 0 ? t.opacity : 1, p(typeof e[m.OPACITY] == "number", 64), e[m.VISIBLE] = t.visible !== void 0 ? t.visible : !0, e[m.Z_INDEX] = t.zIndex, e[m.MAX_RESOLUTION] = t.maxResolution !== void 0 ? t.maxResolution : 1 / 0, e[m.MIN_RESOLUTION] = t.minResolution !== void 0 ? t.minResolution : 0, e[m.MIN_ZOOM] = t.minZoom !== void 0 ? t.minZoom : -1 / 0, e[m.MAX_ZOOM] = t.maxZoom !== void 0 ? t.maxZoom : 1 / 0, this.className_ = e.className !== void 0 ? e.className : "ol-layer", delete e.className, this.setProperties(e), this.state_ = null;
+  }
+  /**
+   * Get the background for this layer.
+   * @return {BackgroundColor|false} Layer background.
+   */
+  getBackground() {
+    return this.background_;
+  }
+  /**
+   * @return {string} CSS class name.
+   */
+  getClassName() {
+    return this.className_;
+  }
+  /**
+   * This method is not meant to be called by layers or layer renderers because the state
+   * is incorrect if the layer is included in a layer group.
+   *
+   * @param {boolean} [managed] Layer is managed.
+   * @return {import("./Layer.js").State} Layer state.
+   */
+  getLayerState(t) {
+    const e = this.state_ || /** @type {?} */
+    {
+      layer: this,
+      managed: t === void 0 ? !0 : t
+    }, i = this.getZIndex();
+    return e.opacity = S(Math.round(this.getOpacity() * 100) / 100, 0, 1), e.visible = this.getVisible(), e.extent = this.getExtent(), e.zIndex = i === void 0 && !e.managed ? 1 / 0 : i, e.maxResolution = this.getMaxResolution(), e.minResolution = Math.max(this.getMinResolution(), 0), e.minZoom = this.getMinZoom(), e.maxZoom = this.getMaxZoom(), this.state_ = e, e;
+  }
+  /**
+   * @abstract
+   * @param {Array<import("./Layer.js").default>} [array] Array of layers (to be
+   *     modified in place).
+   * @return {Array<import("./Layer.js").default>} Array of layers.
+   */
+  getLayersArray(t) {
+    return E();
+  }
+  /**
+   * @abstract
+   * @param {Array<import("./Layer.js").State>} [states] Optional list of layer
+   *     states (to be modified in place).
+   * @return {Array<import("./Layer.js").State>} List of layer states.
+   */
+  getLayerStatesArray(t) {
+    return E();
+  }
+  /**
+   * Return the {@link module:ol/extent~Extent extent} of the layer or `undefined` if it
+   * will be visible regardless of extent.
+   * @return {import("../extent.js").Extent|undefined} The layer extent.
+   * @observable
+   * @api
+   */
+  getExtent() {
+    return (
+      /** @type {import("../extent.js").Extent|undefined} */
+      this.get(m.EXTENT)
+    );
+  }
+  /**
+   * Return the maximum resolution of the layer.
+   * @return {number} The maximum resolution of the layer.
+   * @observable
+   * @api
+   */
+  getMaxResolution() {
+    return (
+      /** @type {number} */
+      this.get(m.MAX_RESOLUTION)
+    );
+  }
+  /**
+   * Return the minimum resolution of the layer.
+   * @return {number} The minimum resolution of the layer.
+   * @observable
+   * @api
+   */
+  getMinResolution() {
+    return (
+      /** @type {number} */
+      this.get(m.MIN_RESOLUTION)
+    );
+  }
+  /**
+   * Return the minimum zoom level of the layer.
+   * @return {number} The minimum zoom level of the layer.
+   * @observable
+   * @api
+   */
+  getMinZoom() {
+    return (
+      /** @type {number} */
+      this.get(m.MIN_ZOOM)
+    );
+  }
+  /**
+   * Return the maximum zoom level of the layer.
+   * @return {number} The maximum zoom level of the layer.
+   * @observable
+   * @api
+   */
+  getMaxZoom() {
+    return (
+      /** @type {number} */
+      this.get(m.MAX_ZOOM)
+    );
+  }
+  /**
+   * Return the opacity of the layer (between 0 and 1).
+   * @return {number} The opacity of the layer.
+   * @observable
+   * @api
+   */
+  getOpacity() {
+    return (
+      /** @type {number} */
+      this.get(m.OPACITY)
+    );
+  }
+  /**
+   * @abstract
+   * @return {import("../source/Source.js").State} Source state.
+   */
+  getSourceState() {
+    return E();
+  }
+  /**
+   * Return the value of this layer's `visible` property. To find out whether the layer
+   * is visible on a map, use `isVisible()` instead.
+   * @return {boolean} The value of the `visible` property of the layer.
+   * @observable
+   * @api
+   */
+  getVisible() {
+    return (
+      /** @type {boolean} */
+      this.get(m.VISIBLE)
+    );
+  }
+  /**
+   * Return the Z-index of the layer, which is used to order layers before
+   * rendering. The default Z-index is 0.
+   * @return {number} The Z-index of the layer.
+   * @observable
+   * @api
+   */
+  getZIndex() {
+    return (
+      /** @type {number} */
+      this.get(m.Z_INDEX)
+    );
+  }
+  /**
+   * Sets the background color.
+   * @param {BackgroundColor} [background] Background color.
+   */
+  setBackground(t) {
+    this.background_ = t, this.changed();
+  }
+  /**
+   * Set the extent at which the layer is visible.  If `undefined`, the layer
+   * will be visible at all extents.
+   * @param {import("../extent.js").Extent|undefined} extent The extent of the layer.
+   * @observable
+   * @api
+   */
+  setExtent(t) {
+    this.set(m.EXTENT, t);
+  }
+  /**
+   * Set the maximum resolution at which the layer is visible.
+   * @param {number} maxResolution The maximum resolution of the layer.
+   * @observable
+   * @api
+   */
+  setMaxResolution(t) {
+    this.set(m.MAX_RESOLUTION, t);
+  }
+  /**
+   * Set the minimum resolution at which the layer is visible.
+   * @param {number} minResolution The minimum resolution of the layer.
+   * @observable
+   * @api
+   */
+  setMinResolution(t) {
+    this.set(m.MIN_RESOLUTION, t);
+  }
+  /**
+   * Set the maximum zoom (exclusive) at which the layer is visible.
+   * Note that the zoom levels for layer visibility are based on the
+   * view zoom level, which may be different from a tile source zoom level.
+   * @param {number} maxZoom The maximum zoom of the layer.
+   * @observable
+   * @api
+   */
+  setMaxZoom(t) {
+    this.set(m.MAX_ZOOM, t);
+  }
+  /**
+   * Set the minimum zoom (inclusive) at which the layer is visible.
+   * Note that the zoom levels for layer visibility are based on the
+   * view zoom level, which may be different from a tile source zoom level.
+   * @param {number} minZoom The minimum zoom of the layer.
+   * @observable
+   * @api
+   */
+  setMinZoom(t) {
+    this.set(m.MIN_ZOOM, t);
+  }
+  /**
+   * Set the opacity of the layer, allowed values range from 0 to 1.
+   * @param {number} opacity The opacity of the layer.
+   * @observable
+   * @api
+   */
+  setOpacity(t) {
+    p(typeof t == "number", 64), this.set(m.OPACITY, t);
+  }
+  /**
+   * Set the visibility of the layer (`true` or `false`).
+   * @param {boolean} visible The visibility of the layer.
+   * @observable
+   * @api
+   */
+  setVisible(t) {
+    this.set(m.VISIBLE, t);
+  }
+  /**
+   * Set Z-index of the layer, which is used to order layers before rendering.
+   * The default Z-index is 0.
+   * @param {number} zindex The z-index of the layer.
+   * @observable
+   * @api
+   */
+  setZIndex(t) {
+    this.set(m.Z_INDEX, t);
+  }
+  /**
+   * Clean up.
+   */
+  disposeInternal() {
+    this.state_ && (this.state_.layer = null, this.state_ = null), super.disposeInternal();
+  }
+}
+const an = {
+  /**
+   * Triggered before a layer is rendered.
+   * @event module:ol/render/Event~RenderEvent#prerender
+   * @api
+   */
+  PRERENDER: "prerender",
+  /**
+   * Triggered after a layer is rendered.
+   * @event module:ol/render/Event~RenderEvent#postrender
+   * @api
+   */
+  POSTRENDER: "postrender",
+  /**
+   * Triggered before layers are composed.  When dispatched by the map, the event object will not have
+   * a `context` set.  When dispatched by a layer, the event object will have a `context` set.  Only
+   * WebGL layers currently dispatch this event.
+   * @event module:ol/render/Event~RenderEvent#precompose
+   * @api
+   */
+  PRECOMPOSE: "precompose",
+  /**
+   * Triggered after layers are composed.  When dispatched by the map, the event object will not have
+   * a `context` set.  When dispatched by a layer, the event object will have a `context` set.  Only
+   * WebGL layers currently dispatch this event.
+   * @event module:ol/render/Event~RenderEvent#postcompose
+   * @api
+   */
+  POSTCOMPOSE: "postcompose",
+  /**
+   * Triggered when rendering is complete, i.e. all sources and tiles have
+   * finished loading for the current viewport, and all tiles are faded in.
+   * The event object will not have a `context` set.
+   * @event module:ol/render/Event~RenderEvent#rendercomplete
+   * @api
+   */
+  RENDERCOMPLETE: "rendercomplete"
+}, P = {
+  ANIMATING: 0,
+  INTERACTING: 1
+}, I = {
+  CENTER: "center",
+  RESOLUTION: "resolution",
+  ROTATION: "rotation"
+}, un = 256;
+function Nt(n, t, e) {
+  return (
+    /**
+     * @param {import("./coordinate.js").Coordinate|undefined} center Center.
+     * @param {number|undefined} resolution Resolution.
+     * @param {import("./size.js").Size} size Viewport size; unused if `onlyCenter` was specified.
+     * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+     * @param {Array<number>} [centerShift] Shift between map center and viewport center.
+     * @return {import("./coordinate.js").Coordinate|undefined} Center.
+     */
+    function(i, r, s, o, u) {
+      if (!i)
+        return;
+      if (!r && !t)
+        return i;
+      const a = t ? 0 : s[0] * r, h = t ? 0 : s[1] * r, l = u ? u[0] : 0, c = u ? u[1] : 0;
+      let g = n[0] + a / 2 + l, f = n[2] - a / 2 + l, d = n[1] + h / 2 + c, R = n[3] - h / 2 + c;
+      g > f && (g = (f + g) / 2, f = g), d > R && (d = (R + d) / 2, R = d);
+      let _ = S(i[0], g, f), M = S(i[1], d, R);
+      if (o && e && r) {
+        const y = 30 * r;
+        _ += -y * Math.log(1 + Math.max(0, g - i[0]) / y) + y * Math.log(1 + Math.max(0, i[0] - f) / y), M += -y * Math.log(1 + Math.max(0, d - i[1]) / y) + y * Math.log(1 + Math.max(0, i[1] - R) / y);
+      }
+      return [_, M];
+    }
+  );
+}
+function ln(n) {
+  return n;
+}
+function ft(n, t, e, i) {
+  const r = A(t) / e[0], s = X(t) / e[1];
+  return i ? Math.min(n, Math.max(r, s)) : Math.min(n, Math.min(r, s));
+}
+function dt(n, t, e) {
+  let i = Math.min(n, t);
+  const r = 50;
+  return i *= Math.log(1 + r * Math.max(0, n / t - 1)) / r + 1, e && (i = Math.max(i, e), i /= Math.log(1 + r * Math.max(0, e / n - 1)) / r + 1), S(i, e / 2, t * 2);
+}
+function hn(n, t, e, i) {
+  return t = t !== void 0 ? t : !0, /**
+   * @param {number|undefined} resolution Resolution.
+   * @param {number} direction Direction.
+   * @param {import("./size.js").Size} size Viewport size.
+   * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+   * @return {number|undefined} Resolution.
+   */
+  function(r, s, o, u) {
+    if (r !== void 0) {
+      const a = n[0], h = n[n.length - 1], l = e ? ft(
+        a,
+        e,
+        o,
+        i
+      ) : a;
+      if (u)
+        return t ? dt(
+          r,
+          l,
+          h
+        ) : S(r, h, l);
+      const c = Math.min(l, r), g = Math.floor(Lt(n, c, s));
+      return n[g] > l && g < n.length - 1 ? n[g + 1] : n[g];
+    }
+  };
+}
+function cn(n, t, e, i, r, s) {
+  return i = i !== void 0 ? i : !0, e = e !== void 0 ? e : 0, /**
+   * @param {number|undefined} resolution Resolution.
+   * @param {number} direction Direction.
+   * @param {import("./size.js").Size} size Viewport size.
+   * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+   * @return {number|undefined} Resolution.
+   */
+  function(o, u, a, h) {
+    if (o !== void 0) {
+      const l = r ? ft(
+        t,
+        r,
+        a,
+        s
+      ) : t;
+      if (h)
+        return i ? dt(
+          o,
+          l,
+          e
+        ) : S(o, e, l);
+      const c = 1e-9, g = Math.ceil(
+        Math.log(t / l) / Math.log(n) - c
+      ), f = -u * (0.5 - c) + 0.5, d = Math.min(l, o), R = Math.floor(
+        Math.log(t / d) / Math.log(n) + f
+      ), _ = Math.max(g, R), M = t / Math.pow(n, _);
+      return S(M, e, l);
+    }
+  };
+}
+function Ot(n, t, e, i, r) {
+  return e = e !== void 0 ? e : !0, /**
+   * @param {number|undefined} resolution Resolution.
+   * @param {number} direction Direction.
+   * @param {import("./size.js").Size} size Viewport size.
+   * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+   * @return {number|undefined} Resolution.
+   */
+  function(s, o, u, a) {
+    if (s !== void 0) {
+      const h = i ? ft(
+        n,
+        i,
+        u,
+        r
+      ) : n;
+      return !e || !a ? S(s, t, h) : dt(
+        s,
+        h,
+        t
+      );
+    }
+  };
+}
+function gn(n) {
+  if (n !== void 0)
+    return 0;
+}
+function xt(n) {
+  if (n !== void 0)
+    return n;
+}
+function fn(n) {
+  const t = 2 * Math.PI / n;
+  return (
+    /**
+     * @param {number|undefined} rotation Rotation.
+     * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+     * @return {number|undefined} Rotation.
+     */
+    function(e, i) {
+      if (i)
+        return e;
+      if (e !== void 0)
+        return e = Math.floor(e / t + 0.5) * t, e;
+    }
+  );
+}
+function dn(n) {
+  return n = n || W(5), /**
+   * @param {number|undefined} rotation Rotation.
+   * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+   * @return {number|undefined} Rotation.
+   */
+  function(t, e) {
+    if (e)
+      return t;
+    if (t !== void 0)
+      return Math.abs(t) <= n ? 0 : t;
+  };
+}
+function Rn(n) {
+  return Math.pow(n, 3);
+}
+function _n(n) {
+  return 1 - Rn(1 - n);
+}
+function mn(n) {
+  return 3 * n * n - 2 * n * n * n;
+}
+function oi(n) {
+  return n;
+}
+function Bt(n, t, e, i, r, s) {
+  s = s || [];
+  let o = 0;
+  for (let u = t; u < e; u += i) {
+    const a = n[u], h = n[u + 1];
+    s[o++] = r[0] * a + r[2] * h + r[4], s[o++] = r[1] * a + r[3] * h + r[5];
+  }
+  return s && s.length != o && (s.length = o), s;
+}
+function yn(n, t, e, i, r, s, o) {
+  o = o || [];
+  const u = Math.cos(r), a = Math.sin(r), h = s[0], l = s[1];
+  let c = 0;
+  for (let g = t; g < e; g += i) {
+    const f = n[g] - h, d = n[g + 1] - l;
+    o[c++] = h + f * u - d * a, o[c++] = l + f * a + d * u;
+    for (let R = g + 2; R < g + i; ++R)
+      o[c++] = n[R];
+  }
+  return o && o.length != c && (o.length = c), o;
+}
+function Mn(n, t, e, i, r, s, o, u) {
+  u = u || [];
+  const a = o[0], h = o[1];
+  let l = 0;
+  for (let c = t; c < e; c += i) {
+    const g = n[c] - a, f = n[c + 1] - h;
+    u[l++] = a + r * g, u[l++] = h + s * f;
+    for (let d = c + 2; d < c + i; ++d)
+      u[l++] = n[d];
+  }
+  return u && u.length != l && (u.length = l), u;
+}
+function Cn(n, t, e, i, r, s, o) {
+  o = o || [];
+  let u = 0;
+  for (let a = t; a < e; a += i) {
+    o[u++] = n[a] + r, o[u++] = n[a + 1] + s;
+    for (let h = a + 2; h < a + i; ++h)
+      o[u++] = n[h];
+  }
+  return o && o.length != u && (o.length = u), o;
+}
+const Ft = en();
+class En extends H {
+  constructor() {
+    super(), this.extent_ = $(), this.extentRevision_ = -1, this.simplifiedGeometryMaxMinSquaredTolerance = 0, this.simplifiedGeometryRevision = 0, this.simplifyTransformedInternal = ge(function(t, e, i) {
+      if (!i)
+        return this.getSimplifiedGeometry(e);
+      const r = this.clone();
+      return r.applyTransform(i), r.getSimplifiedGeometry(e);
+    });
+  }
+  /**
+   * Get a transformed and simplified version of the geometry.
+   * @abstract
+   * @param {number} squaredTolerance Squared tolerance.
+   * @param {import("../proj.js").TransformFunction} [transform] Optional transform function.
+   * @return {Geometry} Simplified geometry.
+   */
+  simplifyTransformed(t, e) {
+    return this.simplifyTransformedInternal(
+      this.getRevision(),
+      t,
+      e
+    );
+  }
+  /**
+   * Make a complete copy of the geometry.
+   * @abstract
+   * @return {!Geometry} Clone.
+   */
+  clone() {
+    return E();
+  }
+  /**
+   * @abstract
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @param {import("../coordinate.js").Coordinate} closestPoint Closest point.
+   * @param {number} minSquaredDistance Minimum squared distance.
+   * @return {number} Minimum squared distance.
+   */
+  closestPointXY(t, e, i, r) {
+    return E();
+  }
+  /**
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @return {boolean} Contains (x, y).
+   */
+  containsXY(t, e) {
+    const i = this.getClosestPoint([t, e]);
+    return i[0] === t && i[1] === e;
+  }
+  /**
+   * Return the closest point of the geometry to the passed point as
+   * {@link module:ol/coordinate~Coordinate coordinate}.
+   * @param {import("../coordinate.js").Coordinate} point Point.
+   * @param {import("../coordinate.js").Coordinate} [closestPoint] Closest point.
+   * @return {import("../coordinate.js").Coordinate} Closest point.
+   * @api
+   */
+  getClosestPoint(t, e) {
+    return e = e || [NaN, NaN], this.closestPointXY(t[0], t[1], e, 1 / 0), e;
+  }
+  /**
+   * Returns true if this geometry includes the specified coordinate. If the
+   * coordinate is on the boundary of the geometry, returns false.
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @return {boolean} Contains coordinate.
+   * @api
+   */
+  intersectsCoordinate(t) {
+    return this.containsXY(t[0], t[1]);
+  }
+  /**
+   * @abstract
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @protected
+   * @return {import("../extent.js").Extent} extent Extent.
+   */
+  computeExtent(t) {
+    return E();
+  }
+  /**
+   * Get the extent of the geometry.
+   * @param {import("../extent.js").Extent} [extent] Extent.
+   * @return {import("../extent.js").Extent} extent Extent.
+   * @api
+   */
+  getExtent(t) {
+    if (this.extentRevision_ != this.getRevision()) {
+      const e = this.computeExtent(this.extent_);
+      (isNaN(e[0]) || isNaN(e[1])) && Q(e), this.extentRevision_ = this.getRevision();
+    }
+    return Ye(this.extent_, t);
+  }
+  /**
+   * Rotate the geometry around a given coordinate. This modifies the geometry
+   * coordinates in place.
+   * @abstract
+   * @param {number} angle Rotation angle in radians.
+   * @param {import("../coordinate.js").Coordinate} anchor The rotation center.
+   * @api
+   */
+  rotate(t, e) {
+    E();
+  }
+  /**
+   * Scale the geometry (with an optional origin).  This modifies the geometry
+   * coordinates in place.
+   * @abstract
+   * @param {number} sx The scaling factor in the x-direction.
+   * @param {number} [sy] The scaling factor in the y-direction (defaults to sx).
+   * @param {import("../coordinate.js").Coordinate} [anchor] The scale origin (defaults to the center
+   *     of the geometry extent).
+   * @api
+   */
+  scale(t, e, i) {
+    E();
+  }
+  /**
+   * Create a simplified version of this geometry.  For linestrings, this uses
+   * the [Douglas Peucker](https://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm)
+   * algorithm.  For polygons, a quantization-based
+   * simplification is used to preserve topology.
+   * @param {number} tolerance The tolerance distance for simplification.
+   * @return {Geometry} A new, simplified version of the original geometry.
+   * @api
+   */
+  simplify(t) {
+    return this.getSimplifiedGeometry(t * t);
+  }
+  /**
+   * Create a simplified version of this geometry using the Douglas Peucker
+   * algorithm.
+   * See https://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm.
+   * @abstract
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {Geometry} Simplified geometry.
+   */
+  getSimplifiedGeometry(t) {
+    return E();
+  }
+  /**
+   * Get the type of this geometry.
+   * @abstract
+   * @return {Type} Geometry type.
+   */
+  getType() {
+    return E();
+  }
+  /**
+   * Apply a transform function to the coordinates of the geometry.
+   * The geometry is modified in place.
+   * If you do not want the geometry modified in place, first `clone()` it and
+   * then use this function on the clone.
+   * @abstract
+   * @param {import("../proj.js").TransformFunction} transformFn Transform function.
+   * Called with a flat array of geometry coordinates.
+   */
+  applyTransform(t) {
+    E();
+  }
+  /**
+   * Test if the geometry and the passed extent intersect.
+   * @abstract
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @return {boolean} `true` if the geometry and the extent intersect.
+   */
+  intersectsExtent(t) {
+    return E();
+  }
+  /**
+   * Translate the geometry.  This modifies the geometry coordinates in place.  If
+   * instead you want a new geometry, first `clone()` this geometry.
+   * @abstract
+   * @param {number} deltaX Delta X.
+   * @param {number} deltaY Delta Y.
+   * @api
+   */
+  translate(t, e) {
+    E();
+  }
+  /**
+   * Transform each coordinate of the geometry from one coordinate reference
+   * system to another. The geometry is modified in place.
+   * For example, a line will be transformed to a line and a circle to a circle.
+   * If you do not want the geometry modified in place, first `clone()` it and
+   * then use this function on the clone.
+   *
+   * @param {import("../proj.js").ProjectionLike} source The current projection.  Can be a
+   *     string identifier or a {@link module:ol/proj/Projection~Projection} object.
+   * @param {import("../proj.js").ProjectionLike} destination The desired projection.  Can be a
+   *     string identifier or a {@link module:ol/proj/Projection~Projection} object.
+   * @return {Geometry} This geometry.  Note that original geometry is
+   *     modified in place.
+   * @api
+   */
+  transform(t, e) {
+    const i = T(t), r = i.getUnits() == "tile-pixels" ? function(s, o, u) {
+      const a = i.getExtent(), h = i.getWorldExtent(), l = X(h) / X(a);
+      return rn(
+        Ft,
+        h[0],
+        h[3],
+        l,
+        -l,
+        0,
+        0,
+        0
+      ), Bt(
+        s,
+        0,
+        s.length,
+        u,
+        Ft,
+        o
+      ), q(i, e)(
+        s,
+        o,
+        u
+      );
+    } : q(i, e);
+    return this.applyTransform(r), this;
+  }
+}
+class Rt extends En {
+  constructor() {
+    super(), this.layout = "XY", this.stride = 2, this.flatCoordinates = null;
+  }
+  /**
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @protected
+   * @return {import("../extent.js").Extent} extent Extent.
+   */
+  computeExtent(t) {
+    return Oe(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      t
+    );
+  }
+  /**
+   * @abstract
+   * @return {Array<*> | null} Coordinates.
+   */
+  getCoordinates() {
+    return E();
+  }
+  /**
+   * Return the first coordinate of the geometry.
+   * @return {import("../coordinate.js").Coordinate} First coordinate.
+   * @api
+   */
+  getFirstCoordinate() {
+    return this.flatCoordinates.slice(0, this.stride);
+  }
+  /**
+   * @return {Array<number>} Flat coordinates.
+   */
+  getFlatCoordinates() {
+    return this.flatCoordinates;
+  }
+  /**
+   * Return the last coordinate of the geometry.
+   * @return {import("../coordinate.js").Coordinate} Last point.
+   * @api
+   */
+  getLastCoordinate() {
+    return this.flatCoordinates.slice(
+      this.flatCoordinates.length - this.stride
+    );
+  }
+  /**
+   * Return the {@link import("./Geometry.js").GeometryLayout layout} of the geometry.
+   * @return {import("./Geometry.js").GeometryLayout} Layout.
+   * @api
+   */
+  getLayout() {
+    return this.layout;
+  }
+  /**
+   * Create a simplified version of this geometry using the Douglas Peucker algorithm.
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {SimpleGeometry} Simplified geometry.
+   */
+  getSimplifiedGeometry(t) {
+    if (this.simplifiedGeometryRevision !== this.getRevision() && (this.simplifiedGeometryMaxMinSquaredTolerance = 0, this.simplifiedGeometryRevision = this.getRevision()), t < 0 || this.simplifiedGeometryMaxMinSquaredTolerance !== 0 && t <= this.simplifiedGeometryMaxMinSquaredTolerance)
+      return this;
+    const e = this.getSimplifiedGeometryInternal(t);
+    return e.getFlatCoordinates().length < this.flatCoordinates.length ? e : (this.simplifiedGeometryMaxMinSquaredTolerance = t, this);
+  }
+  /**
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {SimpleGeometry} Simplified geometry.
+   * @protected
+   */
+  getSimplifiedGeometryInternal(t) {
+    return this;
+  }
+  /**
+   * @return {number} Stride.
+   */
+  getStride() {
+    return this.stride;
+  }
+  /**
+   * @param {import("./Geometry.js").GeometryLayout} layout Layout.
+   * @param {Array<number>} flatCoordinates Flat coordinates.
+   */
+  setFlatCoordinates(t, e) {
+    this.stride = Zt(t), this.layout = t, this.flatCoordinates = e;
+  }
+  /**
+   * @abstract
+   * @param {!Array<*>} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   */
+  setCoordinates(t, e) {
+    E();
+  }
+  /**
+   * @param {import("./Geometry.js").GeometryLayout|undefined} layout Layout.
+   * @param {Array<*>} coordinates Coordinates.
+   * @param {number} nesting Nesting.
+   * @protected
+   */
+  setLayout(t, e, i) {
+    let r;
+    if (t)
+      r = Zt(t);
+    else {
+      for (let s = 0; s < i; ++s) {
+        if (e.length === 0) {
+          this.layout = "XY", this.stride = 2;
+          return;
+        }
+        e = /** @type {Array} */
+        e[0];
+      }
+      r = e.length, t = In(r);
+    }
+    this.layout = t, this.stride = r;
+  }
+  /**
+   * Apply a transform function to the coordinates of the geometry.
+   * The geometry is modified in place.
+   * If you do not want the geometry modified in place, first `clone()` it and
+   * then use this function on the clone.
+   * @param {import("../proj.js").TransformFunction} transformFn Transform function.
+   * Called with a flat array of geometry coordinates.
+   * @api
+   */
+  applyTransform(t) {
+    this.flatCoordinates && (t(this.flatCoordinates, this.flatCoordinates, this.stride), this.changed());
+  }
+  /**
+   * Rotate the geometry around a given coordinate. This modifies the geometry
+   * coordinates in place.
+   * @param {number} angle Rotation angle in counter-clockwise radians.
+   * @param {import("../coordinate.js").Coordinate} anchor The rotation center.
+   * @api
+   */
+  rotate(t, e) {
+    const i = this.getFlatCoordinates();
+    if (i) {
+      const r = this.getStride();
+      yn(
+        i,
+        0,
+        i.length,
+        r,
+        t,
+        e,
+        i
+      ), this.changed();
+    }
+  }
+  /**
+   * Scale the geometry (with an optional origin).  This modifies the geometry
+   * coordinates in place.
+   * @param {number} sx The scaling factor in the x-direction.
+   * @param {number} [sy] The scaling factor in the y-direction (defaults to sx).
+   * @param {import("../coordinate.js").Coordinate} [anchor] The scale origin (defaults to the center
+   *     of the geometry extent).
+   * @api
+   */
+  scale(t, e, i) {
+    e === void 0 && (e = t), i || (i = L(this.getExtent()));
+    const r = this.getFlatCoordinates();
+    if (r) {
+      const s = this.getStride();
+      Mn(
+        r,
+        0,
+        r.length,
+        s,
+        t,
+        e,
+        i,
+        r
+      ), this.changed();
+    }
+  }
+  /**
+   * Translate the geometry.  This modifies the geometry coordinates in place.  If
+   * instead you want a new geometry, first `clone()` this geometry.
+   * @param {number} deltaX Delta X.
+   * @param {number} deltaY Delta Y.
+   * @api
+   */
+  translate(t, e) {
+    const i = this.getFlatCoordinates();
+    if (i) {
+      const r = this.getStride();
+      Cn(
+        i,
+        0,
+        i.length,
+        r,
+        t,
+        e,
+        i
+      ), this.changed();
+    }
+  }
+}
+function In(n) {
+  let t;
+  return n == 2 ? t = "XY" : n == 3 ? t = "XYZ" : n == 4 && (t = "XYZM"), /** @type {import("./Geometry.js").GeometryLayout} */
+  t;
+}
+function Zt(n) {
+  let t;
+  return n == "XY" ? t = 2 : n == "XYZ" || n == "XYM" ? t = 3 : n == "XYZM" && (t = 4), /** @type {number} */
+  t;
+}
+function ai(n, t, e) {
+  const i = n.getFlatCoordinates();
+  if (!i)
+    return null;
+  const r = n.getStride();
+  return Bt(
+    i,
+    0,
+    i.length,
+    r,
+    t,
+    e
+  );
+}
+function bt(n, t, e, i, r, s, o) {
+  const u = n[t], a = n[t + 1], h = n[e] - u, l = n[e + 1] - a;
+  let c;
+  if (h === 0 && l === 0)
+    c = t;
+  else {
+    const g = ((r - u) * h + (s - a) * l) / (h * h + l * l);
+    if (g > 1)
+      c = e;
+    else if (g > 0) {
+      for (let f = 0; f < i; ++f)
+        o[f] = fe(
+          n[t + f],
+          n[e + f],
+          g
+        );
+      o.length = i;
+      return;
+    } else
+      c = t;
+  }
+  for (let g = 0; g < i; ++g)
+    o[g] = n[c + g];
+  o.length = i;
+}
+function qt(n, t, e, i, r) {
+  let s = n[t], o = n[t + 1];
+  for (t += i; t < e; t += i) {
+    const u = n[t], a = n[t + 1], h = j(s, o, u, a);
+    h > r && (r = h), s = u, o = a;
+  }
+  return r;
+}
+function Ht(n, t, e, i, r) {
+  for (let s = 0, o = e.length; s < o; ++s) {
+    const u = e[s];
+    r = qt(n, t, u, i, r), t = u;
+  }
+  return r;
+}
+function ui(n, t, e, i, r) {
+  for (let s = 0, o = e.length; s < o; ++s) {
+    const u = e[s];
+    r = Ht(n, t, u, i, r), t = u[u.length - 1];
+  }
+  return r;
+}
+function $t(n, t, e, i, r, s, o, u, a, h, l) {
+  if (t == e)
+    return h;
+  let c, g;
+  if (r === 0) {
+    if (g = j(
+      o,
+      u,
+      n[t],
+      n[t + 1]
+    ), g < h) {
+      for (c = 0; c < i; ++c)
+        a[c] = n[t + c];
+      return a.length = i, g;
+    }
+    return h;
+  }
+  l = l || [NaN, NaN];
+  let f = t + i;
+  for (; f < e; )
+    if (bt(
+      n,
+      f - i,
+      f,
+      i,
+      o,
+      u,
+      l
+    ), g = j(o, u, l[0], l[1]), g < h) {
+      for (h = g, c = 0; c < i; ++c)
+        a[c] = l[c];
+      a.length = i, f += i;
+    } else
+      f += i * Math.max(
+        (Math.sqrt(g) - Math.sqrt(h)) / r | 0,
+        1
+      );
+  if (s && (bt(
+    n,
+    e - i,
+    t,
+    i,
+    o,
+    u,
+    l
+  ), g = j(o, u, l[0], l[1]), g < h)) {
+    for (h = g, c = 0; c < i; ++c)
+      a[c] = l[c];
+    a.length = i;
+  }
+  return h;
+}
+function Jt(n, t, e, i, r, s, o, u, a, h, l) {
+  l = l || [NaN, NaN];
+  for (let c = 0, g = e.length; c < g; ++c) {
+    const f = e[c];
+    h = $t(
+      n,
+      t,
+      f,
+      i,
+      r,
+      s,
+      o,
+      u,
+      a,
+      h,
+      l
+    ), t = f;
+  }
+  return h;
+}
+function li(n, t, e, i, r, s, o, u, a, h, l) {
+  l = l || [NaN, NaN];
+  for (let c = 0, g = e.length; c < g; ++c) {
+    const f = e[c];
+    h = Jt(
+      n,
+      t,
+      f,
+      i,
+      r,
+      s,
+      o,
+      u,
+      a,
+      h,
+      l
+    ), t = f[f.length - 1];
+  }
+  return h;
+}
+function Sn(n, t, e, i) {
+  for (let r = 0, s = e.length; r < s; ++r)
+    n[t++] = e[r];
+  return t;
+}
+function Qt(n, t, e, i) {
+  for (let r = 0, s = e.length; r < s; ++r) {
+    const o = e[r];
+    for (let u = 0; u < i; ++u)
+      n[t++] = o[u];
+  }
+  return t;
+}
+function te(n, t, e, i, r) {
+  r = r || [];
+  let s = 0;
+  for (let o = 0, u = e.length; o < u; ++o) {
+    const a = Qt(
+      n,
+      t,
+      e[o],
+      i
+    );
+    r[s++] = a, t = a;
+  }
+  return r.length = s, r;
+}
+function hi(n, t, e, i, r) {
+  r = r || [];
+  let s = 0;
+  for (let o = 0, u = e.length; o < u; ++o) {
+    const a = te(
+      n,
+      t,
+      e[o],
+      i,
+      r[s]
+    );
+    a.length === 0 && (a[0] = t), r[s++] = a, t = a[a.length - 1];
+  }
+  return r.length = s, r;
+}
+function ee(n, t, e, i, r, s, o) {
+  const u = (e - t) / i;
+  if (u < 3) {
+    for (; t < e; t += i)
+      s[o++] = n[t], s[o++] = n[t + 1];
+    return o;
+  }
+  const a = new Array(u);
+  a[0] = 1, a[u - 1] = 1;
+  const h = [t, e - i];
+  let l = 0;
+  for (; h.length > 0; ) {
+    const c = h.pop(), g = h.pop();
+    let f = 0;
+    const d = n[g], R = n[g + 1], _ = n[c], M = n[c + 1];
+    for (let y = g + i; y < c; y += i) {
+      const et = n[y], G = n[y + 1], Mt = de(et, G, d, R, _, M);
+      Mt > f && (l = y, f = Mt);
+    }
+    f > r && (a[(l - t) / i] = 1, g + i < l && h.push(g, l), l + i < c && h.push(l, c));
+  }
+  for (let c = 0; c < u; ++c)
+    a[c] && (s[o++] = n[t + c * i], s[o++] = n[t + c * i + 1]);
+  return o;
+}
+function ci(n, t, e, i, r, s, o, u) {
+  for (let a = 0, h = e.length; a < h; ++a) {
+    const l = e[a];
+    o = ee(
+      n,
+      t,
+      l,
+      i,
+      r,
+      s,
+      o
+    ), u.push(o), t = l;
+  }
+  return o;
+}
+function F(n, t) {
+  return t * Math.round(n / t);
+}
+function pn(n, t, e, i, r, s, o) {
+  if (t == e)
+    return o;
+  let u = F(n[t], r), a = F(n[t + 1], r);
+  t += i, s[o++] = u, s[o++] = a;
+  let h, l;
+  do
+    if (h = F(n[t], r), l = F(n[t + 1], r), t += i, t == e)
+      return s[o++] = h, s[o++] = l, o;
+  while (h == u && l == a);
+  for (; t < e; ) {
+    const c = F(n[t], r), g = F(n[t + 1], r);
+    if (t += i, c == h && g == l)
+      continue;
+    const f = h - u, d = l - a, R = c - u, _ = g - a;
+    if (f * _ == d * R && (f < 0 && R < f || f == R || f > 0 && R > f) && (d < 0 && _ < d || d == _ || d > 0 && _ > d)) {
+      h = c, l = g;
+      continue;
+    }
+    s[o++] = h, s[o++] = l, u = h, a = l, h = c, l = g;
+  }
+  return s[o++] = h, s[o++] = l, o;
+}
+function ne(n, t, e, i, r, s, o, u) {
+  for (let a = 0, h = e.length; a < h; ++a) {
+    const l = e[a];
+    o = pn(
+      n,
+      t,
+      l,
+      i,
+      r,
+      s,
+      o
+    ), u.push(o), t = l;
+  }
+  return o;
+}
+function gi(n, t, e, i, r, s, o, u) {
+  for (let a = 0, h = e.length; a < h; ++a) {
+    const l = e[a], c = [];
+    o = ne(
+      n,
+      t,
+      l,
+      i,
+      r,
+      s,
+      o,
+      c
+    ), u.push(c), t = l[l.length - 1];
+  }
+  return o;
+}
+function ie(n, t, e, i, r) {
+  r = r !== void 0 ? r : [];
+  let s = 0;
+  for (let o = t; o < e; o += i)
+    r[s++] = n.slice(o, o + i);
+  return r.length = s, r;
+}
+function re(n, t, e, i, r) {
+  r = r !== void 0 ? r : [];
+  let s = 0;
+  for (let o = 0, u = e.length; o < u; ++o) {
+    const a = e[o];
+    r[s++] = ie(
+      n,
+      t,
+      a,
+      i,
+      r[s]
+    ), t = a;
+  }
+  return r.length = s, r;
+}
+function fi(n, t, e, i, r) {
+  r = r !== void 0 ? r : [];
+  let s = 0;
+  for (let o = 0, u = e.length; o < u; ++o) {
+    const a = e[o];
+    r[s++] = a.length === 1 && a[0] === t ? [] : re(
+      n,
+      t,
+      a,
+      i,
+      r[s]
+    ), t = a[a.length - 1];
+  }
+  return r.length = s, r;
+}
+function se(n, t, e, i) {
+  let r = 0, s = n[e - i], o = n[e - i + 1];
+  for (; t < e; t += i) {
+    const u = n[t], a = n[t + 1];
+    r += o * u - s * a, s = u, o = a;
+  }
+  return r / 2;
+}
+function oe(n, t, e, i) {
+  let r = 0;
+  for (let s = 0, o = e.length; s < o; ++s) {
+    const u = e[s];
+    r += se(n, t, u, i), t = u;
+  }
+  return r;
+}
+function di(n, t, e, i) {
+  let r = 0;
+  for (let s = 0, o = e.length; s < o; ++s) {
+    const u = e[s];
+    r += oe(n, t, u, i), t = u[u.length - 1];
+  }
+  return r;
+}
+class v extends Rt {
+  /**
+   * @param {Array<import("../coordinate.js").Coordinate>|Array<number>} coordinates Coordinates.
+   *     For internal use, flat coordinates in combination with `layout` are also accepted.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   */
+  constructor(t, e) {
+    super(), this.maxDelta_ = -1, this.maxDeltaRevision_ = -1, e !== void 0 && !Array.isArray(t[0]) ? this.setFlatCoordinates(
+      e,
+      /** @type {Array<number>} */
+      t
+    ) : this.setCoordinates(
+      /** @type {Array<import("../coordinate.js").Coordinate>} */
+      t,
+      e
+    );
+  }
+  /**
+   * Make a complete copy of the geometry.
+   * @return {!LinearRing} Clone.
+   * @api
+   */
+  clone() {
+    return new v(this.flatCoordinates.slice(), this.layout);
+  }
+  /**
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @param {import("../coordinate.js").Coordinate} closestPoint Closest point.
+   * @param {number} minSquaredDistance Minimum squared distance.
+   * @return {number} Minimum squared distance.
+   */
+  closestPointXY(t, e, i, r) {
+    return r < zt(this.getExtent(), t, e) ? r : (this.maxDeltaRevision_ != this.getRevision() && (this.maxDelta_ = Math.sqrt(
+      qt(
+        this.flatCoordinates,
+        0,
+        this.flatCoordinates.length,
+        this.stride,
+        0
+      )
+    ), this.maxDeltaRevision_ = this.getRevision()), $t(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      this.maxDelta_,
+      !0,
+      t,
+      e,
+      i,
+      r
+    ));
+  }
+  /**
+   * Return the area of the linear ring on projected plane.
+   * @return {number} Area (on projected plane).
+   * @api
+   */
+  getArea() {
+    return se(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride
+    );
+  }
+  /**
+   * Return the coordinates of the linear ring.
+   * @return {Array<import("../coordinate.js").Coordinate>} Coordinates.
+   * @api
+   */
+  getCoordinates() {
+    return ie(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride
+    );
+  }
+  /**
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {LinearRing} Simplified LinearRing.
+   * @protected
+   */
+  getSimplifiedGeometryInternal(t) {
+    const e = [];
+    return e.length = ee(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      t,
+      e,
+      0
+    ), new v(e, "XY");
+  }
+  /**
+   * Get the type of this geometry.
+   * @return {import("./Geometry.js").Type} Geometry type.
+   * @api
+   */
+  getType() {
+    return "LinearRing";
+  }
+  /**
+   * Test if the geometry and the passed extent intersect.
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @return {boolean} `true` if the geometry and the extent intersect.
+   * @api
+   */
+  intersectsExtent(t) {
+    return !1;
+  }
+  /**
+   * Set the coordinates of the linear ring.
+   * @param {!Array<import("../coordinate.js").Coordinate>} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   * @api
+   */
+  setCoordinates(t, e) {
+    this.setLayout(e, t, 1), this.flatCoordinates || (this.flatCoordinates = []), this.flatCoordinates.length = Qt(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride
+    ), this.changed();
+  }
+}
+class _t extends Rt {
+  /**
+   * @param {import("../coordinate.js").Coordinate} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   */
+  constructor(t, e) {
+    super(), this.setCoordinates(t, e);
+  }
+  /**
+   * Make a complete copy of the geometry.
+   * @return {!Point} Clone.
+   * @api
+   */
+  clone() {
+    const t = new _t(this.flatCoordinates.slice(), this.layout);
+    return t.applyProperties(this), t;
+  }
+  /**
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @param {import("../coordinate.js").Coordinate} closestPoint Closest point.
+   * @param {number} minSquaredDistance Minimum squared distance.
+   * @return {number} Minimum squared distance.
+   */
+  closestPointXY(t, e, i, r) {
+    const s = this.flatCoordinates, o = j(
+      t,
+      e,
+      s[0],
+      s[1]
+    );
+    if (o < r) {
+      const u = this.stride;
+      for (let a = 0; a < u; ++a)
+        i[a] = s[a];
+      return i.length = u, o;
+    }
+    return r;
+  }
+  /**
+   * Return the coordinate of the point.
+   * @return {import("../coordinate.js").Coordinate} Coordinates.
+   * @api
+   */
+  getCoordinates() {
+    return this.flatCoordinates ? this.flatCoordinates.slice() : [];
+  }
+  /**
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @protected
+   * @return {import("../extent.js").Extent} extent Extent.
+   */
+  computeExtent(t) {
+    return Ne(this.flatCoordinates, t);
+  }
+  /**
+   * Get the type of this geometry.
+   * @return {import("./Geometry.js").Type} Geometry type.
+   * @api
+   */
+  getType() {
+    return "Point";
+  }
+  /**
+   * Test if the geometry and the passed extent intersect.
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @return {boolean} `true` if the geometry and the extent intersect.
+   * @api
+   */
+  intersectsExtent(t) {
+    return Ut(t, this.flatCoordinates[0], this.flatCoordinates[1]);
+  }
+  /**
+   * @param {!Array<*>} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   * @api
+   */
+  setCoordinates(t, e) {
+    this.setLayout(e, t, 0), this.flatCoordinates || (this.flatCoordinates = []), this.flatCoordinates.length = Sn(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride
+    ), this.changed();
+  }
+}
+function An(n, t, e, i, r) {
+  return !Ze(
+    r,
+    /**
+     * @param {import("../../coordinate.js").Coordinate} coordinate Coordinate.
+     * @return {boolean} Contains (x, y).
+     */
+    function(o) {
+      return !O(
+        n,
+        t,
+        e,
+        i,
+        o[0],
+        o[1]
+      );
+    }
+  );
+}
+function O(n, t, e, i, r, s) {
+  let o = 0, u = n[e - i], a = n[e - i + 1];
+  for (; t < e; t += i) {
+    const h = n[t], l = n[t + 1];
+    a <= s ? l > s && (h - u) * (s - a) - (r - u) * (l - a) > 0 && o++ : l <= s && (h - u) * (s - a) - (r - u) * (l - a) < 0 && o--, u = h, a = l;
+  }
+  return o !== 0;
+}
+function mt(n, t, e, i, r, s) {
+  if (e.length === 0 || !O(n, t, e[0], i, r, s))
+    return !1;
+  for (let o = 1, u = e.length; o < u; ++o)
+    if (O(n, e[o - 1], e[o], i, r, s))
+      return !1;
+  return !0;
+}
+function Ri(n, t, e, i, r, s) {
+  if (e.length === 0)
+    return !1;
+  for (let o = 0, u = e.length; o < u; ++o) {
+    const a = e[o];
+    if (mt(n, t, a, i, r, s))
+      return !0;
+    t = a[a.length - 1];
+  }
+  return !1;
+}
+function ae(n, t, e, i, r, s, o) {
+  let u, a, h, l, c, g, f;
+  const d = r[s + 1], R = [];
+  for (let y = 0, et = e.length; y < et; ++y) {
+    const G = e[y];
+    for (l = n[G - i], g = n[G - i + 1], u = t; u < G; u += i)
+      c = n[u], f = n[u + 1], (d <= g && f <= d || g <= d && d <= f) && (h = (d - g) / (f - g) * (c - l) + l, R.push(h)), l = c, g = f;
+  }
+  let _ = NaN, M = -1 / 0;
+  for (R.sort(Re), l = R[0], u = 1, a = R.length; u < a; ++u) {
+    c = R[u];
+    const y = Math.abs(c - l);
+    y > M && (h = (l + c) / 2, mt(n, t, e, i, h, d) && (_ = h, M = y)), l = c;
+  }
+  return isNaN(_) && (_ = r[s]), o ? (o.push(_, d, M), o) : [_, d, M];
+}
+function _i(n, t, e, i, r) {
+  let s = [];
+  for (let o = 0, u = e.length; o < u; ++o) {
+    const a = e[o];
+    s = ae(
+      n,
+      t,
+      a,
+      i,
+      r,
+      2 * o,
+      s
+    ), t = a[a.length - 1];
+  }
+  return s;
+}
+function wn(n, t, e, i, r) {
+  let s;
+  for (t += i; t < e; t += i)
+    if (s = r(
+      n.slice(t - i, t),
+      n.slice(t, t + i)
+    ), s)
+      return s;
+  return !1;
+}
+function yt(n, t, e, i, r) {
+  const s = Vt(
+    $(),
+    n,
+    t,
+    e,
+    i
+  );
+  return lt(r, s) ? Te(r, s) || s[0] >= r[0] && s[2] <= r[2] || s[1] >= r[1] && s[3] <= r[3] ? !0 : wn(
+    n,
+    t,
+    e,
+    i,
+    /**
+     * @param {import("../../coordinate.js").Coordinate} point1 Start point.
+     * @param {import("../../coordinate.js").Coordinate} point2 End point.
+     * @return {boolean} `true` if the segment and the extent intersect,
+     *     `false` otherwise.
+     */
+    function(o, u) {
+      return ze(r, o, u);
+    }
+  ) : !1;
+}
+function mi(n, t, e, i, r) {
+  for (let s = 0, o = e.length; s < o; ++s) {
+    if (yt(n, t, e[s], i, r))
+      return !0;
+    t = e[s];
+  }
+  return !1;
+}
+function Pn(n, t, e, i, r) {
+  return !!(yt(n, t, e, i, r) || O(
+    n,
+    t,
+    e,
+    i,
+    r[0],
+    r[1]
+  ) || O(
+    n,
+    t,
+    e,
+    i,
+    r[0],
+    r[3]
+  ) || O(
+    n,
+    t,
+    e,
+    i,
+    r[2],
+    r[1]
+  ) || O(
+    n,
+    t,
+    e,
+    i,
+    r[2],
+    r[3]
+  ));
+}
+function ue(n, t, e, i, r) {
+  if (!Pn(n, t, e[0], i, r))
+    return !1;
+  if (e.length === 1)
+    return !0;
+  for (let s = 1, o = e.length; s < o; ++s)
+    if (An(
+      n,
+      e[s - 1],
+      e[s],
+      i,
+      r
+    ) && !yt(
+      n,
+      e[s - 1],
+      e[s],
+      i,
+      r
+    ))
+      return !1;
+  return !0;
+}
+function yi(n, t, e, i, r) {
+  for (let s = 0, o = e.length; s < o; ++s) {
+    const u = e[s];
+    if (ue(n, t, u, i, r))
+      return !0;
+    t = u[u.length - 1];
+  }
+  return !1;
+}
+function Tn(n, t, e, i) {
+  for (; t < e - i; ) {
+    for (let r = 0; r < i; ++r) {
+      const s = n[t + r];
+      n[t + r] = n[e - i + r], n[e - i + r] = s;
+    }
+    t += i, e -= i;
+  }
+}
+function le(n, t, e, i) {
+  let r = 0, s = n[e - i], o = n[e - i + 1];
+  for (; t < e; t += i) {
+    const u = n[t], a = n[t + 1];
+    r += (u - s) * (a + o), s = u, o = a;
+  }
+  return r === 0 ? void 0 : r > 0;
+}
+function he(n, t, e, i, r) {
+  r = r !== void 0 ? r : !1;
+  for (let s = 0, o = e.length; s < o; ++s) {
+    const u = e[s], a = le(
+      n,
+      t,
+      u,
+      i
+    );
+    if (s === 0) {
+      if (r && a || !r && !a)
+        return !1;
+    } else if (r && !a || !r && a)
+      return !1;
+    t = u;
+  }
+  return !0;
+}
+function Mi(n, t, e, i, r) {
+  for (let s = 0, o = e.length; s < o; ++s) {
+    const u = e[s];
+    if (!he(n, t, u, i, r))
+      return !1;
+    u.length && (t = u[u.length - 1]);
+  }
+  return !0;
+}
+function ut(n, t, e, i, r) {
+  r = r !== void 0 ? r : !1;
+  for (let s = 0, o = e.length; s < o; ++s) {
+    const u = e[s], a = le(
+      n,
+      t,
+      u,
+      i
+    );
+    (s === 0 ? r && a || !r && !a : r && !a || !r && a) && Tn(n, t, u, i), t = u;
+  }
+  return t;
+}
+function Ci(n, t, e, i, r) {
+  for (let s = 0, o = e.length; s < o; ++s)
+    t = ut(
+      n,
+      t,
+      e[s],
+      i,
+      r
+    );
+  return t;
+}
+class Y extends Rt {
+  /**
+   * @param {!Array<Array<import("../coordinate.js").Coordinate>>|!Array<number>} coordinates
+   *     Array of linear rings that define the polygon. The first linear ring of the
+   *     array defines the outer-boundary or surface of the polygon. Each subsequent
+   *     linear ring defines a hole in the surface of the polygon. A linear ring is
+   *     an array of vertices' coordinates where the first coordinate and the last are
+   *     equivalent. (For internal use, flat coordinates in combination with
+   *     `layout` and `ends` are also accepted.)
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   * @param {Array<number>} [ends] Ends (for internal use with flat coordinates).
+   */
+  constructor(t, e, i) {
+    super(), this.ends_ = [], this.flatInteriorPointRevision_ = -1, this.flatInteriorPoint_ = null, this.maxDelta_ = -1, this.maxDeltaRevision_ = -1, this.orientedRevision_ = -1, this.orientedFlatCoordinates_ = null, e !== void 0 && i ? (this.setFlatCoordinates(
+      e,
+      /** @type {Array<number>} */
+      t
+    ), this.ends_ = i) : this.setCoordinates(
+      /** @type {Array<Array<import("../coordinate.js").Coordinate>>} */
+      t,
+      e
+    );
+  }
+  /**
+   * Append the passed linear ring to this polygon.
+   * @param {LinearRing} linearRing Linear ring.
+   * @api
+   */
+  appendLinearRing(t) {
+    this.flatCoordinates ? _e(this.flatCoordinates, t.getFlatCoordinates()) : this.flatCoordinates = t.getFlatCoordinates().slice(), this.ends_.push(this.flatCoordinates.length), this.changed();
+  }
+  /**
+   * Make a complete copy of the geometry.
+   * @return {!Polygon} Clone.
+   * @api
+   */
+  clone() {
+    const t = new Y(
+      this.flatCoordinates.slice(),
+      this.layout,
+      this.ends_.slice()
+    );
+    return t.applyProperties(this), t;
+  }
+  /**
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @param {import("../coordinate.js").Coordinate} closestPoint Closest point.
+   * @param {number} minSquaredDistance Minimum squared distance.
+   * @return {number} Minimum squared distance.
+   */
+  closestPointXY(t, e, i, r) {
+    return r < zt(this.getExtent(), t, e) ? r : (this.maxDeltaRevision_ != this.getRevision() && (this.maxDelta_ = Math.sqrt(
+      Ht(
+        this.flatCoordinates,
+        0,
+        this.ends_,
+        this.stride,
+        0
+      )
+    ), this.maxDeltaRevision_ = this.getRevision()), Jt(
+      this.flatCoordinates,
+      0,
+      this.ends_,
+      this.stride,
+      this.maxDelta_,
+      !0,
+      t,
+      e,
+      i,
+      r
+    ));
+  }
+  /**
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @return {boolean} Contains (x, y).
+   */
+  containsXY(t, e) {
+    return mt(
+      this.getOrientedFlatCoordinates(),
+      0,
+      this.ends_,
+      this.stride,
+      t,
+      e
+    );
+  }
+  /**
+   * Return the area of the polygon on projected plane.
+   * @return {number} Area (on projected plane).
+   * @api
+   */
+  getArea() {
+    return oe(
+      this.getOrientedFlatCoordinates(),
+      0,
+      this.ends_,
+      this.stride
+    );
+  }
+  /**
+   * Get the coordinate array for this geometry.  This array has the structure
+   * of a GeoJSON coordinate array for polygons.
+   *
+   * @param {boolean} [right] Orient coordinates according to the right-hand
+   *     rule (counter-clockwise for exterior and clockwise for interior rings).
+   *     If `false`, coordinates will be oriented according to the left-hand rule
+   *     (clockwise for exterior and counter-clockwise for interior rings).
+   *     By default, coordinate orientation will depend on how the geometry was
+   *     constructed.
+   * @return {Array<Array<import("../coordinate.js").Coordinate>>} Coordinates.
+   * @api
+   */
+  getCoordinates(t) {
+    let e;
+    return t !== void 0 ? (e = this.getOrientedFlatCoordinates().slice(), ut(e, 0, this.ends_, this.stride, t)) : e = this.flatCoordinates, re(e, 0, this.ends_, this.stride);
+  }
+  /**
+   * @return {Array<number>} Ends.
+   */
+  getEnds() {
+    return this.ends_;
+  }
+  /**
+   * @return {Array<number>} Interior point.
+   */
+  getFlatInteriorPoint() {
+    if (this.flatInteriorPointRevision_ != this.getRevision()) {
+      const t = L(this.getExtent());
+      this.flatInteriorPoint_ = ae(
+        this.getOrientedFlatCoordinates(),
+        0,
+        this.ends_,
+        this.stride,
+        t,
+        0
+      ), this.flatInteriorPointRevision_ = this.getRevision();
+    }
+    return this.flatInteriorPoint_;
+  }
+  /**
+   * Return an interior point of the polygon.
+   * @return {Point} Interior point as XYM coordinate, where M is the
+   * length of the horizontal intersection that the point belongs to.
+   * @api
+   */
+  getInteriorPoint() {
+    return new _t(this.getFlatInteriorPoint(), "XYM");
+  }
+  /**
+   * Return the number of rings of the polygon,  this includes the exterior
+   * ring and any interior rings.
+   *
+   * @return {number} Number of rings.
+   * @api
+   */
+  getLinearRingCount() {
+    return this.ends_.length;
+  }
+  /**
+   * Return the Nth linear ring of the polygon geometry. Return `null` if the
+   * given index is out of range.
+   * The exterior linear ring is available at index `0` and the interior rings
+   * at index `1` and beyond.
+   *
+   * @param {number} index Index.
+   * @return {LinearRing|null} Linear ring.
+   * @api
+   */
+  getLinearRing(t) {
+    return t < 0 || this.ends_.length <= t ? null : new v(
+      this.flatCoordinates.slice(
+        t === 0 ? 0 : this.ends_[t - 1],
+        this.ends_[t]
+      ),
+      this.layout
+    );
+  }
+  /**
+   * Return the linear rings of the polygon.
+   * @return {Array<LinearRing>} Linear rings.
+   * @api
+   */
+  getLinearRings() {
+    const t = this.layout, e = this.flatCoordinates, i = this.ends_, r = [];
+    let s = 0;
+    for (let o = 0, u = i.length; o < u; ++o) {
+      const a = i[o], h = new v(
+        e.slice(s, a),
+        t
+      );
+      r.push(h), s = a;
+    }
+    return r;
+  }
+  /**
+   * @return {Array<number>} Oriented flat coordinates.
+   */
+  getOrientedFlatCoordinates() {
+    if (this.orientedRevision_ != this.getRevision()) {
+      const t = this.flatCoordinates;
+      he(t, 0, this.ends_, this.stride) ? this.orientedFlatCoordinates_ = t : (this.orientedFlatCoordinates_ = t.slice(), this.orientedFlatCoordinates_.length = ut(
+        this.orientedFlatCoordinates_,
+        0,
+        this.ends_,
+        this.stride
+      )), this.orientedRevision_ = this.getRevision();
+    }
+    return this.orientedFlatCoordinates_;
+  }
+  /**
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {Polygon} Simplified Polygon.
+   * @protected
+   */
+  getSimplifiedGeometryInternal(t) {
+    const e = [], i = [];
+    return e.length = ne(
+      this.flatCoordinates,
+      0,
+      this.ends_,
+      this.stride,
+      Math.sqrt(t),
+      e,
+      0,
+      i
+    ), new Y(e, "XY", i);
+  }
+  /**
+   * Get the type of this geometry.
+   * @return {import("./Geometry.js").Type} Geometry type.
+   * @api
+   */
+  getType() {
+    return "Polygon";
+  }
+  /**
+   * Test if the geometry and the passed extent intersect.
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @return {boolean} `true` if the geometry and the extent intersect.
+   * @api
+   */
+  intersectsExtent(t) {
+    return ue(
+      this.getOrientedFlatCoordinates(),
+      0,
+      this.ends_,
+      this.stride,
+      t
+    );
+  }
+  /**
+   * Set the coordinates of the polygon.
+   * @param {!Array<Array<import("../coordinate.js").Coordinate>>} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   * @api
+   */
+  setCoordinates(t, e) {
+    this.setLayout(e, t, 2), this.flatCoordinates || (this.flatCoordinates = []);
+    const i = te(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride,
+      this.ends_
+    );
+    this.flatCoordinates.length = i.length === 0 ? 0 : i[i.length - 1], this.changed();
+  }
+}
+function Xt(n) {
+  if (tt(n))
+    throw new Error("Cannot create polygon from empty extent");
+  const t = n[0], e = n[1], i = n[2], r = n[3], s = [
+    t,
+    e,
+    t,
+    r,
+    i,
+    r,
+    i,
+    e,
+    t,
+    e
+  ];
+  return new Y(s, "XY", [s.length]);
+}
+function Ei(n, t, e) {
+  t = t || 32;
+  const i = n.getStride(), r = n.getLayout(), s = n.getCenter(), o = i * (t + 1), u = new Array(o);
+  for (let l = 0; l < o; l += i) {
+    u[l] = 0, u[l + 1] = 0;
+    for (let c = 2; c < i; c++)
+      u[l + c] = s[c];
+  }
+  const a = [u.length], h = new Y(u, r, a);
+  return Nn(h, s, n.getRadius()), h;
+}
+function Nn(n, t, e, i) {
+  const r = n.getFlatCoordinates(), s = n.getStride(), o = r.length / s - 1, u = 0;
+  for (let a = 0; a <= o; ++a) {
+    const h = a * s, l = u + K(a, o) * 2 * Math.PI / o;
+    r[h] = t[0] + e * Math.cos(l), r[h + 1] = t[1] + e * Math.sin(l);
+  }
+  n.changed();
+}
+const rt = 0;
+class Gt extends H {
+  /**
+   * @param {ViewOptions} [options] View options.
+   */
+  constructor(t) {
+    super(), this.on, this.once, this.un, t = Object.assign({}, t), this.hints_ = [0, 0], this.animations_ = [], this.updateAnimationKey_, this.projection_ = ct(t.projection, "EPSG:3857"), this.viewportSize_ = [100, 100], this.targetCenter_ = null, this.targetResolution_, this.targetRotation_, this.nextCenter_ = null, this.nextResolution_, this.nextRotation_, this.cancelAnchor_ = void 0, t.projection && Wt(), t.center && (t.center = w(t.center, this.projection_)), t.extent && (t.extent = V(t.extent, this.projection_)), this.applyOptions_(t);
+  }
+  /**
+   * Set up the view with the given options.
+   * @param {ViewOptions} options View options.
+   */
+  applyOptions_(t) {
+    const e = Object.assign({}, t);
+    for (const u in I)
+      delete e[u];
+    this.setProperties(e, !0);
+    const i = xn(t);
+    this.maxResolution_ = i.maxResolution, this.minResolution_ = i.minResolution, this.zoomFactor_ = i.zoomFactor, this.resolutions_ = t.resolutions, this.padding_ = t.padding, this.minZoom_ = i.minZoom;
+    const r = On(t), s = i.constraint, o = Fn(t);
+    this.constraints_ = {
+      center: r,
+      resolution: s,
+      rotation: o
+    }, this.setRotation(t.rotation !== void 0 ? t.rotation : 0), this.setCenterInternal(
+      t.center !== void 0 ? t.center : null
+    ), t.resolution !== void 0 ? this.setResolution(t.resolution) : t.zoom !== void 0 && this.setZoom(t.zoom);
+  }
+  /**
+   * Padding (in css pixels).
+   * If the map viewport is partially covered with other content (overlays) along
+   * its edges, this setting allows to shift the center of the viewport away from that
+   * content. The order of the values in the array is top, right, bottom, left.
+   * The default is no padding, which is equivalent to `[0, 0, 0, 0]`.
+   * @type {Array<number>|undefined}
+   * @api
+   */
+  get padding() {
+    return this.padding_;
+  }
+  set padding(t) {
+    let e = this.padding_;
+    this.padding_ = t;
+    const i = this.getCenterInternal();
+    if (i) {
+      const r = t || [0, 0, 0, 0];
+      e = e || [0, 0, 0, 0];
+      const s = this.getResolution(), o = s / 2 * (r[3] - e[3] + e[1] - r[1]), u = s / 2 * (r[0] - e[0] + e[2] - r[2]);
+      this.setCenterInternal([i[0] + o, i[1] - u]);
+    }
+  }
+  /**
+   * Get an updated version of the view options used to construct the view.  The
+   * current resolution (or zoom), center, and rotation are applied to any stored
+   * options.  The provided options can be used to apply new min/max zoom or
+   * resolution limits.
+   * @param {ViewOptions} newOptions New options to be applied.
+   * @return {ViewOptions} New options updated with the current view state.
+   */
+  getUpdatedOptions_(t) {
+    const e = this.getProperties();
+    return e.resolution !== void 0 ? e.resolution = this.getResolution() : e.zoom = this.getZoom(), e.center = this.getCenterInternal(), e.rotation = this.getRotation(), Object.assign({}, e, t);
+  }
+  /**
+   * Animate the view.  The view's center, zoom (or resolution), and rotation
+   * can be animated for smooth transitions between view states.  For example,
+   * to animate the view to a new zoom level:
+   *
+   *     view.animate({zoom: view.getZoom() + 1});
+   *
+   * By default, the animation lasts one second and uses in-and-out easing.  You
+   * can customize this behavior by including `duration` (in milliseconds) and
+   * `easing` options (see {@link module:ol/easing}).
+   *
+   * To chain together multiple animations, call the method with multiple
+   * animation objects.  For example, to first zoom and then pan:
+   *
+   *     view.animate({zoom: 10}, {center: [0, 0]});
+   *
+   * If you provide a function as the last argument to the animate method, it
+   * will get called at the end of an animation series.  The callback will be
+   * called with `true` if the animation series completed on its own or `false`
+   * if it was cancelled.
+   *
+   * Animations are cancelled by user interactions (e.g. dragging the map) or by
+   * calling `view.setCenter()`, `view.setResolution()`, or `view.setRotation()`
+   * (or another method that calls one of these).
+   *
+   * @param {...(AnimationOptions|function(boolean): void)} var_args Animation
+   *     options.  Multiple animations can be run in series by passing multiple
+   *     options objects.  To run multiple animations in parallel, call the method
+   *     multiple times.  An optional callback can be provided as a final
+   *     argument.  The callback will be called with a boolean indicating whether
+   *     the animation completed without being cancelled.
+   * @api
+   */
+  animate(t) {
+    this.isDef() && !this.getAnimating() && this.resolveConstraints(0);
+    const e = new Array(arguments.length);
+    for (let i = 0; i < e.length; ++i) {
+      let r = arguments[i];
+      r.center && (r = Object.assign({}, r), r.center = w(
+        r.center,
+        this.getProjection()
+      )), r.anchor && (r = Object.assign({}, r), r.anchor = w(
+        r.anchor,
+        this.getProjection()
+      )), e[i] = r;
+    }
+    this.animateInternal.apply(this, e);
+  }
+  /**
+   * @param {...(AnimationOptions|function(boolean): void)} var_args Animation options.
+   */
+  animateInternal(t) {
+    let e = arguments.length, i;
+    e > 1 && typeof arguments[e - 1] == "function" && (i = arguments[e - 1], --e);
+    let r = 0;
+    for (; r < e && !this.isDef(); ++r) {
+      const l = arguments[r];
+      l.center && this.setCenterInternal(l.center), l.zoom !== void 0 ? this.setZoom(l.zoom) : l.resolution && this.setResolution(l.resolution), l.rotation !== void 0 && this.setRotation(l.rotation);
+    }
+    if (r === e) {
+      i && D(i, !0);
+      return;
+    }
+    let s = Date.now(), o = this.targetCenter_.slice(), u = this.targetResolution_, a = this.targetRotation_;
+    const h = [];
+    for (; r < e; ++r) {
+      const l = (
+        /** @type {AnimationOptions} */
+        arguments[r]
+      ), c = {
+        start: s,
+        complete: !1,
+        anchor: l.anchor,
+        duration: l.duration !== void 0 ? l.duration : 1e3,
+        easing: l.easing || mn,
+        callback: i
+      };
+      if (l.center && (c.sourceCenter = o, c.targetCenter = l.center.slice(), o = c.targetCenter), l.zoom !== void 0 ? (c.sourceResolution = u, c.targetResolution = this.getResolutionForZoom(l.zoom), u = c.targetResolution) : l.resolution && (c.sourceResolution = u, c.targetResolution = l.resolution, u = c.targetResolution), l.rotation !== void 0) {
+        c.sourceRotation = a;
+        const g = K(l.rotation - a + Math.PI, 2 * Math.PI) - Math.PI;
+        c.targetRotation = a + g, a = c.targetRotation;
+      }
+      Zn(c) ? c.complete = !0 : s += c.duration, h.push(c);
+    }
+    this.animations_.push(h), this.setHint(P.ANIMATING, 1), this.updateAnimations_();
+  }
+  /**
+   * Determine if the view is being animated.
+   * @return {boolean} The view is being animated.
+   * @api
+   */
+  getAnimating() {
+    return this.hints_[P.ANIMATING] > 0;
+  }
+  /**
+   * Determine if the user is interacting with the view, such as panning or zooming.
+   * @return {boolean} The view is being interacted with.
+   * @api
+   */
+  getInteracting() {
+    return this.hints_[P.INTERACTING] > 0;
+  }
+  /**
+   * Cancel any ongoing animations.
+   * @api
+   */
+  cancelAnimations() {
+    this.setHint(P.ANIMATING, -this.hints_[P.ANIMATING]);
+    let t;
+    for (let e = 0, i = this.animations_.length; e < i; ++e) {
+      const r = this.animations_[e];
+      if (r[0].callback && D(r[0].callback, !1), !t)
+        for (let s = 0, o = r.length; s < o; ++s) {
+          const u = r[s];
+          if (!u.complete) {
+            t = u.anchor;
+            break;
+          }
+        }
+    }
+    this.animations_.length = 0, this.cancelAnchor_ = t, this.nextCenter_ = null, this.nextResolution_ = NaN, this.nextRotation_ = NaN;
+  }
+  /**
+   * Update all animations.
+   */
+  updateAnimations_() {
+    if (this.updateAnimationKey_ !== void 0 && (cancelAnimationFrame(this.updateAnimationKey_), this.updateAnimationKey_ = void 0), !this.getAnimating())
+      return;
+    const t = Date.now();
+    let e = !1;
+    for (let i = this.animations_.length - 1; i >= 0; --i) {
+      const r = this.animations_[i];
+      let s = !0;
+      for (let o = 0, u = r.length; o < u; ++o) {
+        const a = r[o];
+        if (a.complete)
+          continue;
+        const h = t - a.start;
+        let l = a.duration > 0 ? h / a.duration : 1;
+        l >= 1 ? (a.complete = !0, l = 1) : s = !1;
+        const c = a.easing(l);
+        if (a.sourceCenter) {
+          const g = a.sourceCenter[0], f = a.sourceCenter[1], d = a.targetCenter[0], R = a.targetCenter[1];
+          this.nextCenter_ = a.targetCenter;
+          const _ = g + c * (d - g), M = f + c * (R - f);
+          this.targetCenter_ = [_, M];
+        }
+        if (a.sourceResolution && a.targetResolution) {
+          const g = c === 1 ? a.targetResolution : a.sourceResolution + c * (a.targetResolution - a.sourceResolution);
+          if (a.anchor) {
+            const f = this.getViewportSize_(this.getRotation()), d = this.constraints_.resolution(
+              g,
+              0,
+              f,
+              !0
+            );
+            this.targetCenter_ = this.calculateCenterZoom(
+              d,
+              a.anchor
+            );
+          }
+          this.nextResolution_ = a.targetResolution, this.targetResolution_ = g, this.applyTargetState_(!0);
+        }
+        if (a.sourceRotation !== void 0 && a.targetRotation !== void 0) {
+          const g = c === 1 ? K(a.targetRotation + Math.PI, 2 * Math.PI) - Math.PI : a.sourceRotation + c * (a.targetRotation - a.sourceRotation);
+          if (a.anchor) {
+            const f = this.constraints_.rotation(
+              g,
+              !0
+            );
+            this.targetCenter_ = this.calculateCenterRotate(
+              f,
+              a.anchor
+            );
+          }
+          this.nextRotation_ = a.targetRotation, this.targetRotation_ = g;
+        }
+        if (this.applyTargetState_(!0), e = !0, !a.complete)
+          break;
+      }
+      if (s) {
+        this.animations_[i] = null, this.setHint(P.ANIMATING, -1), this.nextCenter_ = null, this.nextResolution_ = NaN, this.nextRotation_ = NaN;
+        const o = r[0].callback;
+        o && D(o, !0);
+      }
+    }
+    this.animations_ = this.animations_.filter(Boolean), e && this.updateAnimationKey_ === void 0 && (this.updateAnimationKey_ = requestAnimationFrame(
+      this.updateAnimations_.bind(this)
+    ));
+  }
+  /**
+   * @param {number} rotation Target rotation.
+   * @param {import("./coordinate.js").Coordinate} anchor Rotation anchor.
+   * @return {import("./coordinate.js").Coordinate|undefined} Center for rotation and anchor.
+   */
+  calculateCenterRotate(t, e) {
+    let i;
+    const r = this.getCenterInternal();
+    return r !== void 0 && (i = [r[0] - e[0], r[1] - e[1]], Ke(i, t - this.getRotation()), De(i, e)), i;
+  }
+  /**
+   * @param {number} resolution Target resolution.
+   * @param {import("./coordinate.js").Coordinate} anchor Zoom anchor.
+   * @return {import("./coordinate.js").Coordinate|undefined} Center for resolution and anchor.
+   */
+  calculateCenterZoom(t, e) {
+    let i;
+    const r = this.getCenterInternal(), s = this.getResolution();
+    if (r !== void 0 && s !== void 0) {
+      const o = e[0] - t * (e[0] - r[0]) / s, u = e[1] - t * (e[1] - r[1]) / s;
+      i = [o, u];
+    }
+    return i;
+  }
+  /**
+   * Returns the current viewport size.
+   * @private
+   * @param {number} [rotation] Take into account the rotation of the viewport when giving the size
+   * @return {import("./size.js").Size} Viewport size or `[100, 100]` when no viewport is found.
+   */
+  getViewportSize_(t) {
+    const e = this.viewportSize_;
+    if (t) {
+      const i = e[0], r = e[1];
+      return [
+        Math.abs(i * Math.cos(t)) + Math.abs(r * Math.sin(t)),
+        Math.abs(i * Math.sin(t)) + Math.abs(r * Math.cos(t))
+      ];
+    }
+    return e;
+  }
+  /**
+   * Stores the viewport size on the view. The viewport size is not read every time from the DOM
+   * to avoid performance hit and layout reflow.
+   * This should be done on map size change.
+   * Note: the constraints are not resolved during an animation to avoid stopping it
+   * @param {import("./size.js").Size} [size] Viewport size; if undefined, [100, 100] is assumed
+   */
+  setViewportSize(t) {
+    this.viewportSize_ = Array.isArray(t) ? t.slice() : [100, 100], this.getAnimating() || this.resolveConstraints(0);
+  }
+  /**
+   * Get the view center.
+   * @return {import("./coordinate.js").Coordinate|undefined} The center of the view.
+   * @observable
+   * @api
+   */
+  getCenter() {
+    const t = this.getCenterInternal();
+    return t && Pt(t, this.getProjection());
+  }
+  /**
+   * Get the view center without transforming to user projection.
+   * @return {import("./coordinate.js").Coordinate|undefined} The center of the view.
+   */
+  getCenterInternal() {
+    return (
+      /** @type {import("./coordinate.js").Coordinate|undefined} */
+      this.get(I.CENTER)
+    );
+  }
+  /**
+   * @return {Constraints} Constraints.
+   */
+  getConstraints() {
+    return this.constraints_;
+  }
+  /**
+   * @return {boolean} Resolution constraint is set
+   */
+  getConstrainResolution() {
+    return this.get("constrainResolution");
+  }
+  /**
+   * @param {Array<number>} [hints] Destination array.
+   * @return {Array<number>} Hint.
+   */
+  getHints(t) {
+    return t !== void 0 ? (t[0] = this.hints_[0], t[1] = this.hints_[1], t) : this.hints_.slice();
+  }
+  /**
+   * Calculate the extent for the current view state and the passed size.
+   * The size is the pixel dimensions of the box into which the calculated extent
+   * should fit. In most cases you want to get the extent of the entire map,
+   * that is `map.getSize()`.
+   * @param {import("./size.js").Size} [size] Box pixel size. If not provided, the size
+   * of the map that uses this view will be used.
+   * @return {import("./extent.js").Extent} Extent.
+   * @api
+   */
+  calculateExtent(t) {
+    const e = this.calculateExtentInternal(t);
+    return Qe(e, this.getProjection());
+  }
+  /**
+   * @param {import("./size.js").Size} [size] Box pixel size. If not provided,
+   * the map's last known viewport size will be used.
+   * @return {import("./extent.js").Extent} Extent.
+   */
+  calculateExtentInternal(t) {
+    t = t || this.getViewportSizeMinusPadding_();
+    const e = (
+      /** @type {!import("./coordinate.js").Coordinate} */
+      this.getCenterInternal()
+    );
+    p(e, 1);
+    const i = (
+      /** @type {!number} */
+      this.getResolution()
+    );
+    p(i !== void 0, 2);
+    const r = (
+      /** @type {!number} */
+      this.getRotation()
+    );
+    return p(r !== void 0, 3), Ge(e, i, r, t);
+  }
+  /**
+   * Get the maximum resolution of the view.
+   * @return {number} The maximum resolution of the view.
+   * @api
+   */
+  getMaxResolution() {
+    return this.maxResolution_;
+  }
+  /**
+   * Get the minimum resolution of the view.
+   * @return {number} The minimum resolution of the view.
+   * @api
+   */
+  getMinResolution() {
+    return this.minResolution_;
+  }
+  /**
+   * Get the maximum zoom level for the view.
+   * @return {number} The maximum zoom level.
+   * @api
+   */
+  getMaxZoom() {
+    return (
+      /** @type {number} */
+      this.getZoomForResolution(this.minResolution_)
+    );
+  }
+  /**
+   * Set a new maximum zoom level for the view.
+   * @param {number} zoom The maximum zoom level.
+   * @api
+   */
+  setMaxZoom(t) {
+    this.applyOptions_(this.getUpdatedOptions_({ maxZoom: t }));
+  }
+  /**
+   * Get the minimum zoom level for the view.
+   * @return {number} The minimum zoom level.
+   * @api
+   */
+  getMinZoom() {
+    return (
+      /** @type {number} */
+      this.getZoomForResolution(this.maxResolution_)
+    );
+  }
+  /**
+   * Set a new minimum zoom level for the view.
+   * @param {number} zoom The minimum zoom level.
+   * @api
+   */
+  setMinZoom(t) {
+    this.applyOptions_(this.getUpdatedOptions_({ minZoom: t }));
+  }
+  /**
+   * Set whether the view should allow intermediary zoom levels.
+   * @param {boolean} enabled Whether the resolution is constrained.
+   * @api
+   */
+  setConstrainResolution(t) {
+    this.applyOptions_(this.getUpdatedOptions_({ constrainResolution: t }));
+  }
+  /**
+   * Get the view projection.
+   * @return {import("./proj/Projection.js").default} The projection of the view.
+   * @api
+   */
+  getProjection() {
+    return this.projection_;
+  }
+  /**
+   * Get the view resolution.
+   * @return {number|undefined} The resolution of the view.
+   * @observable
+   * @api
+   */
+  getResolution() {
+    return (
+      /** @type {number|undefined} */
+      this.get(I.RESOLUTION)
+    );
+  }
+  /**
+   * Get the resolutions for the view. This returns the array of resolutions
+   * passed to the constructor of the View, or undefined if none were given.
+   * @return {Array<number>|undefined} The resolutions of the view.
+   * @api
+   */
+  getResolutions() {
+    return this.resolutions_;
+  }
+  /**
+   * Get the resolution for a provided extent (in map units) and size (in pixels).
+   * @param {import("./extent.js").Extent} extent Extent.
+   * @param {import("./size.js").Size} [size] Box pixel size.
+   * @return {number} The resolution at which the provided extent will render at
+   *     the given size.
+   * @api
+   */
+  getResolutionForExtent(t, e) {
+    return this.getResolutionForExtentInternal(
+      V(t, this.getProjection()),
+      e
+    );
+  }
+  /**
+   * Get the resolution for a provided extent (in map units) and size (in pixels).
+   * @param {import("./extent.js").Extent} extent Extent.
+   * @param {import("./size.js").Size} [size] Box pixel size.
+   * @return {number} The resolution at which the provided extent will render at
+   *     the given size.
+   */
+  getResolutionForExtentInternal(t, e) {
+    e = e || this.getViewportSizeMinusPadding_();
+    const i = A(t) / e[0], r = X(t) / e[1];
+    return Math.max(i, r);
+  }
+  /**
+   * Return a function that returns a value between 0 and 1 for a
+   * resolution. Exponential scaling is assumed.
+   * @param {number} [power] Power.
+   * @return {function(number): number} Resolution for value function.
+   */
+  getResolutionForValueFunction(t) {
+    t = t || 2;
+    const e = this.getConstrainedResolution(this.maxResolution_), i = this.minResolution_, r = Math.log(e / i) / Math.log(t);
+    return (
+      /**
+       * @param {number} value Value.
+       * @return {number} Resolution.
+       */
+      function(s) {
+        return e / Math.pow(t, s * r);
+      }
+    );
+  }
+  /**
+   * Get the view rotation.
+   * @return {number} The rotation of the view in radians.
+   * @observable
+   * @api
+   */
+  getRotation() {
+    return (
+      /** @type {number} */
+      this.get(I.ROTATION)
+    );
+  }
+  /**
+   * Return a function that returns a resolution for a value between
+   * 0 and 1. Exponential scaling is assumed.
+   * @param {number} [power] Power.
+   * @return {function(number): number} Value for resolution function.
+   */
+  getValueForResolutionFunction(t) {
+    const e = Math.log(t || 2), i = this.getConstrainedResolution(this.maxResolution_), r = this.minResolution_, s = Math.log(i / r) / e;
+    return (
+      /**
+       * @param {number} resolution Resolution.
+       * @return {number} Value.
+       */
+      function(o) {
+        return Math.log(i / o) / e / s;
+      }
+    );
+  }
+  /**
+   * Returns the size of the viewport minus padding.
+   * @private
+   * @param {number} [rotation] Take into account the rotation of the viewport when giving the size
+   * @return {import("./size.js").Size} Viewport size reduced by the padding.
+   */
+  getViewportSizeMinusPadding_(t) {
+    let e = this.getViewportSize_(t);
+    const i = this.padding_;
+    return i && (e = [
+      e[0] - i[1] - i[3],
+      e[1] - i[0] - i[2]
+    ]), e;
+  }
+  /**
+   * @return {State} View state.
+   */
+  getState() {
+    const t = this.getProjection(), e = this.getResolution(), i = this.getRotation();
+    let r = (
+      /** @type {import("./coordinate.js").Coordinate} */
+      this.getCenterInternal()
+    );
+    const s = this.padding_;
+    if (s) {
+      const o = this.getViewportSizeMinusPadding_();
+      r = st(
+        r,
+        this.getViewportSize_(),
+        [o[0] / 2 + s[3], o[1] / 2 + s[0]],
+        e,
+        i
+      );
+    }
+    return {
+      center: r.slice(0),
+      projection: t !== void 0 ? t : null,
+      resolution: e,
+      nextCenter: this.nextCenter_,
+      nextResolution: this.nextResolution_,
+      nextRotation: this.nextRotation_,
+      rotation: i,
+      zoom: this.getZoom()
+    };
+  }
+  /**
+   * @return {ViewStateLayerStateExtent} Like `FrameState`, but just `viewState` and `extent`.
+   */
+  getViewStateAndExtent() {
+    return {
+      viewState: this.getState(),
+      extent: this.calculateExtent()
+    };
+  }
+  /**
+   * Get the current zoom level. This method may return non-integer zoom levels
+   * if the view does not constrain the resolution, or if an interaction or
+   * animation is underway.
+   * @return {number|undefined} Zoom.
+   * @api
+   */
+  getZoom() {
+    let t;
+    const e = this.getResolution();
+    return e !== void 0 && (t = this.getZoomForResolution(e)), t;
+  }
+  /**
+   * Get the zoom level for a resolution.
+   * @param {number} resolution The resolution.
+   * @return {number|undefined} The zoom level for the provided resolution.
+   * @api
+   */
+  getZoomForResolution(t) {
+    let e = this.minZoom_ || 0, i, r;
+    if (this.resolutions_) {
+      const s = Lt(this.resolutions_, t, 1);
+      e = s, i = this.resolutions_[s], s == this.resolutions_.length - 1 ? r = 2 : r = i / this.resolutions_[s + 1];
+    } else
+      i = this.maxResolution_, r = this.zoomFactor_;
+    return e + Math.log(i / t) / Math.log(r);
+  }
+  /**
+   * Get the resolution for a zoom level.
+   * @param {number} zoom Zoom level.
+   * @return {number} The view resolution for the provided zoom level.
+   * @api
+   */
+  getResolutionForZoom(t) {
+    if (this.resolutions_) {
+      if (this.resolutions_.length <= 1)
+        return 0;
+      const e = S(
+        Math.floor(t),
+        0,
+        this.resolutions_.length - 2
+      ), i = this.resolutions_[e] / this.resolutions_[e + 1];
+      return this.resolutions_[e] / Math.pow(i, S(t - e, 0, 1));
+    }
+    return this.maxResolution_ / Math.pow(this.zoomFactor_, t - this.minZoom_);
+  }
+  /**
+   * Fit the given geometry or extent based on the given map size and border.
+   * The size is pixel dimensions of the box to fit the extent into.
+   * In most cases you will want to use the map size, that is `map.getSize()`.
+   * Takes care of the map angle.
+   * @param {import("./geom/SimpleGeometry.js").default|import("./extent.js").Extent} geometryOrExtent The geometry or
+   *     extent to fit the view to.
+   * @param {FitOptions} [options] Options.
+   * @api
+   */
+  fit(t, e) {
+    let i;
+    if (p(
+      Array.isArray(t) || typeof /** @type {?} */
+      t.getSimplifiedGeometry == "function",
+      24
+    ), Array.isArray(t)) {
+      p(!tt(t), 25);
+      const r = V(t, this.getProjection());
+      i = Xt(r);
+    } else if (t.getType() === "Circle") {
+      const r = V(
+        t.getExtent(),
+        this.getProjection()
+      );
+      i = Xt(r), i.rotate(this.getRotation(), L(r));
+    } else
+      i = t;
+    this.fitInternal(i, e);
+  }
+  /**
+   * Calculate rotated extent
+   * @param {import("./geom/SimpleGeometry.js").default} geometry The geometry.
+   * @return {import("./extent").Extent} The rotated extent for the geometry.
+   */
+  rotatedExtentForGeometry(t) {
+    const e = this.getRotation(), i = Math.cos(e), r = Math.sin(-e), s = t.getFlatCoordinates(), o = t.getStride();
+    let u = 1 / 0, a = 1 / 0, h = -1 / 0, l = -1 / 0;
+    for (let c = 0, g = s.length; c < g; c += o) {
+      const f = s[c] * i - s[c + 1] * r, d = s[c] * r + s[c + 1] * i;
+      u = Math.min(u, f), a = Math.min(a, d), h = Math.max(h, f), l = Math.max(l, d);
+    }
+    return [u, a, h, l];
+  }
+  /**
+   * @param {import("./geom/SimpleGeometry.js").default} geometry The geometry.
+   * @param {FitOptions} [options] Options.
+   */
+  fitInternal(t, e) {
+    e = e || {};
+    let i = e.size;
+    i || (i = this.getViewportSizeMinusPadding_());
+    const r = e.padding !== void 0 ? e.padding : [0, 0, 0, 0], s = e.nearest !== void 0 ? e.nearest : !1;
+    let o;
+    e.minResolution !== void 0 ? o = e.minResolution : e.maxZoom !== void 0 ? o = this.getResolutionForZoom(e.maxZoom) : o = 0;
+    const u = this.rotatedExtentForGeometry(t);
+    let a = this.getResolutionForExtentInternal(u, [
+      i[0] - r[1] - r[3],
+      i[1] - r[0] - r[2]
+    ]);
+    a = isNaN(a) ? o : Math.max(a, o), a = this.getConstrainedResolution(a, s ? 0 : 1);
+    const h = this.getRotation(), l = Math.sin(h), c = Math.cos(h), g = L(u);
+    g[0] += (r[1] - r[3]) / 2 * a, g[1] += (r[0] - r[2]) / 2 * a;
+    const f = g[0] * c - g[1] * l, d = g[1] * c + g[0] * l, R = this.getConstrainedCenter([f, d], a), _ = e.callback ? e.callback : me;
+    e.duration !== void 0 ? this.animateInternal(
+      {
+        resolution: a,
+        center: R,
+        duration: e.duration,
+        easing: e.easing
+      },
+      _
+    ) : (this.targetResolution_ = a, this.targetCenter_ = R, this.applyTargetState_(!1, !0), D(_, !0));
+  }
+  /**
+   * Center on coordinate and view position.
+   * @param {import("./coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {import("./size.js").Size} size Box pixel size.
+   * @param {import("./pixel.js").Pixel} position Position on the view to center on.
+   * @api
+   */
+  centerOn(t, e, i) {
+    this.centerOnInternal(
+      w(t, this.getProjection()),
+      e,
+      i
+    );
+  }
+  /**
+   * @param {import("./coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {import("./size.js").Size} size Box pixel size.
+   * @param {import("./pixel.js").Pixel} position Position on the view to center on.
+   */
+  centerOnInternal(t, e, i) {
+    this.setCenterInternal(
+      st(
+        t,
+        e,
+        i,
+        this.getResolution(),
+        this.getRotation()
+      )
+    );
+  }
+  /**
+   * Calculates the shift between map and viewport center.
+   * @param {import("./coordinate.js").Coordinate} center Center.
+   * @param {number} resolution Resolution.
+   * @param {number} rotation Rotation.
+   * @param {import("./size.js").Size} size Size.
+   * @return {Array<number>|undefined} Center shift.
+   */
+  calculateCenterShift(t, e, i, r) {
+    let s;
+    const o = this.padding_;
+    if (o && t) {
+      const u = this.getViewportSizeMinusPadding_(-i), a = st(
+        t,
+        r,
+        [u[0] / 2 + o[3], u[1] / 2 + o[0]],
+        e,
+        i
+      );
+      s = [
+        t[0] - a[0],
+        t[1] - a[1]
+      ];
+    }
+    return s;
+  }
+  /**
+   * @return {boolean} Is defined.
+   */
+  isDef() {
+    return !!this.getCenterInternal() && this.getResolution() !== void 0;
+  }
+  /**
+   * Adds relative coordinates to the center of the view. Any extent constraint will apply.
+   * @param {import("./coordinate.js").Coordinate} deltaCoordinates Relative value to add.
+   * @api
+   */
+  adjustCenter(t) {
+    const e = Pt(this.targetCenter_, this.getProjection());
+    this.setCenter([
+      e[0] + t[0],
+      e[1] + t[1]
+    ]);
+  }
+  /**
+   * Adds relative coordinates to the center of the view. Any extent constraint will apply.
+   * @param {import("./coordinate.js").Coordinate} deltaCoordinates Relative value to add.
+   */
+  adjustCenterInternal(t) {
+    const e = this.targetCenter_;
+    this.setCenterInternal([
+      e[0] + t[0],
+      e[1] + t[1]
+    ]);
+  }
+  /**
+   * Multiply the view resolution by a ratio, optionally using an anchor. Any resolution
+   * constraint will apply.
+   * @param {number} ratio The ratio to apply on the view resolution.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
+   * @api
+   */
+  adjustResolution(t, e) {
+    e = e && w(e, this.getProjection()), this.adjustResolutionInternal(t, e);
+  }
+  /**
+   * Multiply the view resolution by a ratio, optionally using an anchor. Any resolution
+   * constraint will apply.
+   * @param {number} ratio The ratio to apply on the view resolution.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
+   */
+  adjustResolutionInternal(t, e) {
+    const i = this.getAnimating() || this.getInteracting(), r = this.getViewportSize_(this.getRotation()), s = this.constraints_.resolution(
+      this.targetResolution_ * t,
+      0,
+      r,
+      i
+    );
+    e && (this.targetCenter_ = this.calculateCenterZoom(s, e)), this.targetResolution_ *= t, this.applyTargetState_();
+  }
+  /**
+   * Adds a value to the view zoom level, optionally using an anchor. Any resolution
+   * constraint will apply.
+   * @param {number} delta Relative value to add to the zoom level.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
+   * @api
+   */
+  adjustZoom(t, e) {
+    this.adjustResolution(Math.pow(this.zoomFactor_, -t), e);
+  }
+  /**
+   * Adds a value to the view rotation, optionally using an anchor. Any rotation
+   * constraint will apply.
+   * @param {number} delta Relative value to add to the zoom rotation, in radians.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The rotation center.
+   * @api
+   */
+  adjustRotation(t, e) {
+    e && (e = w(e, this.getProjection())), this.adjustRotationInternal(t, e);
+  }
+  /**
+   * @param {number} delta Relative value to add to the zoom rotation, in radians.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The rotation center.
+   */
+  adjustRotationInternal(t, e) {
+    const i = this.getAnimating() || this.getInteracting(), r = this.constraints_.rotation(
+      this.targetRotation_ + t,
+      i
+    );
+    e && (this.targetCenter_ = this.calculateCenterRotate(r, e)), this.targetRotation_ += t, this.applyTargetState_();
+  }
+  /**
+   * Set the center of the current view. Any extent constraint will apply.
+   * @param {import("./coordinate.js").Coordinate|undefined} center The center of the view.
+   * @observable
+   * @api
+   */
+  setCenter(t) {
+    this.setCenterInternal(
+      t && w(t, this.getProjection())
+    );
+  }
+  /**
+   * Set the center using the view projection (not the user projection).
+   * @param {import("./coordinate.js").Coordinate|undefined} center The center of the view.
+   */
+  setCenterInternal(t) {
+    this.targetCenter_ = t, this.applyTargetState_();
+  }
+  /**
+   * @param {import("./ViewHint.js").default} hint Hint.
+   * @param {number} delta Delta.
+   * @return {number} New value.
+   */
+  setHint(t, e) {
+    return this.hints_[t] += e, this.changed(), this.hints_[t];
+  }
+  /**
+   * Set the resolution for this view. Any resolution constraint will apply.
+   * @param {number|undefined} resolution The resolution of the view.
+   * @observable
+   * @api
+   */
+  setResolution(t) {
+    this.targetResolution_ = t, this.applyTargetState_();
+  }
+  /**
+   * Set the rotation for this view. Any rotation constraint will apply.
+   * @param {number} rotation The rotation of the view in radians.
+   * @observable
+   * @api
+   */
+  setRotation(t) {
+    this.targetRotation_ = t, this.applyTargetState_();
+  }
+  /**
+   * Zoom to a specific zoom level. Any resolution constrain will apply.
+   * @param {number} zoom Zoom level.
+   * @api
+   */
+  setZoom(t) {
+    this.setResolution(this.getResolutionForZoom(t));
+  }
+  /**
+   * Recompute rotation/resolution/center based on target values.
+   * Note: we have to compute rotation first, then resolution and center considering that
+   * parameters can influence one another in case a view extent constraint is present.
+   * @param {boolean} [doNotCancelAnims] Do not cancel animations.
+   * @param {boolean} [forceMoving] Apply constraints as if the view is moving.
+   * @private
+   */
+  applyTargetState_(t, e) {
+    const i = this.getAnimating() || this.getInteracting() || e, r = this.constraints_.rotation(
+      this.targetRotation_,
+      i
+    ), s = this.getViewportSize_(r), o = this.constraints_.resolution(
+      this.targetResolution_,
+      0,
+      s,
+      i
+    ), u = this.constraints_.center(
+      this.targetCenter_,
+      o,
+      s,
+      i,
+      this.calculateCenterShift(
+        this.targetCenter_,
+        o,
+        r,
+        s
+      )
+    );
+    this.get(I.ROTATION) !== r && this.set(I.ROTATION, r), this.get(I.RESOLUTION) !== o && (this.set(I.RESOLUTION, o), this.set("zoom", this.getZoom(), !0)), (!u || !this.get(I.CENTER) || !B(this.get(I.CENTER), u)) && this.set(I.CENTER, u), this.getAnimating() && !t && this.cancelAnimations(), this.cancelAnchor_ = void 0;
+  }
+  /**
+   * If any constraints need to be applied, an animation will be triggered.
+   * This is typically done on interaction end.
+   * Note: calling this with a duration of 0 will apply the constrained values straight away,
+   * without animation.
+   * @param {number} [duration] The animation duration in ms.
+   * @param {number} [resolutionDirection] Which direction to zoom.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
+   */
+  resolveConstraints(t, e, i) {
+    t = t !== void 0 ? t : 200;
+    const r = e || 0, s = this.constraints_.rotation(this.targetRotation_), o = this.getViewportSize_(s), u = this.constraints_.resolution(
+      this.targetResolution_,
+      r,
+      o
+    ), a = this.constraints_.center(
+      this.targetCenter_,
+      u,
+      o,
+      !1,
+      this.calculateCenterShift(
+        this.targetCenter_,
+        u,
+        s,
+        o
+      )
+    );
+    if (t === 0 && !this.cancelAnchor_) {
+      this.targetResolution_ = u, this.targetRotation_ = s, this.targetCenter_ = a, this.applyTargetState_();
+      return;
+    }
+    i = i || (t === 0 ? this.cancelAnchor_ : void 0), this.cancelAnchor_ = void 0, (this.getResolution() !== u || this.getRotation() !== s || !this.getCenterInternal() || !B(this.getCenterInternal(), a)) && (this.getAnimating() && this.cancelAnimations(), this.animateInternal({
+      rotation: s,
+      center: a,
+      resolution: u,
+      duration: t,
+      easing: _n,
+      anchor: i
+    }));
+  }
+  /**
+   * Notify the View that an interaction has started.
+   * The view state will be resolved to a stable one if needed
+   * (depending on its constraints).
+   * @api
+   */
+  beginInteraction() {
+    this.resolveConstraints(0), this.setHint(P.INTERACTING, 1);
+  }
+  /**
+   * Notify the View that an interaction has ended. The view state will be resolved
+   * to a stable one if needed (depending on its constraints).
+   * @param {number} [duration] Animation duration in ms.
+   * @param {number} [resolutionDirection] Which direction to zoom.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
+   * @api
+   */
+  endInteraction(t, e, i) {
+    i = i && w(i, this.getProjection()), this.endInteractionInternal(t, e, i);
+  }
+  /**
+   * Notify the View that an interaction has ended. The view state will be resolved
+   * to a stable one if needed (depending on its constraints).
+   * @param {number} [duration] Animation duration in ms.
+   * @param {number} [resolutionDirection] Which direction to zoom.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
+   */
+  endInteractionInternal(t, e, i) {
+    this.getInteracting() && (this.setHint(P.INTERACTING, -1), this.resolveConstraints(t, e, i));
+  }
+  /**
+   * Get a valid position for the view center according to the current constraints.
+   * @param {import("./coordinate.js").Coordinate|undefined} targetCenter Target center position.
+   * @param {number} [targetResolution] Target resolution. If not supplied, the current one will be used.
+   * This is useful to guess a valid center position at a different zoom level.
+   * @return {import("./coordinate.js").Coordinate|undefined} Valid center position.
+   */
+  getConstrainedCenter(t, e) {
+    const i = this.getViewportSize_(this.getRotation());
+    return this.constraints_.center(
+      t,
+      e || this.getResolution(),
+      i
+    );
+  }
+  /**
+   * Get a valid zoom level according to the current view constraints.
+   * @param {number|undefined} targetZoom Target zoom.
+   * @param {number} [direction=0] Indicate which resolution should be used
+   * by a renderer if the view resolution does not match any resolution of the tile source.
+   * If 0, the nearest resolution will be used. If 1, the nearest lower resolution
+   * will be used. If -1, the nearest higher resolution will be used.
+   * @return {number|undefined} Valid zoom level.
+   */
+  getConstrainedZoom(t, e) {
+    const i = this.getResolutionForZoom(t);
+    return this.getZoomForResolution(
+      this.getConstrainedResolution(i, e)
+    );
+  }
+  /**
+   * Get a valid resolution according to the current view constraints.
+   * @param {number|undefined} targetResolution Target resolution.
+   * @param {number} [direction=0] Indicate which resolution should be used
+   * by a renderer if the view resolution does not match any resolution of the tile source.
+   * If 0, the nearest resolution will be used. If 1, the nearest lower resolution
+   * will be used. If -1, the nearest higher resolution will be used.
+   * @return {number|undefined} Valid resolution.
+   */
+  getConstrainedResolution(t, e) {
+    e = e || 0;
+    const i = this.getViewportSize_(this.getRotation());
+    return this.constraints_.resolution(t, e, i);
+  }
+}
+function D(n, t) {
+  setTimeout(function() {
+    n(t);
+  }, 0);
+}
+function On(n) {
+  if (n.extent !== void 0) {
+    const e = n.smoothExtentConstraint !== void 0 ? n.smoothExtentConstraint : !0;
+    return Nt(n.extent, n.constrainOnlyCenter, e);
+  }
+  const t = ct(n.projection, "EPSG:3857");
+  if (n.multiWorld !== !0 && t.isGlobal()) {
+    const e = t.getExtent().slice();
+    return e[0] = -1 / 0, e[2] = 1 / 0, Nt(e, !1, !1);
+  }
+  return ln;
+}
+function xn(n) {
+  let t, e, i, o = n.minZoom !== void 0 ? n.minZoom : rt, u = n.maxZoom !== void 0 ? n.maxZoom : 28;
+  const a = n.zoomFactor !== void 0 ? n.zoomFactor : 2, h = n.multiWorld !== void 0 ? n.multiWorld : !1, l = n.smoothResolutionConstraint !== void 0 ? n.smoothResolutionConstraint : !0, c = n.showFullExtent !== void 0 ? n.showFullExtent : !1, g = ct(n.projection, "EPSG:3857"), f = g.getExtent();
+  let d = n.constrainOnlyCenter, R = n.extent;
+  if (!h && !R && g.isGlobal() && (d = !1, R = f), n.resolutions !== void 0) {
+    const _ = n.resolutions;
+    e = _[o], i = _[u] !== void 0 ? _[u] : _[_.length - 1], n.constrainResolution ? t = hn(
+      _,
+      l,
+      !d && R,
+      c
+    ) : t = Ot(
+      e,
+      i,
+      l,
+      !d && R,
+      c
+    );
+  } else {
+    const M = (f ? Math.max(A(f), X(f)) : (
+      // use an extent that can fit the whole world if need be
+      360 * vt.degrees / g.getMetersPerUnit()
+    )) / un / Math.pow(2, rt), y = M / Math.pow(2, 28 - rt);
+    e = n.maxResolution, e !== void 0 ? o = 0 : e = M / Math.pow(a, o), i = n.minResolution, i === void 0 && (n.maxZoom !== void 0 ? n.maxResolution !== void 0 ? i = e / Math.pow(a, u) : i = M / Math.pow(a, u) : i = y), u = o + Math.floor(
+      Math.log(e / i) / Math.log(a)
+    ), i = e / Math.pow(a, u - o), n.constrainResolution ? t = cn(
+      a,
+      e,
+      i,
+      l,
+      !d && R,
+      c
+    ) : t = Ot(
+      e,
+      i,
+      l,
+      !d && R,
+      c
+    );
+  }
+  return {
+    constraint: t,
+    maxResolution: e,
+    minResolution: i,
+    minZoom: o,
+    zoomFactor: a
+  };
+}
+function Fn(n) {
+  if (n.enableRotation !== void 0 ? n.enableRotation : !0) {
+    const e = n.constrainRotation;
+    return e === void 0 || e === !0 ? dn() : e === !1 ? xt : typeof e == "number" ? fn(e) : xt;
+  }
+  return gn;
+}
+function Zn(n) {
+  return !(n.sourceCenter && n.targetCenter && !B(n.sourceCenter, n.targetCenter) || n.sourceResolution !== n.targetResolution || n.sourceRotation !== n.targetRotation);
+}
+function st(n, t, e, i, r) {
+  const s = Math.cos(-r);
+  let o = Math.sin(-r), u = n[0] * s - n[1] * o, a = n[1] * s + n[0] * o;
+  u += (t[0] / 2 - e[0]) * i, a += (e[1] - t[1] / 2) * i, o = -o;
+  const h = u * s - a * o, l = a * s + u * o;
+  return [h, l];
+}
+class Ii extends on {
+  /**
+   * @param {Options<SourceType>} options Layer options.
+   */
+  constructor(t) {
+    const e = Object.assign({}, t);
+    delete e.source, super(e), this.on, this.once, this.un, this.mapPrecomposeKey_ = null, this.mapRenderKey_ = null, this.sourceChangeKey_ = null, this.renderer_ = null, this.sourceReady_ = !1, this.rendered = !1, t.render && (this.render = t.render), t.map && this.setMap(t.map), this.addChangeListener(
+      m.SOURCE,
+      this.handleSourcePropertyChange_
+    );
+    const i = t.source ? (
+      /** @type {SourceType} */
+      t.source
+    ) : null;
+    this.setSource(i);
+  }
+  /**
+   * @param {Array<import("./Layer.js").default>} [array] Array of layers (to be modified in place).
+   * @return {Array<import("./Layer.js").default>} Array of layers.
+   */
+  getLayersArray(t) {
+    return t = t || [], t.push(this), t;
+  }
+  /**
+   * @param {Array<import("./Layer.js").State>} [states] Optional list of layer states (to be modified in place).
+   * @return {Array<import("./Layer.js").State>} List of layer states.
+   */
+  getLayerStatesArray(t) {
+    return t = t || [], t.push(this.getLayerState()), t;
+  }
+  /**
+   * Get the layer source.
+   * @return {SourceType|null} The layer source (or `null` if not yet set).
+   * @observable
+   * @api
+   */
+  getSource() {
+    return (
+      /** @type {SourceType} */
+      this.get(m.SOURCE) || null
+    );
+  }
+  /**
+   * @return {SourceType|null} The source being rendered.
+   */
+  getRenderSource() {
+    return this.getSource();
+  }
+  /**
+   * @return {import("../source/Source.js").State} Source state.
+   */
+  getSourceState() {
+    const t = this.getSource();
+    return t ? t.getState() : "undefined";
+  }
+  /**
+   * @private
+   */
+  handleSourceChange_() {
+    this.changed(), !(this.sourceReady_ || this.getSource().getState() !== "ready") && (this.sourceReady_ = !0, this.dispatchEvent("sourceready"));
+  }
+  /**
+   * @private
+   */
+  handleSourcePropertyChange_() {
+    this.sourceChangeKey_ && (nt(this.sourceChangeKey_), this.sourceChangeKey_ = null), this.sourceReady_ = !1;
+    const t = this.getSource();
+    t && (this.sourceChangeKey_ = it(
+      t,
+      Ct.CHANGE,
+      this.handleSourceChange_,
+      this
+    ), t.getState() === "ready" && (this.sourceReady_ = !0, setTimeout(() => {
+      this.dispatchEvent("sourceready");
+    }, 0))), this.changed();
+  }
+  /**
+   * @param {import("../pixel").Pixel} pixel Pixel.
+   * @return {Promise<Array<import("../Feature").FeatureLike>>} Promise that resolves with
+   * an array of features.
+   */
+  getFeatures(t) {
+    return this.renderer_ ? this.renderer_.getFeatures(t) : Promise.resolve([]);
+  }
+  /**
+   * @param {import("../pixel").Pixel} pixel Pixel.
+   * @return {Uint8ClampedArray|Uint8Array|Float32Array|DataView|null} Pixel data.
+   */
+  getData(t) {
+    return !this.renderer_ || !this.rendered ? null : this.renderer_.getData(t);
+  }
+  /**
+   * The layer is visible on the map view, i.e. within its min/max resolution or zoom and
+   * extent, not set to `visible: false`, and not inside a layer group that is set
+   * to `visible: false`.
+   * @param {View|import("../View.js").ViewStateLayerStateExtent} [view] View or {@link import("../Map.js").FrameState}.
+   * Only required when the layer is not added to a map.
+   * @return {boolean} The layer is visible in the map view.
+   * @api
+   */
+  isVisible(t) {
+    let e;
+    const i = this.getMapInternal();
+    !t && i && (t = i.getView()), t instanceof Gt ? e = {
+      viewState: t.getState(),
+      extent: t.calculateExtent()
+    } : e = t, !e.layerStatesArray && i && (e.layerStatesArray = i.getLayerGroup().getLayerStatesArray());
+    let r;
+    e.layerStatesArray ? r = e.layerStatesArray.find(
+      (o) => o.layer === this
+    ) : r = this.getLayerState();
+    const s = this.getExtent();
+    return bn(r, e.viewState) && (!s || lt(s, e.extent));
+  }
+  /**
+   * Get the attributions of the source of this layer for the given view.
+   * @param {View|import("../View.js").ViewStateLayerStateExtent} [view] View or {@link import("../Map.js").FrameState}.
+   * Only required when the layer is not added to a map.
+   * @return {Array<string>} Attributions for this layer at the given view.
+   * @api
+   */
+  getAttributions(t) {
+    if (!this.isVisible(t))
+      return [];
+    let e;
+    const i = this.getSource();
+    if (i && (e = i.getAttributions()), !e)
+      return [];
+    const r = t instanceof Gt ? t.getViewStateAndExtent() : t;
+    let s = e(r);
+    return Array.isArray(s) || (s = [s]), s;
+  }
+  /**
+   * In charge to manage the rendering of the layer. One layer type is
+   * bounded with one layer renderer.
+   * @param {?import("../Map.js").FrameState} frameState Frame state.
+   * @param {HTMLElement} target Target which the renderer may (but need not) use
+   * for rendering its content.
+   * @return {HTMLElement|null} The rendered element.
+   */
+  render(t, e) {
+    const i = this.getRenderer();
+    return i.prepareFrame(t) ? (this.rendered = !0, i.renderFrame(t, e)) : null;
+  }
+  /**
+   * Called when a layer is not visible during a map render.
+   */
+  unrender() {
+    this.rendered = !1;
+  }
+  /**
+   * For use inside the library only.
+   * @param {import("../Map.js").default|null} map Map.
+   */
+  setMapInternal(t) {
+    t || this.unrender(), this.set(m.MAP, t);
+  }
+  /**
+   * For use inside the library only.
+   * @return {import("../Map.js").default|null} Map.
+   */
+  getMapInternal() {
+    return this.get(m.MAP);
+  }
+  /**
+   * Sets the layer to be rendered on top of other layers on a map. The map will
+   * not manage this layer in its layers collection. This
+   * is useful for temporary layers. To remove an unmanaged layer from the map,
+   * use `#setMap(null)`.
+   *
+   * To add the layer to a map and have it managed by the map, use
+   * {@link module:ol/Map~Map#addLayer} instead.
+   * @param {import("../Map.js").default|null} map Map.
+   * @api
+   */
+  setMap(t) {
+    this.mapPrecomposeKey_ && (nt(this.mapPrecomposeKey_), this.mapPrecomposeKey_ = null), t || this.changed(), this.mapRenderKey_ && (nt(this.mapRenderKey_), this.mapRenderKey_ = null), t && (this.mapPrecomposeKey_ = it(
+      t,
+      an.PRECOMPOSE,
+      function(e) {
+        const r = /** @type {import("../render/Event.js").default} */ e.frameState.layerStatesArray, s = this.getLayerState(!1);
+        p(
+          !r.some(function(o) {
+            return o.layer === s.layer;
+          }),
+          67
+        ), r.push(s);
+      },
+      this
+    ), this.mapRenderKey_ = it(this, Ct.CHANGE, t.render, t), this.changed());
+  }
+  /**
+   * Set the layer source.
+   * @param {SourceType|null} source The layer source.
+   * @observable
+   * @api
+   */
+  setSource(t) {
+    this.set(m.SOURCE, t);
+  }
+  /**
+   * Get the renderer for this layer.
+   * @return {RendererType|null} The layer renderer.
+   */
+  getRenderer() {
+    return this.renderer_ || (this.renderer_ = this.createRenderer()), this.renderer_;
+  }
+  /**
+   * @return {boolean} The layer has a renderer.
+   */
+  hasRenderer() {
+    return !!this.renderer_;
+  }
+  /**
+   * Create a renderer for this layer.
+   * @return {RendererType} A layer renderer.
+   * @protected
+   */
+  createRenderer() {
+    return null;
+  }
+  /**
+   * Clean up.
+   */
+  disposeInternal() {
+    this.renderer_ && (this.renderer_.dispose(), delete this.renderer_), this.setSource(null), super.disposeInternal();
+  }
+}
+function bn(n, t) {
+  if (!n.visible)
+    return !1;
+  const e = t.resolution;
+  if (e < n.minResolution || e >= n.maxResolution)
+    return !1;
+  const i = t.zoom;
+  return i > n.minZoom && i <= n.maxZoom;
+}
+class Si extends H {
+  /**
+   * @param {Options} options Source options.
+   */
+  constructor(t) {
+    super(), this.projection = T(t.projection), this.attributions_ = jt(t.attributions), this.attributionsCollapsible_ = t.attributionsCollapsible !== void 0 ? t.attributionsCollapsible : !0, this.loading = !1, this.state_ = t.state !== void 0 ? t.state : "ready", this.wrapX_ = t.wrapX !== void 0 ? t.wrapX : !1, this.interpolate_ = !!t.interpolate, this.viewResolver = null, this.viewRejector = null;
+    const e = this;
+    this.viewPromise_ = new Promise(function(i, r) {
+      e.viewResolver = i, e.viewRejector = r;
+    });
+  }
+  /**
+   * Get the attribution function for the source.
+   * @return {?Attribution} Attribution function.
+   * @api
+   */
+  getAttributions() {
+    return this.attributions_;
+  }
+  /**
+   * @return {boolean} Attributions are collapsible.
+   * @api
+   */
+  getAttributionsCollapsible() {
+    return this.attributionsCollapsible_;
+  }
+  /**
+   * Get the projection of the source.
+   * @return {import("../proj/Projection.js").default|null} Projection.
+   * @api
+   */
+  getProjection() {
+    return this.projection;
+  }
+  /**
+   * @param {import("../proj/Projection").default} [projection] Projection.
+   * @return {Array<number>|null} Resolutions.
+   */
+  getResolutions(t) {
+    return null;
+  }
+  /**
+   * @return {Promise<import("../View.js").ViewOptions>} A promise for view-related properties.
+   */
+  getView() {
+    return this.viewPromise_;
+  }
+  /**
+   * Get the state of the source, see {@link import("./Source.js").State} for possible states.
+   * @return {import("./Source.js").State} State.
+   * @api
+   */
+  getState() {
+    return this.state_;
+  }
+  /**
+   * @return {boolean|undefined} Wrap X.
+   */
+  getWrapX() {
+    return this.wrapX_;
+  }
+  /**
+   * @return {boolean} Use linear interpolation when resampling.
+   */
+  getInterpolate() {
+    return this.interpolate_;
+  }
+  /**
+   * Refreshes the source. The source will be cleared, and data from the server will be reloaded.
+   * @api
+   */
+  refresh() {
+    this.changed();
+  }
+  /**
+   * Set the attributions of the source.
+   * @param {AttributionLike|undefined} attributions Attributions.
+   *     Can be passed as `string`, `Array<string>`, {@link module:ol/source/Source~Attribution},
+   *     or `undefined`.
+   * @api
+   */
+  setAttributions(t) {
+    this.attributions_ = jt(t), this.changed();
+  }
+  /**
+   * Set the state of the source.
+   * @param {import("./Source.js").State} state State.
+   */
+  setState(t) {
+    this.state_ = t, this.changed();
+  }
+}
+function jt(n) {
+  return n ? Array.isArray(n) ? function(t) {
+    return n;
+  } : typeof n == "function" ? n : function(t) {
+    return [n];
+  } : null;
+}
+export {
+  lt as $,
+  _n as A,
+  on as B,
+  oi as C,
+  Kn as D,
+  Ke as E,
+  gn as F,
+  en as G,
+  ni as H,
+  P as I,
+  Ge as J,
+  tt as K,
+  Ii as L,
+  Yn as M,
+  Q as N,
+  Ln as O,
+  _t as P,
+  qe as Q,
+  an as R,
+  Si as S,
+  Le as T,
+  ve as U,
+  Gt as V,
+  Xe as W,
+  be as X,
+  Rn as Y,
+  q as Z,
+  Un as _,
+  ti as a,
+  xe as a0,
+  zn as a1,
+  X as a2,
+  L as a3,
+  Ze as a4,
+  Hn as a5,
+  vn as a6,
+  je as a7,
+  si as a8,
+  T as a9,
+  gi as aA,
+  yi as aB,
+  hi as aC,
+  En as aD,
+  J as aE,
+  Sn as aF,
+  yn as aG,
+  Dn as aH,
+  Te as aI,
+  De as aJ,
+  pt as aK,
+  C as aL,
+  F as aM,
+  Bt as aN,
+  ei as aO,
+  ai as aP,
+  ii as aQ,
+  Ve as aR,
+  $n as aS,
+  Qn as aa,
+  Rt as ab,
+  zt as ac,
+  qt as ad,
+  $t as ae,
+  wn as af,
+  ie as ag,
+  ee as ah,
+  yt as ai,
+  Qt as aj,
+  Ht as ak,
+  Jt as al,
+  re as am,
+  ci as an,
+  mi as ao,
+  te as ap,
+  Ut as aq,
+  Oe as ar,
+  ui as as,
+  li as at,
+  Ri as au,
+  di as av,
+  Ci as aw,
+  fi as ax,
+  _i as ay,
+  Mi as az,
+  Jn as b,
+  Gn as c,
+  Ne as d,
+  kn as e,
+  w as f,
+  B as g,
+  Pt as h,
+  V as i,
+  Qe as j,
+  jn as k,
+  We as l,
+  Bn as m,
+  Zt as n,
+  Y as o,
+  $ as p,
+  Wn as q,
+  Ei as r,
+  Dt as s,
+  kt as t,
+  rn as u,
+  ri as v,
+  qn as w,
+  A as x,
+  bn as y,
+  Vn as z
+};